Changeset 5750 for branches/DataAnalysis Refactoring/HeuristicLab.Problems.ExternalEvaluation.GP/3.4/ExternalEvaluationSymbolicExpressionTreeStringFormatter.cs

Timestamp:

03/18/11 12:50:28 (13 years ago)

Author:

gkronber

Message:

#1418 Implemented variable view that allows to add and remove variable strings (ported from external evaluation views). Implemented formatter and grammar for external evaluation plugin. Fixed bug in symbolic expression view. Fixed bug in run collection variable impact view. Removed unused plugin HeuristicLab.Problems.ExternalEvaluation.GP.Views. Renamed files.

File:

• branches/DataAnalysis Refactoring/HeuristicLab.Problems.ExternalEvaluation.GP/3.4/ExternalEvaluationSymbolicExpressionTreeStringFormatter.cs (copied) (copied from branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Formatters/SymbolicExpressionTreeStringFormatter.cs) (4 diffs)

branches/DataAnalysis Refactoring/HeuristicLab.Problems.ExternalEvaluation.GP/3.4/ExternalEvaluationSymbolicExpressionTreeStringFormatter.cs

@@ -25 +25 @@
 using HeuristicLab.Common;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using System;
 
-namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
+namespace HeuristicLab.Problems.ExternalEvaluation.GP {
 
-  [Item("SymbolicExpressionTreeStringFormatter", "The default string formatter for symbolic expression trees.")]
+  [Item("ExternalEvaluationSymbolicExpressionTreeStringFormatter", "A string formatter for symbolic expression trees for external evaluation.")]
   [StorableClass]
-  public class SymbolicExpressionTreeStringFormatter : NamedItem, ISymbolicExpressionTreeStringFormatter {
+  public class ExternalEvaluationSymbolicExpressionTreeStringFormatter : NamedItem, ISymbolicExpressionTreeStringFormatter {
 
     public bool Indent { get; set; }
 
     [StorableConstructor]
-    protected SymbolicExpressionTreeStringFormatter(bool deserializing) : base(deserializing) { }
-    protected SymbolicExpressionTreeStringFormatter(SymbolicExpressionTreeStringFormatter original, Cloner cloner)
+    protected ExternalEvaluationSymbolicExpressionTreeStringFormatter(bool deserializing) : base(deserializing) { }
+    protected ExternalEvaluationSymbolicExpressionTreeStringFormatter(ExternalEvaluationSymbolicExpressionTreeStringFormatter original, Cloner cloner)
       : base(original, cloner) {
       Indent = original.Indent;
     }
-    public SymbolicExpressionTreeStringFormatter()
+    public ExternalEvaluationSymbolicExpressionTreeStringFormatter()
       : base() {
-      Name = "Default String Formatter";
+      Name = "External Evaluation Symbolic Expression Tree Formatter";
       Indent = true;
     }
 
     public string Format(ISymbolicExpressionTree symbolicExpressionTree) {
-      return FormatRecursively(symbolicExpressionTree.Root, 0);
+      // skip root and start symbols
+      return FormatRecursively(symbolicExpressionTree.Root.GetSubtree(0).GetSubtree(0), 0);
     }
 
@@ -57 +61 @@
       if (node.Subtrees.Count() > 0) {
         // symbol on same line as '('
-        strBuilder.AppendLine(node.ToString());
+        if (node.Symbol is Addition) {
+          strBuilder.AppendLine("+");
+        } else if (node.Symbol is And) {
+          strBuilder.AppendLine("&&");
+        } else if (node.Symbol is Average) {
+          strBuilder.AppendLine("avg");
+        } else if (node.Symbol is Cosine) {
+          strBuilder.AppendLine("cos");
+        } else if (node.Symbol is Division) {
+          strBuilder.AppendLine("/");
+        } else if (node.Symbol is Exponential) {
+          strBuilder.AppendLine("exp");
+        } else if (node.Symbol is GreaterThan) {
+          strBuilder.AppendLine(">");
+        } else if (node.Symbol is IfThenElse) {
+          strBuilder.AppendLine("if");
+        } else if (node.Symbol is LessThan) {
+          strBuilder.AppendLine("<");
+        } else if (node.Symbol is Logarithm) {
+          strBuilder.AppendLine("ln");
+        } else if (node.Symbol is Multiplication) {
+          strBuilder.AppendLine("*");
+        } else if (node.Symbol is Not) {
+          strBuilder.AppendLine("!");
+        } else if (node.Symbol is Or) {
+          strBuilder.AppendLine("||");
+        } else if (node.Symbol is Sine) {
+          strBuilder.AppendLine("sin");
+        } else if (node.Symbol is Subtraction) {
+          strBuilder.AppendLine("-");
+        } else if (node.Symbol is Tangent) {
+          strBuilder.AppendLine("tan");
+        } else {
+          throw new NotSupportedException("Formatting of symbol: " + node.Symbol + " not supported for external evaluation.");
+        }
         // each subtree expression on a new line
         // and closing ')' also on new line
+
         foreach (var subtree in node.Subtrees) {
           strBuilder.AppendLine(FormatRecursively(subtree, indentLength + 2));
@@ -66 +105 @@
         strBuilder.Append(")");
       } else {
-        // symbol in the same line with as '(' and ')'
-        strBuilder.Append(node.ToString());
-        strBuilder.Append(")");
+        if (node is VariableTreeNode) {
+          var varNode = node as VariableTreeNode;
+          // symbol in the same line with as '(' and ')'
+          strBuilder.Append(";" + varNode.VariableName + ";" + varNode.Weight.ToString("E4"));
+          strBuilder.Append(")");
+        } else if (node is ConstantTreeNode) {
+          var constNode = node as ConstantTreeNode;
+          // symbol in the same line with as '(' and ')'
+          strBuilder.Append(";" + constNode.Value.ToString("E4"));
+          strBuilder.Append(")");
+        } else {
+          throw new NotSupportedException("Formatting of symbol: " + node.Symbol + " not supported for external evaluation.");
+        }
       }
       return strBuilder.ToString();
@@ -74 +123 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SymbolicExpressionTreeStringFormatter(this, cloner);
+      return new ExternalEvaluationSymbolicExpressionTreeStringFormatter(this, cloner);
     }
   }