Changeset 18123 for branches/3140_NumberSymbol

Timestamp:

12/15/21 10:34:24 (2 years ago)

Author:

gkronber

Message:

#3140: fixed parsing of Numbers in SymbolicExpressionImporter

Location:

branches/3140_NumberSymbol

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/SymbolicExpressionImporter.cs (modified) (5 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/Token.cs (modified) (3 diffs)
• HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionTreeSimplifierTest.cs (modified) (3 diffs)

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/SymbolicExpressionImporter.cs

@@ -97 +97 @@
 
     public ISymbolicExpressionTree Import(string str) {
-      str = str.Replace("(", " ( ").Replace(")", " ) ");
+      str = str.Replace("(", " ( ").Replace(")", " ) ")
+        .Replace("<", " < ").Replace(">", " > ")
+        .Replace("=", " = ");
       ISymbolicExpressionTreeNode root = programRootSymbol.CreateTreeNode();
       ISymbolicExpressionTreeNode start = startSymbol.CreateTreeNode();
@@ -159 +161 @@
         Expect(Token.RPAR, tokens);
         return tree;
-      } else if (tokens.Peek().Symbol == TokenSymbol.NUMBER) {
+      } else if (tokens.Peek().Symbol == TokenSymbol.CONSTANT) {
         var t = (INumericTreeNode)number.CreateTreeNode();
         t.Value = tokens.Dequeue().DoubleValue;
+        return t;
+      } else if (tokens.Peek().Symbol == TokenSymbol.LBRACKET) {
+        Expect(Token.LBRACKET, tokens);
+        Expect(Token.NUM, tokens);
+        var t = (INumericTreeNode)number.CreateTreeNode();
+        if (tokens.Peek().Symbol == TokenSymbol.EQ) {
+          Expect(Token.EQ, tokens);
+          var initValToken = tokens.Dequeue();
+          if(initValToken.Symbol == TokenSymbol.CONSTANT) {
+            t.Value = initValToken.DoubleValue;
+          } else {
+            throw new FormatException("Expected a real value");
+          }
+        }
+        Expect(Token.RBRACKET, tokens);
         return t;
       } else throw new FormatException("Expected function or number symbol");
@@ -224 +241 @@
 
       var weights = new List<double>();
-      while (tokens.Peek().Symbol == TokenSymbol.NUMBER) {
+      while (tokens.Peek().Symbol == TokenSymbol.CONSTANT) {
         weights.Add(tokens.Dequeue().DoubleValue);
       }
@@ -252 +269 @@
 
       var weightTok = tokens.Dequeue();
-      Debug.Assert(weightTok.Symbol == TokenSymbol.NUMBER);
+      Debug.Assert(weightTok.Symbol == TokenSymbol.CONSTANT);
       t.Weight = weightTok.DoubleValue;
 
@@ -270 +287 @@
 
     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 &&
+          token.Symbol != TokenSymbol.LBRACKET &&  // LBRACKET and RBRACKET are used for <num=..> and as LT, GT operators
+          token.Symbol != TokenSymbol.RBRACKET  
+          ) throw new FormatException("Expected function symbol, but got: " + token.StringValue);
       return knownSymbols[token.StringValue].CreateTreeNode();
     }

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/Token.cs

