Free cookie consent management tool by TermsFeed Policy Generator

Changeset 14505 for branches


Ignore:
Timestamp:
12/19/16 16:59:14 (7 years ago)
Author:
bburlacu
Message:

#2704: Improve expression generation and fix file formatting.

Location:
branches/HeuristicLab.ExpressionGenerator/HeuristicLab.ExpressionGenerator/3.4
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed

  • branches/HeuristicLab.ExpressionGenerator/HeuristicLab.ExpressionGenerator/3.4/Expression.cs

    r14480 r14505  
    2929
    3030namespace HeuristicLab.ExpressionGenerator {
    31     public class Expression : IExpression {
    32         // unique name for each expression
    33         public string Name { get; set; }
    34         // optional label (non-unique) - useful for string (infix) representations
    35         public string Label { get; set; }
     31  public class Expression : IExpression {
     32    // unique name for each expression
     33    public string Name { get; set; }
     34    // optional label (non-unique) - useful for string (infix) representations
     35    public string Label { get; set; }
    3636
    37         public ExpressionType Type { get; private set; }
     37    public ExpressionType Type { get; private set; }
    3838
    39         private readonly List<Expression> arguments;
    40         public IEnumerable<Expression> Arguments {
    41             get { return arguments ?? Enumerable.Empty<Expression>(); }
     39    private readonly List<Expression> arguments;
     40    public IEnumerable<Expression> Arguments {
     41      get { return arguments ?? Enumerable.Empty<Expression>(); }
     42    }
     43
     44    public IRandom Distribution { get; private set; }
     45
     46    public Func<IEnumerable<double>, double> Transform { get; private set; }
     47
     48    public double Value { get; private set; }
     49
     50    public Expression(string name, double value) {
     51      Type = ExpressionType.Constant;
     52      Value = value;
     53      Name = name;
     54    }
     55
     56    public Expression(string name, IRandom distribution) {
     57      Type = ExpressionType.RandomVariable;
     58      Distribution = distribution;
     59      Name = name;
     60    }
     61
     62    public Expression(string name, Func<IEnumerable<double>, double> transform, IEnumerable<Expression> arguments) {
     63      Type = ExpressionType.Function;
     64      Transform = transform;
     65      this.arguments = this.arguments ?? new List<Expression>();
     66      this.arguments.AddRange(arguments);
     67      Name = name;
     68    }
     69
     70    public static Expression Constant(string name, double value) {
     71      return new Expression(name, value);
     72    }
     73
     74    public static Expression RandomVariable(string name, IRandom distribution) {
     75      return new Expression(name, distribution);
     76    }
     77
     78    public static Expression Function(string name, Func<IEnumerable<double>, double> transform, IEnumerable<Expression> arguments) {
     79      return new Expression(name, transform, arguments);
     80    }
     81
     82    public override string ToString() {
     83      var sb = new StringBuilder();
     84
     85      switch (Type) {
     86        case ExpressionType.Constant:
     87          sb.Append(Value.ToString("0.000", CultureInfo.CurrentCulture));
     88          break;
     89        case ExpressionType.RandomVariable:
     90          sb.Append(string.Format("{0} ~ {1}", Name, GetStringDescription(Distribution)));
     91          break;
     92        case ExpressionType.Function:
     93          sb.Append(string.Format("{0} = f(", Name));
     94          if (Arguments.Any()) {
     95            for (int i = 0; i < arguments.Count - 1; ++i)
     96              sb.Append(string.Format("{0}, ", arguments[i].Name));
     97            sb.Append(string.Format("{0})", arguments.Last().Name));
     98          }
     99          break;
     100      }
     101
     102      return sb.ToString();
     103    }
     104
     105    public string PrintInfix() {
     106      var sb = new StringBuilder();
     107      switch (Type) {
     108        case ExpressionType.Constant:
     109          sb.Append(Value < 0
     110              ? string.Format("(- {0})", Math.Abs(Value).ToString("0.000", CultureInfo.CurrentCulture))
     111              : Value.ToString("0.000", CultureInfo.CurrentCulture));
     112          break;
     113        case ExpressionType.RandomVariable:
     114          sb.Append(Name);
     115          break;
     116        case ExpressionType.Function:
     117          if (!Arguments.Any())
     118            break;
     119          var args = Arguments.ToList();
     120          sb.Append("(");
     121          // the Label should be known to the infix parser
     122          if (Label == "+" || Label == "-" || Label == "*" || Label == "/") {
     123            if (args.Count == 1) {
     124              sb.Append(string.Format("{0}", args[0].PrintInfix()));
     125            } else {
     126              sb.Append("(");
     127              var last = args.Last();
     128              for (int i = 0; i < args.Count - 1; ++i) {
     129                var arg = args[i];
     130                sb.Append(string.Format("{0} {1} ", arg.PrintInfix(), Label));
     131              }
     132              sb.Append(string.Format("{0})", last.PrintInfix()));
     133            }
     134          } else {
     135            sb.Append(string.Format("{0}(", Label));
     136            var last = args.Last();
     137            for (int i = 0; i < args.Count - 1; ++i) {
     138              var arg = args[i];
     139              sb.Append(string.Format("{0}, ", arg.PrintInfix(), Label));
     140            }
     141            sb.Append(string.Format("{0})", last.PrintInfix()));
     142          }
     143          sb.Append(")");
     144          break;
     145      }
     146      return sb.ToString();
     147    }
     148
     149    public string PrintDot() {
     150      var stack = new Stack<Expression>();
     151      stack.Push(this);
     152
     153      var sb = new StringBuilder();
     154      sb.AppendLine("digraph g {");
     155
     156      while (stack.Count > 0) {
     157        var top = stack.Pop();
     158
     159        if (!top.Arguments.Any())
     160          continue;
     161
     162        foreach (var arg in top.Arguments) {
     163          var from = top.Arguments.Any() ? top.Name : top.ToString();
     164          var to = arg.Arguments.Any() ? arg.Name : arg.ToString();
     165          sb.AppendLine(string.Format("\"{0}\" -> \"{1}\";", from, to));
     166          stack.Push(arg);
    42167        }
     168      }
    43169
    44         public IRandom Distribution { get; private set; }
     170      sb.AppendLine("}");
     171      return sb.ToString();
     172    }
    45173
    46         public Func<IEnumerable<double>, double> Transform { get; private set; }
     174    private static string GetStringDescription(IRandom random) {
     175      var normal = random as NormalDistributedRandom;
     176      if (normal != null)
     177        return string.Format("N({0}, {1})", normal.Mu, normal.Sigma);
    47178
    48         public double Value { get; private set; }
     179      var uniform = random as UniformDistributedRandom;
     180      if (uniform != null)
     181        return string.Format("U({0}, {1})", uniform.Min, uniform.Max);
    49182
    50         public Expression(string name, double value) {
    51             Type = ExpressionType.Constant;
    52             Value = value;
    53             Name = name;
    54         }
     183      var gamma = random as GammaDistributedRandom;
     184      if (gamma != null)
     185        return string.Format("G({0}, {1})", gamma.Shape, gamma.Rate);
    55186
    56         public Expression(string name, IRandom distribution) {
    57             Type = ExpressionType.RandomVariable;
    58             Distribution = distribution;
    59             Name = name;
    60         }
    61 
    62         public Expression(string name, Func<IEnumerable<double>, double> transform, IEnumerable<Expression> arguments) {
    63             Type = ExpressionType.Function;
    64             Transform = transform;
    65             this.arguments = this.arguments ?? new List<Expression>();
    66             this.arguments.AddRange(arguments);
    67             Name = name;
    68         }
    69 
    70         public static Expression Constant(string name, double value) {
    71             return new Expression(name, value);
    72         }
    73 
    74         public static Expression RandomVariable(string name, IRandom distribution) {
    75             return new Expression(name, distribution);
    76         }
    77 
    78         public static Expression Function(string name, Func<IEnumerable<double>, double> transform, IEnumerable<Expression> arguments) {
    79             return new Expression(name, transform, arguments);
    80         }
    81 
    82         public override string ToString() {
    83             var sb = new StringBuilder();
    84 
    85             switch (Type) {
    86                 case ExpressionType.Constant:
    87                     sb.Append(Value.ToString("0.000", CultureInfo.CurrentCulture));
    88                     break;
    89                 case ExpressionType.RandomVariable:
    90                     sb.Append(string.Format("{0} ~ {1}", Name, GetStringDescription(Distribution)));
    91                     break;
    92                 case ExpressionType.Function:
    93                     sb.Append(string.Format("{0} = f(", Name));
    94                     if (Arguments.Any()) {
    95                         for (int i = 0; i < arguments.Count - 1; ++i)
    96                             sb.Append(string.Format("{0}, ", arguments[i].Name));
    97                         sb.Append(string.Format("{0})", arguments.Last().Name));
    98                     }
    99                     break;
    100             }
    101 
    102             return sb.ToString();
    103         }
    104 
    105         public string PrintInfix() {
    106             var sb = new StringBuilder();
    107             switch (Type) {
    108                 case ExpressionType.Constant:
    109                     sb.Append(Value < 0
    110                         ? string.Format("(- {0})", Math.Abs(Value).ToString("0.000", CultureInfo.CurrentCulture))
    111                         : Value.ToString("0.000", CultureInfo.CurrentCulture));
    112                     break;
    113                 case ExpressionType.RandomVariable:
    114                     sb.Append(Name);
    115                     break;
    116                 case ExpressionType.Function:
    117                     if (!Arguments.Any())
    118                         break;
    119                     var args = Arguments.ToList();
    120                     sb.Append("(");
    121                     // the Label should be known to the infix parser
    122                     if (Label == "+" || Label == "-" || Label == "*" || Label == "/") {
    123                         if (args.Count == 1) {
    124                             sb.Append(string.Format("{0}", args[0].PrintInfix()));
    125                         } else {
    126                             sb.Append("(");
    127                             var last = args.Last();
    128                             for (int i = 0; i < args.Count - 1; ++i) {
    129                                 var arg = args[i];
    130                                 sb.Append(string.Format("{0} {1}", arg.PrintInfix(), Label));
    131                             }
    132                             sb.Append(string.Format(" {0})", last.PrintInfix()));
    133                         }
    134                     } else {
    135                         sb.Append(string.Format("{0}(", Label));
    136                         var last = args.Last();
    137                         for (int i = 0; i < args.Count - 1; ++i) {
    138                             var arg = args[i];
    139                             sb.Append(string.Format("{0}, ", arg.PrintInfix(), Label));
    140                         }
    141                         sb.Append(string.Format("{0})", last.PrintInfix()));
    142                     }
    143                     sb.Append(")");
    144                     break;
    145             }
    146             return sb.ToString();
    147         }
    148 
    149         public string PrintDot() {
    150             var stack = new Stack<Expression>();
    151             stack.Push(this);
    152 
    153             var sb = new StringBuilder();
    154             sb.AppendLine("digraph g {");
    155 
    156             while (stack.Count > 0) {
    157                 var top = stack.Pop();
    158 
    159                 if (!top.Arguments.Any())
    160                     continue;
    161 
    162                 foreach (var arg in top.Arguments) {
    163                     var from = top.Arguments.Any() ? top.Name : top.ToString();
    164                     var to = arg.Arguments.Any() ? arg.Name : arg.ToString();
    165                     sb.AppendLine(string.Format("\"{0}\" -> \"{1}\";", from, to));
    166                     stack.Push(arg);
    167                 }
    168             }
    169 
    170             sb.AppendLine("}");
    171             return sb.ToString();
    172         }
    173 
    174         private static string GetStringDescription(IRandom random) {
    175             var normal = random as NormalDistributedRandom;
    176             if (normal != null)
    177                 return string.Format("N({0}, {1})", normal.Mu, normal.Sigma);
    178 
    179             var uniform = random as UniformDistributedRandom;
    180             if (uniform != null)
    181                 return string.Format("U({0}, {1})", uniform.Min, uniform.Max);
    182 
    183             var gamma = random as GammaDistributedRandom;
    184             if (gamma != null)
    185                 return string.Format("G({0}, {1})", gamma.Shape, gamma.Rate);
    186 
    187             return random.ToString();
    188         }
     187      return random.ToString();
    189188    }
     189  }
    190190}

  • branches/HeuristicLab.ExpressionGenerator/HeuristicLab.ExpressionGenerator/3.4/HeuristicLab.ExpressionGenerator.csproj

    r14480 r14505  
    7474    <Compile Include="Expression.cs" />
    7575    <Compile Include="ExpressionEvaluator.cs" />
     76    <Compile Include="ExpressionGenerator.cs" />
    7677    <Compile Include="ExpressionTemplate.cs" />
    7778    <Compile Include="Interfaces\IExpression.cs" />
Note: See TracChangeset for help on using the changeset viewer.