Changeset 3733 for trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Tests/SymbolicExpressionImporter.cs

Timestamp:

05/10/10 08:15:00 (14 years ago)

Author:

gkronber

Message:

Added test cases for arithmetic expression interpreter. And fixed minor problems in the interpreter. #791

Location:

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Tests

Files:

• . (added)
• SymbolicExpressionImporter.cs (copied) (copied from branches/3.2/sources/HeuristicLab.GP.Tests/SymbolicExpressionImporter.cs) (5 diffs)

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Tests/SymbolicExpressionImporter.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -24 +24 @@
 using System.Linq;
 using System.Text;
-using HeuristicLab.GP.Interfaces;
 using System.IO;
 using System.Diagnostics;
-using HeuristicLab.GP.StructureIdentification;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
-namespace HeuristicLab.GP.Test {
-  class SymbolicExpressionImporter {
-    private const string DIFFSTART = "dif";
+namespace HeuristicLab.Problems.DataAnalysis.Tests {
+  internal class SymbolicExpressionImporter {
     private const string VARSTART = "var";
-    private const string OPENPARAMSTART = "open-param";
-    private Dictionary<string, IFunction> knownFunctions = new Dictionary<string, IFunction>() 
+    private Dictionary<string, Symbol> knownSymbols = new Dictionary<string, Symbol>() 
       {
         {"+", new Addition()},
-        {"and", new And()},
-        {"mean", new Average()},
-        {"cos", new Cosinus()},
         {"/", new Division()},
-        {"equ", new Equal()},
-        {"exp", new Exponential()},
-        {">", new GreaterThan()},
-        {"if", new IfThenElse()},
-        {"<", new LessThan()},
-        {"log", new Logarithm()},
         {"*", new Multiplication()},
-        {"not", new Not()},
-        {"or", new Or()},
-        {"expt", new Power()},
-        {"sign", new Signum()},
-        {"sin",new Sinus()},
-        {"sqrt", new Sqrt()},
         {"-", new Subtraction()},
-        {"tan", new Tangens()},
-        {"xor", new Xor()},
-        {"open-param", new HeuristicLab.GP.StructureIdentification.Networks.OpenParameter()},
-        {"open-+", new HeuristicLab.GP.StructureIdentification.Networks.OpenAddition()},
-        {"open--", new HeuristicLab.GP.StructureIdentification.Networks.OpenSubtraction()},
-        {"open-*", new HeuristicLab.GP.StructureIdentification.Networks.OpenMultiplication()},
-        {"open-/", new HeuristicLab.GP.StructureIdentification.Networks.OpenDivision()},
-        {"open-log", new HeuristicLab.GP.StructureIdentification.Networks.OpenLog()},
-        {"open-exp", new HeuristicLab.GP.StructureIdentification.Networks.OpenExp()},
-        //{"open-sqr", new HeuristicLab.GP.StructureIdentification.Networks.OpenSqr()},
-        //{"open-sqrt", new HeuristicLab.GP.StructureIdentification.Networks.OpenSqrt()},
-        {"f1-+", new HeuristicLab.GP.StructureIdentification.Networks.AdditionF1()},
-        {"f1--", new HeuristicLab.GP.StructureIdentification.Networks.SubtractionF1()},
-        {"f1-/", new HeuristicLab.GP.StructureIdentification.Networks.DivisionF1()},
-        {"f1-*", new HeuristicLab.GP.StructureIdentification.Networks.MultiplicationF1()},
-        {"cycle", new HeuristicLab.GP.StructureIdentification.Networks.Cycle()},
-        {"flip", new HeuristicLab.GP.StructureIdentification.Networks.Flip()},
 
       };
     Constant constant = new Constant();
-    HeuristicLab.GP.StructureIdentification.Variable variable = new HeuristicLab.GP.StructureIdentification.Variable();
-    Differential differential = new Differential();
-    HeuristicLab.GP.StructureIdentification.Networks.OpenParameter openParam = new HeuristicLab.GP.StructureIdentification.Networks.OpenParameter();
+    Variable variable = new Variable();
+    ProgramRootSymbol programRootSymbol = new ProgramRootSymbol();
+    StartSymbol startSymbol = new StartSymbol();
+
     public SymbolicExpressionImporter() {
     }
 
-    internal IFunctionTree Import(string str) {
+    internal SymbolicExpressionTree Import(string str) {
       str = str.Replace("(", " ( ").Replace(")", " ) ");
-      return ParseSexp(new Queue<Token>(GetTokenStream(str)));
+      SymbolicExpressionTreeNode root = programRootSymbol.CreateTreeNode();
+      SymbolicExpressionTreeNode start = startSymbol.CreateTreeNode();
+      SymbolicExpressionTreeNode mainBranch = ParseSexp(new Queue<Token>(GetTokenStream(str)));
+      root.AddSubTree(start);
+      start.AddSubTree(mainBranch);
+      return new SymbolicExpressionTree(root);
     }
 
@@ -94 +67 @@
     }
 
-    private HeuristicLab.GP.Interfaces.IFunctionTree ParseSexp(Queue<Token> tokens) {
+    private SymbolicExpressionTreeNode ParseSexp(Queue<Token> tokens) {
       if (tokens.Peek().Symbol == TokenSymbol.LPAR) {
-        IFunctionTree tree;
+        SymbolicExpressionTreeNode tree;
         Expect(Token.LPAR, tokens);
         if (tokens.Peek().StringValue.StartsWith(VARSTART)) {
           tree = ParseVariable(tokens);
-        } else if (tokens.Peek().StringValue.StartsWith(DIFFSTART)) {
-          tree = ParseDifferential(tokens);
-        } else if (tokens.Peek().StringValue.StartsWith(OPENPARAMSTART)) {
-          tree = ParseOpenParameter(tokens);
         } else {
           Token curToken = tokens.Dequeue();
@@ -114 +83 @@
         return tree;
       } else if (tokens.Peek().Symbol == TokenSymbol.NUMBER) {
-        ConstantFunctionTree t = (ConstantFunctionTree)constant.GetTreeNode();
+        ConstantTreeNode t = (ConstantTreeNode)constant.CreateTreeNode();
         t.Value = tokens.Dequeue().DoubleValue;
         return t;
@@ -120 +89 @@
     }
 
-    private IFunctionTree ParseOpenParameter(Queue<Token> tokens) {
-      Token tok = tokens.Dequeue();
-      Debug.Assert(tok.StringValue == "open-param");
-      HeuristicLab.GP.StructureIdentification.Networks.OpenParameterFunctionTree t = (HeuristicLab.GP.StructureIdentification.Networks.OpenParameterFunctionTree)openParam.GetTreeNode();
+    private SymbolicExpressionTreeNode ParseVariable(Queue<Token> tokens) {
+      Token varTok = tokens.Dequeue();
+      Debug.Assert(varTok.StringValue == "variable");
+      VariableTreeNode t = (VariableTreeNode)variable.CreateTreeNode();
       t.Weight = tokens.Dequeue().DoubleValue;
       t.VariableName = tokens.Dequeue().StringValue;
-      t.SampleOffset = (int)tokens.Dequeue().DoubleValue;
       return t;
     }
 
-    private IFunctionTree ParseDifferential(Queue<Token> tokens) {
-      Token diffTok = tokens.Dequeue();
-      Debug.Assert(diffTok.StringValue == "differential");
-      VariableFunctionTree t = (VariableFunctionTree)differential.GetTreeNode();
-      t.Weight = tokens.Dequeue().DoubleValue;
-      t.VariableName = tokens.Dequeue().StringValue;
-      t.SampleOffset = (int)tokens.Dequeue().DoubleValue;
-      return t;
-    }
-
-    private IFunctionTree ParseVariable(Queue<Token> tokens) {
-      Token varTok = tokens.Dequeue();
-      Debug.Assert(varTok.StringValue == "variable");
-      VariableFunctionTree t = (VariableFunctionTree)variable.GetTreeNode();
-      t.Weight = tokens.Dequeue().DoubleValue;
-      t.VariableName = tokens.Dequeue().StringValue;
-      t.SampleOffset = (int)tokens.Dequeue().DoubleValue;
-      return t;
-    }
-
-    private IFunctionTree CreateTree(Token token) {
+    private SymbolicExpressionTreeNode CreateTree(Token token) {
       if (token.Symbol != TokenSymbol.SYMB) throw new FormatException("Expected function symbol, but got: " + token.StringValue);
-      return knownFunctions[token.StringValue].GetTreeNode();
+      return knownSymbols[token.StringValue].CreateTreeNode();
     }
 
     private void Expect(Token token, Queue<Token> tokens) {
       Token cur = tokens.Dequeue();
-      if (!token.Equals(cur)) throw new FormatException("Expected: " + token.StringValue + ", but got found: " + cur.StringValue);
+      if (!token.Equals(cur)) throw new FormatException("Expected: " + token.StringValue + ", but got: " + cur.StringValue);
     }
   }