Changeset 15784 for branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Grammar.cs

Timestamp:

02/16/18 18:36:17 (7 years ago)

Author:

lkammere

Message:

#2886: Add basic implementation for inverse factors.

File:

• branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Grammar.cs (modified) (11 diffs)

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Grammar.cs

@@ -24 +24 @@
     public NonterminalSymbol SinFactor;
 
+    public NonterminalSymbol InvExpr;
+    public NonterminalSymbol InvTerm;
+    public NonterminalSymbol InvFactor;
+
     public NonterminalSymbol SimpleExpr;
     public NonterminalSymbol SimpleTerm;
@@ -32 +36 @@
     public TerminalSymbol Exp;
     public TerminalSymbol Sin;
+    public TerminalSymbol Inv;
 
     // For infix notation
@@ -70 +75 @@
       SinFactor = new NonterminalSymbol("SinFactor");
 
+      InvExpr = new NonterminalSymbol("InvExpr");
+      InvTerm = new NonterminalSymbol("InvTerm");
+      InvFactor = new NonterminalSymbol("InvFactor");
+
       SimpleExpr = new NonterminalSymbol("SimpleExpr");
       SimpleTerm = new NonterminalSymbol("SimpleTerm");
@@ -78 +87 @@
       Exp = new TerminalSymbol("exp");
       Sin = new TerminalSymbol("sin");
+      Inv = new TerminalSymbol("inv");
 
       OpeningBracket = new TerminalSymbol("(");
@@ -94 +104 @@
       Term.AddProduction(Factor, Term, Multiplication);
       Term.AddProduction(Factor);
+      Term.AddProduction(InvExpr, Inv);
 
       Factor.AddProduction(Var);
@@ -109 +120 @@
       SimpleTerm.AddProduction(Var, SimpleTerm, Multiplication);
       SimpleTerm.AddProduction(Var);
+
+      InvExpr.AddProduction(InvTerm, InvExpr, Addition);
+      InvExpr.AddProduction(InvTerm);
+
+      InvTerm.AddProduction(InvFactor, InvTerm, Multiplication);
+      InvTerm.AddProduction(InvFactor);
+
+      InvFactor.AddProduction(Var);
+      InvFactor.AddProduction(LogFactor);
+      InvFactor.AddProduction(SinFactor);
       #endregion
 
@@ -144 +165 @@
     private int[] GetSubtreeHashes(Stack<Symbol> parseStack) {
       Symbol currentSymbol = parseStack.Pop();
-
-      // MULTIPLICATION
-      if (ReferenceEquals(currentSymbol, Multiplication)) {
-        List<int> childHashes = new List<int>();
-
-        // First subtree
-        if (ReferenceEquals(parseStack.Peek(), Multiplication)) {
-          childHashes.AddRange(GetSubtreeHashes(parseStack));
-        } else {
-          childHashes.Add(AggregateHashes(parseStack.Peek(), GetSubtreeHashes(parseStack)));
-        }
-        // Second subtree
-        if (ReferenceEquals(parseStack.Peek(), Multiplication)) {
-          childHashes.AddRange(GetSubtreeHashes(parseStack));
-        } else {
-          childHashes.Add(AggregateHashes(parseStack.Peek(), GetSubtreeHashes(parseStack)));
-        }
-
-        // Sort due to commutativity
-        childHashes.Sort();
-        return childHashes.ToArray();
-      }
 
       // ADDITION
@@ -191 +190 @@
       }
 
-      // LOG, EXP, SIN
+      // MULTIPLICATION
+      if (ReferenceEquals(currentSymbol, Multiplication)) {
+        List<int> childHashes = new List<int>();
+
+        // First subtree
+        if (ReferenceEquals(parseStack.Peek(), Multiplication)) {
+          childHashes.AddRange(GetSubtreeHashes(parseStack));
+        } else {
+          childHashes.Add(AggregateHashes(parseStack.Peek(), GetSubtreeHashes(parseStack)));
+        }
+        // Second subtree
+        if (ReferenceEquals(parseStack.Peek(), Multiplication)) {
+          childHashes.AddRange(GetSubtreeHashes(parseStack));
+        } else {
+          childHashes.Add(AggregateHashes(parseStack.Peek(), GetSubtreeHashes(parseStack)));
+        }
+
+        // Sort due to commutativity
+        childHashes.Sort();
+
+        // Cancel out inverse factors.
+        var inversChildHashes = childHashes
+          .Select(ch => AggregateHashes(Inv, ch.ToEnumerable()))
+          .ToList();
+
+        return childHashes // If this factor cancels out another one, then remove BOTH. Otherwise, keep the factor.
+          .Where(ch => !inversChildHashes.Remove(ch))
+          .ToArray();
+      }
+
+      // LOG, EXP, SIN, INV
       if (ReferenceEquals(currentSymbol, Log) || ReferenceEquals(currentSymbol, Exp) ||
-          ReferenceEquals(currentSymbol, Sin)) {
+          ReferenceEquals(currentSymbol, Sin) || ReferenceEquals(currentSymbol, Inv)) {
         return AggregateHashes(parseStack.Peek(), GetSubtreeHashes(parseStack)).ToEnumerable().ToArray();
       }
@@ -205 +234 @@
 
       int start;
-      if (ReferenceEquals(operatorSym, Addition) && hashesArray.Count() <= 1) {
+      if ((ReferenceEquals(operatorSym, Addition) || ReferenceEquals(operatorSym, Multiplication)) && hashesArray.Count() <= 1) {
         start = 0;
       } else {
@@ -257 +286 @@
       } else if (ReferenceEquals(currentSymbol, Sin)) {
         parsedSubTree = sinSy.CreateTreeNode();
+        parsedSubTree.AddSubtree(ParseSymbolicExpressionTree(parseStack));
+
+      } else if (ReferenceEquals(currentSymbol, Inv)) {
+        parsedSubTree = divSy.CreateTreeNode();
+        ConstantTreeNode dividend = (ConstantTreeNode)constSy.CreateTreeNode();
+        dividend.Value = 1.0;
+        parsedSubTree.AddSubtree(dividend);
         parsedSubTree.AddSubtree(ParseSymbolicExpressionTree(parseStack));
 
@@ -293 +329 @@
         result.AddRange(rightPart);
 
-      } else if (ReferenceEquals(head, Log) || ReferenceEquals(head, Exp) || ReferenceEquals(head, Sin)) {
+      } else if (ReferenceEquals(head, Log) || ReferenceEquals(head, Exp)
+              || ReferenceEquals(head, Sin) || ReferenceEquals(head, Inv)) {
         result.Add(head);
         result.Add(OpeningBracket);