@@ -23 +23 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  internal enum TokenSymbol { LPAR, RPAR, SYMB, NUMBER };
+  internal enum TokenSymbol {
+    LPAR, RPAR, SYMB, CONSTANT,
+    NUM, // num
+    EQ,  // =
+    LBRACKET, // <
+    RBRACKET  // >
+  };
   internal class Token {
     public static readonly Token LPAR = Token.Parse("(");
     public static readonly Token RPAR = Token.Parse(")");
+    public static readonly Token LBRACKET = Token.Parse("<");
+    public static readonly Token RBRACKET = Token.Parse(">");
+    public static readonly Token EQ = Token.Parse("=");
+    public static readonly Token NUM = Token.Parse("num");
 
     public TokenSymbol Symbol { get; set; }
@@ -46 +56 @@
     public static Token Parse(string strToken) {
       strToken = strToken.Trim();
-      Token t = new Token();
+      var t = new Token();
       t.StringValue = strToken.Trim();
-      double temp;
       if (strToken == "") {
         t = null;
@@ -55 +64 @@
       } else if (strToken == ")") {
         t.Symbol = TokenSymbol.RPAR;
-      } else if (double.TryParse(strToken, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out temp)) {
-        t.Symbol = TokenSymbol.NUMBER;
-        t.DoubleValue = double.Parse(strToken, CultureInfo.InvariantCulture.NumberFormat);
+      } else if (strToken == "<") {
+        t.Symbol = TokenSymbol.LBRACKET;
+      } else if (strToken == ">") {
+        t.Symbol = TokenSymbol.RBRACKET;
+      } else if (strToken == "=") {
+        t.Symbol = TokenSymbol.EQ;
+      } else if (strToken.ToLower() == "num") {
+        t.Symbol = TokenSymbol.NUM;
+      } else if (double.TryParse(strToken, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out var val)) {
+        t.Symbol = TokenSymbol.CONSTANT;
+        t.DoubleValue = val;
       } else {
         t.Symbol = TokenSymbol.SYMB;

branches/3140_NumberSymbol/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionTreeSimplifierTest.cs

@@ -230 +230 @@
 
       #region abs
-      AssertEqualAfterSimplification("(abs 2.0)", "2.0");
-      AssertEqualAfterSimplification("(abs -2.0)", "2.0"); // constant folding
+      AssertEqualAfterSimplification("(abs <num=2.0>)", "2.0");
+      AssertEqualAfterSimplification("(abs <num=-2.0>)", "2.0"); // constant folding
       AssertEqualAfterSimplification("(abs (exp (variable 2.0 x)))", "(exp (variable 2.0 x)))"); // exp is always positive
       AssertEqualAfterSimplification("(abs (exp (variable 2.0 x)))", "(exp (variable 2.0 x)))"); // exp is always positive
@@ -238 +238 @@
       AssertEqualAfterSimplification("(abs (cuberoot (variable 2.0 a)))", "(cuberoot (variable 2.0 a))"); // cuberoot is always positive (for our cases)
 
-      AssertEqualAfterSimplification("(* (abs (variable 2.0 x)) 2.0)", "(abs (variable 4.0 x))");  // can multiply positive constants into abs
-      AssertEqualAfterSimplification("(* (abs (variable 2.0 x)) -2.0)", "(* (abs (variable 4.0 x)) -1.0)"); // for negative constants keep the sign
+      AssertEqualAfterSimplification("(* (abs (variable 2.0 x)) <num=2.0>)", "(abs (variable 4.0 x))");  // can multiply positive constants into abs
+      AssertEqualAfterSimplification("(* (abs (variable 2.0 x)) <num=-2.0>)", "(* (abs (variable 4.0 x)) -1.0)"); // for negative constants keep the sign
 
       AssertEqualAfterSimplification("(abs (* (variable 1.0 a) (variable 2.0 b)))", "(* (abs (variable 1.0 a)) (abs (variable 1.0 b)) 2.0))");
@@ -265 +265 @@
 
       #region AQ
-      AssertEqualAfterSimplification("(* (aq (variable 1.0 x) (variable 1.0 y)) 2.0)", "(aq (variable 2.0 x) (variable 1.0 y))");
-      AssertEqualAfterSimplification("(/ (aq (variable 1.0 x) (variable 1.0 y)) 2.0)", "(aq (variable 0.5 x) (variable 1.0 y))");
+      AssertEqualAfterSimplification("(* (aq (variable 1.0 x) (variable 1.0 y)) <num=2.0>)", "(aq (variable 2.0 x) (variable 1.0 y))");
+      AssertEqualAfterSimplification("(/ (aq (variable 1.0 x) (variable 1.0 y)) <num=2.0>)", "(aq (variable 0.5 x) (variable 1.0 y))");
 
       #endregion
 
       #region do not drop subtrees with small weights
-      AssertEqualAfterSimplification("(* 1e-14 (variable 1.0 a))", "(variable 1e-14 a)");
-      AssertEqualAfterSimplification("(+ (variable 1.0 a) 1e-14)", 
-                                     "(+ (variable 1.0 a) 1e-14)");
+      AssertEqualAfterSimplification("(* <num=1e-14> (variable 1.0 a))", "(variable 1e-14 a)");
+      AssertEqualAfterSimplification("(+ (variable 1.0 a) <num=1e-14>)",
+                                     "(+ (variable 1.0 a) <num=1e-14>)");
       // a scenario where a term with small weight can have large effect
-      AssertEqualAfterSimplification("(+ (* (pow (variable 1.0 a) 10) 1e-14) 1.0)",
-                                     "(+ (* (pow (variable 1.0 a) 10) 1e-14) 1.0)");
+      AssertEqualAfterSimplification("(+ (* (pow (variable 1.0 a) <num=10>) <num=1e-14>) 1.0)",
+                                     "(+ (* (pow (variable 1.0 a) <num=10>) <num=1e-14>) 1.0)");
       // a test case (from ticket #2985)
-      AssertEqualAfterSimplification("(+ (* (exp (variable 3.5861E+001 a)) 5.5606E-016) 5.9323E-002)",
-                                     "(+ (* (exp (variable 3.5861E+001 a)) 5.5606E-016) 5.9323E-002)");
+      AssertEqualAfterSimplification("(+ (* (exp (variable 3.5861E+001 a)) <num=5.5606E-016>) <num=5.9323E-002>)",
+                                     "(+ (* (exp (variable 3.5861E+001 a)) <num=5.5606E-016>) <num=5.9323E-002>)");
       #endregion
     }