Changeset 14540 for branches/symbreg-factors-2650

Timestamp:

01/04/17 14:49:12 (8 years ago)

Author:

gkronber

Message:

#2650: fixed bugs in simplifier (causing multiple references to the same tree nodes within a tree)

Location:

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

Files:

• Importer/SymbolicExpressionImporter.cs (modified) (1 diff)
• SymbolicDataAnalysisExpressionTreeSimplifier.cs (modified) (9 diffs)

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

@@ -237 +237 @@
       var t = (BinaryFactorVariableTreeNode)binFactorVar.CreateTreeNode();
       var varNameTok = tokens.Dequeue();
-      Debug.Assert(tok.Symbol == TokenSymbol.SYMB);
+      Debug.Assert(varNameTok.Symbol == TokenSymbol.SYMB);
       t.VariableName = varNameTok.StringValue;
 
       var varValTok = tokens.Dequeue();
-      Debug.Assert(tok.Symbol == TokenSymbol.SYMB);
+      Debug.Assert(varValTok.Symbol == TokenSymbol.SYMB);
       t.VariableValue = varValTok.StringValue;
 
       var weightTok = tokens.Dequeue();
-      Debug.Assert(tok.Symbol == TokenSymbol.NUMBER);
+      Debug.Assert(weightTok.Symbol == TokenSymbol.NUMBER);
       t.Weight = weightTok.DoubleValue;
 

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

@@ -24 +24 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using HeuristicLab.Common;
@@ -64 +65 @@
       ISymbolicExpressionTreeNode rootNode = (new ProgramRootSymbol()).CreateTreeNode();
       rootNode.AddSubtree(GetSimplifiedTree(macroExpandedTree));
+
+#if DEBUG
+      // check that each node is only referenced once
+      var nodes = rootNode.IterateNodesPrefix().ToArray();
+      foreach(var n in nodes) if(nodes.Count(ni => ni == n) > 1) throw new InvalidOperationException();
+#endif
       return new SymbolicExpressionTree(rootNode);
     }
@@ -904 +911 @@
         return a.Subtrees
           .Select(x => GetSimplifiedTree(x))
-          .Select(x => MakeFraction(x, b))
+          .Select(x => MakeFraction(x, GetSimplifiedTree(b)))
           .Aggregate((c, d) => MakeSum(c, d));
       } else if(IsMultiplication(a) && IsConstant(b)) {
@@ -1084 +1091 @@
       if(IsConstant(a) && IsConstant(b)) {
         // fold constants
-        ((ConstantTreeNode)a).Value *= ((ConstantTreeNode)b).Value;
-        return a;
+        return MakeConstant(((ConstantTreeNode)a).Value * ((ConstantTreeNode)b).Value);
       } else if(IsConstant(a)) {
         // a * $ => $ * a
@@ -1123 +1129 @@
         return a;
       } else if(IsConstant(b) && IsAddition(a) ||
-          IsFactor(b) && IsAddition(a)) {
+          IsFactor(b) && IsAddition(a) ||
+          IsBinFactor(b) && IsAddition(a)) {
         // multiply constants into additions
-        return a.Subtrees.Select(x => MakeProduct(x, b)).Aggregate((c, d) => MakeSum(c, d));
+        return a.Subtrees.Select(x => MakeProduct(GetSimplifiedTree(x), GetSimplifiedTree(b))).Aggregate((c, d) => MakeSum(c, d));
       } else if(IsDivision(a) && IsDivision(b)) {
         // (a1 / a2) * (b1 / b2) => (a1 * b1) / (a2 * b2)
@@ -1146 +1153 @@
       } else if(IsMultiplication(a)) {
         // a is already an multiplication => append b
-        a.AddSubtree(b);
+        a.AddSubtree(GetSimplifiedTree(b));
         MergeVariablesAndConstantsInProduct(a);
         return a;
@@ -1256 +1263 @@
     /// <summary>
     /// x => x * -1
-    /// Doesn't create new trees and manipulates x
+    /// Is only used in cases where it is not necessary to create new tree nodes. Manipulates x directly.
     /// </summary>
     /// <param name="x"></param>
@@ -1293 +1300 @@
     /// <summary>
     /// x => 1/x
-    /// Doesn't create new trees and manipulates x
+    /// Must create new tree nodes
     /// </summary>
     /// <param name="x"></param>
@@ -1302 +1309 @@
       } else if(IsFactor(x)) {
         var factorNode = (FactorVariableTreeNode)x;
-        for(int i = 0; i < factorNode.Weights.Length; i++) factorNode.Weights[i] = 1.0 / factorNode.Weights[i];
-        return factorNode;
+        return MakeFactor(factorNode.Symbol, factorNode.VariableName, factorNode.Weights.Select(w => 1.0 / w));
       } else if(IsDivision(x)) {
         return MakeFraction(x.GetSubtree(1), x.GetSubtree(0));