Changeset 15835 for branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration

Timestamp:

03/09/18 14:31:15 (7 years ago)

Author:

lkammere

Message:

#2886: Split huge hashing function into smaller ones.

File:

• branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Hashing/Hasher.cs (modified) (3 diffs)

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Hashing/Hasher.cs

@@ -28 +28 @@
       // ADDITION
       if (currentSymbol == Grammar.Addition) {
-        var uniqueChildHashes = new HashSet<THashType>();
-
-        // First subtree
-        if (parseStack.Peek() == Grammar.Addition) {
-          uniqueChildHashes.UnionWith(GetSubtreeHashes(parseStack));
-        } else {
-          var peek = parseStack.Peek();
-          uniqueChildHashes.Add(AggregateHashes(peek, GetSubtreeHashes(parseStack)));
-        }
-        // Second subtree
-        if (parseStack.Peek() == Grammar.Addition) {
-          uniqueChildHashes.UnionWith(GetSubtreeHashes(parseStack));
-        } else {
-          var peek = parseStack.Peek();
-          uniqueChildHashes.Add(AggregateHashes(peek, GetSubtreeHashes(parseStack)));
-        }
-
-        var result = uniqueChildHashes.ToArray();
-        Array.Sort(result);
-        return result;
+        return GetAdditionSubtreeHashes(parseStack);
       }
 
       // MULTIPLICATION
       if (currentSymbol == Grammar.Multiplication) {
-        var childHashes = new List<THashType>();
-
-        // First subtree
-        if (parseStack.Peek() == Grammar.Multiplication) {
-          childHashes.AddRange(GetSubtreeHashes(parseStack));
-        } else {
-          childHashes.Add(AggregateHashes(parseStack.Peek(), GetSubtreeHashes(parseStack)));
-        }
-        // Second subtree
-        if (parseStack.Peek() == Grammar.Multiplication) {
-          childHashes.AddRange(GetSubtreeHashes(parseStack));
-        } else {
-          childHashes.Add(AggregateHashes(parseStack.Peek(), GetSubtreeHashes(parseStack)));
-        }
-
-        // Sort due to commutativity
-        childHashes.Sort();
-
-        // Cancel out inverse factors.
-        bool[] isFactorRemaining = Enumerable.Repeat(true, childHashes.Count).ToArray();
-
-        for (int i = 0; i < isFactorRemaining.Length; i++) {
-          if (!isFactorRemaining[i]) continue;
-          if (isFactorRemaining.Length <= 2) break; // Until we have constants, we can't cancel out all terms.
-
-          var currFactor = childHashes[i];
-          var invFactor = AggregateHashes(Grammar.Inv, new[] { currFactor });
-
-          int indexOfInv = childHashes.IndexOf(invFactor);
-          if (indexOfInv >= 0 && isFactorRemaining[indexOfInv]) {
-            isFactorRemaining[i] = isFactorRemaining[indexOfInv] = false;
-          }
-        }
-
-        return childHashes
-          .Where((c, i) => isFactorRemaining[i])
-          .ToArray();
+        return GetMultiplicationSubtreeHashes(parseStack);
       }
 
@@ -95 +40 @@
           currentSymbol == Grammar.Sin || currentSymbol == Grammar.Cos ||
           currentSymbol == Grammar.Inv) {
+        // Directly aggregate the single subtree
         return new[] { AggregateHashes(parseStack.Peek(), GetSubtreeHashes(parseStack)) };
       }
@@ -101 +47 @@
       return new[] { AggregateHashes(currentSymbol, new THashType[0]) };
     }
+
+    private THashType[] GetAdditionSubtreeHashes(Stack<Symbol> parseStack) {
+      var uniqueChildHashes = new HashSet<THashType>();
+
+      // First subtree
+      if (parseStack.Peek() == Grammar.Addition) {
+        uniqueChildHashes.UnionWith(GetSubtreeHashes(parseStack));
+      } else {
+        var peek = parseStack.Peek();
+        uniqueChildHashes.Add(AggregateHashes(peek, GetSubtreeHashes(parseStack)));
+      }
+      // Second subtree
+      if (parseStack.Peek() == Grammar.Addition) {
+        uniqueChildHashes.UnionWith(GetSubtreeHashes(parseStack));
+      } else {
+        var peek = parseStack.Peek();
+        uniqueChildHashes.Add(AggregateHashes(peek, GetSubtreeHashes(parseStack)));
+      }
+
+      var result = uniqueChildHashes.ToArray();
+      Array.Sort(result);
+      return result;
+    }
+
+    public THashType[] GetMultiplicationSubtreeHashes(Stack<Symbol> parseStack) {
+      var childHashes = new List<THashType>();
+
+      // First subtree
+      if (parseStack.Peek() == Grammar.Multiplication) {
+        childHashes.AddRange(GetSubtreeHashes(parseStack));
+      } else {
+        childHashes.Add(AggregateHashes(parseStack.Peek(), GetSubtreeHashes(parseStack)));
+      }
+      // Second subtree
+      if (parseStack.Peek() == Grammar.Multiplication) {
+        childHashes.AddRange(GetSubtreeHashes(parseStack));
+      } else {
+        childHashes.Add(AggregateHashes(parseStack.Peek(), GetSubtreeHashes(parseStack)));
+      }
+
+      // Sort due to commutativity
+      childHashes.Sort();
+
+      // Cancel out inverse factors.
+      bool[] isFactorRemaining = Enumerable.Repeat(true, childHashes.Count).ToArray();
+
+      for (int i = 0; i < isFactorRemaining.Length; i++) {
+        if (!isFactorRemaining[i]) continue;
+        if (isFactorRemaining.Length <= 2) break; // Until we have constants, we can't cancel out all terms.
+
+        var currFactor = childHashes[i];
+        var invFactor = AggregateHashes(Grammar.Inv, new[] { currFactor });
+
+        int indexOfInv = childHashes.IndexOf(invFactor);
+        if (indexOfInv >= 0 && isFactorRemaining[indexOfInv]) {
+          isFactorRemaining[i] = isFactorRemaining[indexOfInv] = false;
+        }
+      }
+
+      return childHashes
+        .Where((c, i) => isFactorRemaining[i])
+        .ToArray();
+    }
+
+
   }