Changeset 14534 for branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/SymbolicExpressionImporter.cs

Timestamp:

12/30/16 19:35:15 (8 years ago)

Author:

gkronber

Message:

#2650: added simplifier unit tests for factor symbols

File:

• branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/SymbolicExpressionImporter.cs (modified) (10 diffs)

branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/SymbolicExpressionImporter.cs

@@ -35 +35 @@
     private const string INVOKESTART = "CALL";
     private const string TIMELAGSTART = "LAG";
-    private Dictionary<string, Symbol> knownSymbols = new Dictionary<string, Symbol>() 
+    private Dictionary<string, Symbol> knownSymbols = new Dictionary<string, Symbol>()
       {
         {"+", new Addition()},
@@ -45 +45 @@
         {"POW", new Power()},
         {"ROOT", new Root()},
+        {"SQR", new Square()},
+        {"SQRT", new SquareRoot()},
         {"SIN",new Sine()},
         {"COS", new Cosine()},
@@ -74 +76 @@
         {"PROG", new ProgramRootSymbol()},
         {"MAIN", new StartSymbol()},
+        {"FACTOR", new FactorVariable() },
+        {"BINARYFACTOR", new BinaryFactorVariable()}
       };
 
@@ -82 +86 @@
     TimeLag timeLag = new TimeLag();
     Integral integral = new Integral();
+    FactorVariable factorVar = new FactorVariable();
+    BinaryFactorVariable binFactorVar = new BinaryFactorVariable();
 
     ProgramRootSymbol programRootSymbol = new ProgramRootSymbol();
@@ -91 +97 @@
       ISymbolicExpressionTreeNode start = startSymbol.CreateTreeNode();
       ISymbolicExpressionTreeNode mainBranch = ParseSexp(new Queue<Token>(GetTokenStream(str)));
