Free cookie consent management tool by TermsFeed Policy Generator

source: branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs @ 18114

Last change on this file since 18114 was 18114, checked in by gkronber, 2 years ago

#3140: made several more changes while reviewing the branch.

File size: 15.2 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Globalization;
25using System.Linq;
26using System.Text;
27using System.Text.RegularExpressions;
28using HEAL.Attic;
29using HeuristicLab.Common;
30using HeuristicLab.Core;
31using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
32
33namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
34  [Item("C# Symbolic Expression Tree Formatter", "A string formatter that converts symbolic expression trees to C# code.")]
35  [StorableType("88298836-6087-405A-9354-D4E6864887EB")]
36  public sealed class CSharpSymbolicExpressionTreeStringFormatter : NamedItem, ISymbolicExpressionTreeStringFormatter {
37    [StorableConstructor]
38    private CSharpSymbolicExpressionTreeStringFormatter(StorableConstructorFlag _) : base(_) { }
39    private CSharpSymbolicExpressionTreeStringFormatter(CSharpSymbolicExpressionTreeStringFormatter original, Cloner cloner) : base(original, cloner) { }
40    public CSharpSymbolicExpressionTreeStringFormatter()
41      : base() {
42      Name = ItemName;
43      Description = ItemDescription;
44    }
45    public override IDeepCloneable Clone(Cloner cloner) {
46      return new CSharpSymbolicExpressionTreeStringFormatter(this, cloner);
47    }
48
49    public string Format(ISymbolicExpressionTree symbolicExpressionTree) {
50      // skip root and start symbols
51      StringBuilder strBuilder = new StringBuilder();
52      GenerateHeader(strBuilder, symbolicExpressionTree);
53      FormatRecursively(symbolicExpressionTree.Root.GetSubtree(0).GetSubtree(0), strBuilder);
54      GenerateFooter(strBuilder);
55      return strBuilder.ToString();
56    }
57
58    private string VariableName2Identifier(string name) {
59      /*
60       * identifier-start-character:
61       *    letter-character
62       *    _ (the underscore character U+005F)
63       *  identifier-part-characters:
64       *    identifier-part-character
65       *    identifier-part-characters   identifier-part-character
66       *  identifier-part-character:
67       *    letter-character
68       *    decimal-digit-character
69       *    connecting-character
70       *    combining-character
71       *    formatting-character
72       *  letter-character:
73       *    A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl
74       *    A unicode-escape-sequence representing a character of classes Lu, Ll, Lt, Lm, Lo, or Nl
75       *  combining-character:
76       *    A Unicode character of classes Mn or Mc
77       *    A unicode-escape-sequence representing a character of classes Mn or Mc
78       *  decimal-digit-character:
79       *    A Unicode character of the class Nd
80       *    A unicode-escape-sequence representing a character of the class Nd
81       *  connecting-character:
82       *    A Unicode character of the class Pc
83       *    A unicode-escape-sequence representing a character of the class Pc
84       *  formatting-character:
85       *    A Unicode character of the class Cf
86       *    A unicode-escape-sequence representing a character of the class Cf
87       */
88
89      var invalidIdentifierStarts = new Regex(@"[^_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Lo}\p{Nl}]");
90      var invalidIdentifierParts = new Regex(@"[^\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Lo}\p{Nl}\p{Mn}\p{Mc}\p{Nd}\p{Pc}\p{Cf}]");
91      return "@" +
92        (invalidIdentifierStarts.IsMatch(name.Substring(0, 1)) ? "_" : "") + // prepend '_' if necessary
93        invalidIdentifierParts.Replace(name, "_");
94    }
95
96    private void FormatRecursively(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
97      // TODO: adapt to interpreter semantics. The HL interpreter also allows Boolean operations on reals
98      if (node.Subtrees.Any()) {
99        if (node.Symbol is Addition) {
100          FormatOperator(node, "+", strBuilder);
101        } else if (node.Symbol is And) {
102          FormatOperator(node, "&&", strBuilder);
103        } else if (node.Symbol is Average) {
104          FormatFunction(node, "Average", strBuilder);
105        } else if (node.Symbol is Cosine) {
106          FormatFunction(node, "Math.Cos", strBuilder);
107        } else if (node.Symbol is Division) {
108          FormatDivision(node, strBuilder);
109        } else if (node.Symbol is Exponential) {
110          FormatFunction(node, "Math.Exp", strBuilder);
111        } else if (node.Symbol is GreaterThan) {
112          FormatOperator(node, ">", strBuilder);
113        } else if (node.Symbol is IfThenElse) {
114          FormatFunction(node, "EvaluateIf", strBuilder);
115        } else if (node.Symbol is LessThan) {
116          FormatOperator(node, "<", strBuilder);
117        } else if (node.Symbol is Logarithm) {
118          FormatFunction(node, "Math.Log", strBuilder);
119        } else if (node.Symbol is Multiplication) {
120          FormatOperator(node, "*", strBuilder);
121        } else if (node.Symbol is Not) {
122          FormatOperator(node, "!", strBuilder);
123        } else if (node.Symbol is Or) {
124          FormatOperator(node, "||", strBuilder);
125        } else if (node.Symbol is Xor) {
126          FormatOperator(node, "^", strBuilder);
127        } else if (node.Symbol is Sine) {
128          FormatFunction(node, "Math.Sin", strBuilder);
129        } else if (node.Symbol is Subtraction) {
130          FormatSubtraction(node, strBuilder);
131        } else if (node.Symbol is Tangent) {
132          FormatFunction(node, "Math.Tan", strBuilder);
133        } else if (node.Symbol is HyperbolicTangent) {
134          FormatFunction(node, "Math.Tanh", strBuilder);
135        } else if (node.Symbol is Square) {
136          FormatSquare(node, strBuilder);
137        } else if (node.Symbol is SquareRoot) {
138          FormatFunction(node, "Math.Sqrt", strBuilder);
139        } else if (node.Symbol is Cube) {
140          FormatPower(node, strBuilder, "3");
141        } else if (node.Symbol is CubeRoot) {
142          strBuilder.Append("Cbrt(");
143          FormatRecursively(node.GetSubtree(0), strBuilder);
144          strBuilder.Append(")");
145        } else if (node.Symbol is Power) {
146          FormatFunction(node, "Math.Pow", strBuilder);
147        } else if (node.Symbol is Root) {
148          FormatRoot(node, strBuilder);
149        } else if (node.Symbol is Absolute) {
150          FormatFunction(node, "Math.Abs", strBuilder);
151        } else if (node.Symbol is AnalyticQuotient) {
152          strBuilder.Append("(");
153          FormatRecursively(node.GetSubtree(0), strBuilder);
154          strBuilder.Append(" / Math.Sqrt(1 + Math.Pow(");
155          FormatRecursively(node.GetSubtree(1), strBuilder);
156          strBuilder.Append(" , 2) ) )");
157        } else {
158          throw new NotSupportedException("Formatting of symbol: " + node.Symbol + " not supported for C# symbolic expression tree formatter.");
159        }
160      } else {
161        if (node is VariableTreeNode) {
162          var varNode = node as VariableTreeNode;
163          strBuilder.AppendFormat("{0} * {1}", VariableName2Identifier(varNode.VariableName), varNode.Weight.ToString("g17", CultureInfo.InvariantCulture));
164        } else if (node is INumericTreeNode numNode) {
165          strBuilder.Append(numNode.Value.ToString("g17", CultureInfo.InvariantCulture));
166        } else if (node.Symbol is FactorVariable) {
167          var factorNode = node as FactorVariableTreeNode;
168          FormatFactor(factorNode, strBuilder);
169        } else if (node.Symbol is BinaryFactorVariable) {
170          var binFactorNode = node as BinaryFactorVariableTreeNode;
171          FormatBinaryFactor(binFactorNode, strBuilder);
172        } else {
173          throw new NotSupportedException("Formatting of symbol: " + node.Symbol + " not supported for C# symbolic expression tree formatter.");
174        }
175      }
176    }
177
178    private void FormatFactor(FactorVariableTreeNode node, StringBuilder strBuilder) {
179      strBuilder.AppendFormat("EvaluateFactor({0}, new [] {{ {1} }}, new [] {{ {2} }})", VariableName2Identifier(node.VariableName),
180        string.Join(",", node.Symbol.GetVariableValues(node.VariableName).Select(name => "\"" + name + "\"")), string.Join(",", node.Weights.Select(v => v.ToString(CultureInfo.InvariantCulture))));
181    }
182
183    private void FormatBinaryFactor(BinaryFactorVariableTreeNode node, StringBuilder strBuilder) {
184      strBuilder.AppendFormat(CultureInfo.InvariantCulture, "EvaluateBinaryFactor({0}, \"{1}\", {2})", VariableName2Identifier(node.VariableName), node.VariableValue, node.Weight);
185    }
186
187    private void FormatSquare(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
188      FormatPower(node, strBuilder, "2");
189    }
190    private void FormatPower(ISymbolicExpressionTreeNode node, StringBuilder strBuilder, string exponent) {
191      strBuilder.Append("Math.Pow(");
192      FormatRecursively(node.GetSubtree(0), strBuilder);
193      strBuilder.Append($", {exponent})");
194    }
195
196    private void FormatRoot(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
197      strBuilder.Append("Math.Pow(");
198      FormatRecursively(node.GetSubtree(0), strBuilder);
199      strBuilder.Append(", 1.0 / (");
200      FormatRecursively(node.GetSubtree(1), strBuilder);
201      strBuilder.Append("))");
202    }
203
204    private void FormatDivision(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
205      if (node.SubtreeCount == 1) {
206        strBuilder.Append("1.0 / ");
207        FormatRecursively(node.GetSubtree(0), strBuilder);
208      } else {
209        FormatRecursively(node.GetSubtree(0), strBuilder);
210        strBuilder.Append("/ (");
211        for (int i = 1; i < node.SubtreeCount; i++) {
212          if (i > 1) strBuilder.Append(" * ");
213          FormatRecursively(node.GetSubtree(i), strBuilder);
214        }
215        strBuilder.Append(")");
216      }
217    }
218
219    private void FormatSubtraction(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
220      if (node.SubtreeCount == 1) {
221        strBuilder.Append("-");
222        FormatRecursively(node.GetSubtree(0), strBuilder);
223        return;
224      }
225      //Default case: more than 1 child
226      FormatOperator(node, "-", strBuilder);
227    }
228
229    private void FormatOperator(ISymbolicExpressionTreeNode node, string symbol, StringBuilder strBuilder) {
230      strBuilder.Append("(");
231      foreach (var child in node.Subtrees) {
232        FormatRecursively(child, strBuilder);
233        if (child != node.Subtrees.Last())
234          strBuilder.Append(" " + symbol + " ");
235      }
236      strBuilder.Append(")");
237    }
238
239    private void FormatFunction(ISymbolicExpressionTreeNode node, string function, StringBuilder strBuilder) {
240      strBuilder.Append(function + "(");
241      foreach (var child in node.Subtrees) {
242        FormatRecursively(child, strBuilder);
243        if (child != node.Subtrees.Last())
244          strBuilder.Append(", ");
245      }
246      strBuilder.Append(")");
247    }
248
249    private void GenerateHeader(StringBuilder strBuilder, ISymbolicExpressionTree symbolicExpressionTree) {
250      strBuilder.AppendLine("using System;");
251      strBuilder.AppendLine("using System.Linq;" + Environment.NewLine);
252      strBuilder.AppendLine("namespace HeuristicLab.Models {");
253      strBuilder.AppendLine("public static class Model {");
254      GenerateAverageSource(strBuilder);
255      GenerateCbrtSource(strBuilder);
256      GenerateIfThenElseSource(strBuilder);
257      GenerateFactorSource(strBuilder);
258      GenerateBinaryFactorSource(strBuilder);
259      strBuilder.Append(Environment.NewLine + "public static double Evaluate (");
260
261      // here we don't have access to problemData to determine the type for each variable (double/string) therefore we must distinguish based on the symbol type
262      HashSet<string> doubleVarNames = new HashSet<string>();
263      foreach (var node in symbolicExpressionTree.IterateNodesPostfix().Where(x => x is VariableTreeNode || x is VariableConditionTreeNode)) {
264        doubleVarNames.Add(((IVariableTreeNode)node).VariableName);
265      }
266
267      HashSet<string> stringVarNames = new HashSet<string>();
268      foreach (var node in symbolicExpressionTree.IterateNodesPostfix().Where(x => x is BinaryFactorVariableTreeNode || x is FactorVariableTreeNode)) {
269        stringVarNames.Add(((IVariableTreeNode)node).VariableName);
270      }
271
272      var orderedNames = stringVarNames.OrderBy(n => n, new NaturalStringComparer()).Select(n => "string " + VariableName2Identifier(n) + " /* " + n + " */");
273      strBuilder.Append(string.Join(", ", orderedNames));
274
275      if (stringVarNames.Any() && doubleVarNames.Any())
276        strBuilder.AppendLine(",");
277      orderedNames = doubleVarNames.OrderBy(n => n, new NaturalStringComparer()).Select(n => "double " + VariableName2Identifier(n) + " /* " + n + " */");
278      strBuilder.Append(string.Join(", ", orderedNames));
279
280
281      strBuilder.AppendLine(") {");
282      strBuilder.Append("double result = ");
283    }
284
285    private void GenerateFooter(StringBuilder strBuilder) {
286      strBuilder.AppendLine(";");
287
288      strBuilder.AppendLine("return result;");
289      strBuilder.AppendLine("}");
290      strBuilder.AppendLine("}");
291      strBuilder.AppendLine("}");
292    }
293
294    private void GenerateAverageSource(StringBuilder strBuilder) {
295      strBuilder.AppendLine("private static double Average(params double[] values) {");
296      strBuilder.AppendLine("  return values.Average();");
297      strBuilder.AppendLine("}");
298    }
299    private void GenerateCbrtSource(StringBuilder strBuilder) {
300      strBuilder.AppendLine("private static double Cbrt(double x) {");
301      strBuilder.AppendLine("  return x < 0 ? -Math.Pow(-x, 1.0 / 3.0) : Math.Pow(x, 1.0 / 3.0);");
302      strBuilder.AppendLine("}");
303    }
304
305    private void GenerateIfThenElseSource(StringBuilder strBuilder) {
306      strBuilder.AppendLine("private static double EvaluateIf(bool condition, double then, double @else) {");
307      strBuilder.AppendLine("   return condition ? then : @else;");
308      strBuilder.AppendLine("}");
309    }
310
311    private void GenerateFactorSource(StringBuilder strBuilder) {
312      strBuilder.AppendLine("private static double EvaluateFactor(string factorValue, string[] factorValues, double[] parameters) {");
313      strBuilder.AppendLine("   for(int i=0;i<factorValues.Length;i++) " +
314                            "      if(factorValues[i] == factorValue) return parameters[i];" +
315                            "   throw new ArgumentException();");
316      strBuilder.AppendLine("}");
317    }
318
319    private void GenerateBinaryFactorSource(StringBuilder strBuilder) {
320      strBuilder.AppendLine("private static double EvaluateBinaryFactor(string factorValue, string targetValue, double weight) {");
321      strBuilder.AppendLine("  return factorValue == targetValue ? weight : 0.0;");
322      strBuilder.AppendLine("}");
323    }
324
325  }
326}
Note: See TracBrowser for help on using the repository browser.