-      if (mainBranch.Symbol is ProgramRootSymbol) {
+      if(mainBranch.Symbol is ProgramRootSymbol) {
         // when a root symbol was parsed => use main branch as root
         root = mainBranch;
@@ -111 +117 @@
 
     private ISymbolicExpressionTreeNode ParseSexp(Queue<Token> tokens) {
-      if (tokens.Peek().Symbol == TokenSymbol.LPAR) {
+      if(tokens.Peek().Symbol == TokenSymbol.LPAR) {
         ISymbolicExpressionTreeNode tree;
         Expect(Token.LPAR, tokens);
-        if (tokens.Peek().StringValue.StartsWith(VARSTART)) {
+        if(tokens.Peek().StringValue.StartsWith(VARSTART)) {
           tree = ParseVariable(tokens);
-        } else if (tokens.Peek().StringValue.StartsWith(LAGGEDVARSTART)) {
+        } else if(tokens.Peek().StringValue.StartsWith(LAGGEDVARSTART)) {
           tree = ParseLaggedVariable(tokens);
-        } else if (tokens.Peek().StringValue.StartsWith(TIMELAGSTART)) {
+        } else if(tokens.Peek().StringValue.StartsWith(TIMELAGSTART)) {
           tree = ParseTimeLag(tokens);
           tree.AddSubtree(ParseSexp(tokens));
-        } else if (tokens.Peek().StringValue.StartsWith(INTEGRALSTART)) {
+        } else if(tokens.Peek().StringValue.StartsWith(INTEGRALSTART)) {
           tree = ParseIntegral(tokens);
           tree.AddSubtree(ParseSexp(tokens));
-        } else if (tokens.Peek().StringValue.StartsWith(DEFUNSTART)) {
+        } else if(tokens.Peek().StringValue.StartsWith(DEFUNSTART)) {
           tree = ParseDefun(tokens);
-          while (!tokens.Peek().Equals(Token.RPAR)) {
+          while(!tokens.Peek().Equals(Token.RPAR)) {
             tree.AddSubtree(ParseSexp(tokens));
           }
-        } else if (tokens.Peek().StringValue.StartsWith(ARGSTART)) {
+        } else if(tokens.Peek().StringValue.StartsWith(ARGSTART)) {
           tree = ParseArgument(tokens);
-        } else if (tokens.Peek().StringValue.StartsWith(INVOKESTART)) {
+        } else if(tokens.Peek().StringValue.StartsWith(INVOKESTART)) {
           tree = ParseInvoke(tokens);
-          while (!tokens.Peek().Equals(Token.RPAR)) {
+          while(!tokens.Peek().Equals(Token.RPAR)) {
             tree.AddSubtree(ParseSexp(tokens));
           }
+        } else if(tokens.Peek().StringValue.StartsWith("FACTOR")) {
+          tree = ParseFactor(tokens);
+        } else if(tokens.Peek().StringValue.StartsWith("BINARYFACTOR")) {
+          tree = ParseBinaryFactor(tokens);
         } else {
           Token curToken = tokens.Dequeue();
           tree = CreateTree(curToken);
-          while (!tokens.Peek().Equals(Token.RPAR)) {
+          while(!tokens.Peek().Equals(Token.RPAR)) {
             tree.AddSubtree(ParseSexp(tokens));
           }
@@ -145 +155 @@
         Expect(Token.RPAR, tokens);
         return tree;
-      } else if (tokens.Peek().Symbol == TokenSymbol.NUMBER) {
+      } else if(tokens.Peek().Symbol == TokenSymbol.NUMBER) {
         ConstantTreeNode t = (ConstantTreeNode)constant.CreateTreeNode();
         t.Value = tokens.Dequeue().DoubleValue;
@@ -201 +211 @@
     }
 
+    private ISymbolicExpressionTreeNode ParseFactor(Queue<Token> tokens) {
+      Token tok = tokens.Dequeue();
+      Debug.Assert(tok.StringValue == "FACTOR");
+      FactorVariableTreeNode t = (FactorVariableTreeNode)(new FactorVariable()).CreateTreeNode(); // create a new symbol each time on purpose
+      var varNameTok = tokens.Dequeue();
+      Debug.Assert(tok.Symbol == TokenSymbol.SYMB);
+      t.VariableName = varNameTok.StringValue;
+
+      var weights = new List<double>();
+      while(tokens.Peek().Symbol == TokenSymbol.NUMBER) {
+        weights.Add(tokens.Dequeue().DoubleValue);
+      }
+
+      t.Weights = weights.ToArray();
+
+      // create a set of (virtual) values to match the number of weights
+      t.Symbol.VariableNames = new string[] { t.VariableName };
+      t.Symbol.VariableValues = new KeyValuePair<string, List<string>>[] { new KeyValuePair<string, List<string>>(t.VariableName, weights.Select((_, i) => "x" + i).ToList()) };
+      return t;
+    }
+
+    private ISymbolicExpressionTreeNode ParseBinaryFactor(Queue<Token> tokens) {
+      Token tok = tokens.Dequeue();
+      Debug.Assert(tok.StringValue == "BINFACTOR");
+      var t = (BinaryFactorVariableTreeNode)binFactorVar.CreateTreeNode();
+      var varNameTok = tokens.Dequeue();
+      Debug.Assert(tok.Symbol == TokenSymbol.SYMB);
+      t.VariableName = varNameTok.StringValue;
+
+      var varValTok = tokens.Dequeue();
+      Debug.Assert(tok.Symbol == TokenSymbol.SYMB);
+      t.VariableValue = varNameTok.StringValue;
+
+      var weightTok = tokens.Dequeue();
+      Debug.Assert(tok.Symbol == TokenSymbol.NUMBER);
+      t.Weight = weightTok.DoubleValue;
+
+      return t;
+    }
+
+
     private ISymbolicExpressionTreeNode ParseLaggedVariable(Queue<Token> tokens) {
       Token varTok = tokens.Dequeue();
@@ -212 +263 @@
 
     private ISymbolicExpressionTreeNode CreateTree(Token token) {
-      if (token.Symbol != TokenSymbol.SYMB) throw new FormatException("Expected function symbol, but got: " + token.StringValue);
+      if(token.Symbol != TokenSymbol.SYMB) throw new FormatException("Expected function symbol, but got: " + token.StringValue);
       return knownSymbols[token.StringValue].CreateTreeNode();
     }
@@ -218 +269 @@
     private void Expect(Token token, Queue<Token> tokens) {
       Token cur = tokens.Dequeue();
-      if (!token.Equals(cur)) throw new FormatException("Expected: " + token.StringValue + ", but got: " + cur.StringValue);
+      if(!token.Equals(cur)) throw new FormatException("Expected: " + token.StringValue + ", but got: " + cur.StringValue);
     }
   }