Changeset 5733 for branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs

Timestamp:

03/17/11 14:07:47 (13 years ago)

Author:

mkommend

Message:

#1418: Corrected problem interfaces & unified naming of subtrees.

File:

• branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs (modified) (39 diffs)

branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs

@@ -55 +55 @@
       var clone = (ISymbolicExpressionTreeNode)originalTree.Root.Clone();
       // macro expand (initially no argument trees)
-      var macroExpandedTree = MacroExpand(clone, clone.GetSubTree(0), new List<ISymbolicExpressionTreeNode>());
+      var macroExpandedTree = MacroExpand(clone, clone.GetSubtree(0), new List<ISymbolicExpressionTreeNode>());
       ISymbolicExpressionTreeNode rootNode = (new ProgramRootSymbol()).CreateTreeNode();
-      rootNode.AddSubTree(GetSimplifiedTree(macroExpandedTree));
+      rootNode.AddSubtree(GetSimplifiedTree(macroExpandedTree));
       return new SymbolicExpressionTree(rootNode);
     }
@@ -63 +63 @@
     // the argumentTrees list contains already expanded trees used as arguments for invocations
     private ISymbolicExpressionTreeNode MacroExpand(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode node, IList<ISymbolicExpressionTreeNode> argumentTrees) {
-      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(node.SubTrees);
-      while (node.SubTrees.Count() > 0) node.RemoveSubTree(0);
+      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(node.Subtrees);
+      while (node.SubtreesCount > 0) node.RemoveSubtree(0);
       if (node.Symbol is InvokeFunction) {
         var invokeSym = node.Symbol as InvokeFunction;
@@ -80 +80 @@
         // recursive application
         foreach (var subtree in subtrees) {
-          node.AddSubTree(MacroExpand(root, subtree, argumentTrees));
+          node.AddSubtree(MacroExpand(root, subtree, argumentTrees));
         }
         return node;
@@ -87 +87 @@
 
     private ISymbolicExpressionTreeNode FindFunctionDefinition(ISymbolicExpressionTreeNode root, string functionName) {
-      foreach (var subtree in root.SubTrees.OfType<DefunTreeNode>()) {
-        if (subtree.FunctionName == functionName) return subtree.GetSubTree(0);
+      foreach (var subtree in root.Subtrees.OfType<DefunTreeNode>()) {
+        if (subtree.FunctionName == functionName) return subtree.GetSubtree(0);
       }
 
@@ -232 +232 @@
     private ISymbolicExpressionTreeNode SimplifyAny(ISymbolicExpressionTreeNode original) {
       // can't simplify this function but simplify all subtrees 
-      List<ISymbolicExpressionTreeNode> subTrees = new List<ISymbolicExpressionTreeNode>(original.SubTrees);
-      while (original.SubTrees.Count() > 0) original.RemoveSubTree(0);
+      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(original.Subtrees);
+      while (original.Subtrees.Count() > 0) original.RemoveSubtree(0);
       var clone = (SymbolicExpressionTreeNode)original.Clone();
-      List<ISymbolicExpressionTreeNode> simplifiedSubTrees = new List<ISymbolicExpressionTreeNode>();
-      foreach (var subTree in subTrees) {
-        simplifiedSubTrees.Add(GetSimplifiedTree(subTree));
-        original.AddSubTree(subTree);
-      }
-      foreach (var simplifiedSubtree in simplifiedSubTrees) {
-        clone.AddSubTree(simplifiedSubtree);
-      }
-      if (simplifiedSubTrees.TrueForAll(t => IsConstant(t))) {
+      List<ISymbolicExpressionTreeNode> simplifiedSubtrees = new List<ISymbolicExpressionTreeNode>();
+      foreach (var subtree in subtrees) {
+        simplifiedSubtrees.Add(GetSimplifiedTree(subtree));
+        original.AddSubtree(subtree);
+      }
+      foreach (var simplifiedSubtree in simplifiedSubtrees) {
+        clone.AddSubtree(simplifiedSubtree);
+      }
+      if (simplifiedSubtrees.TrueForAll(t => IsConstant(t))) {
         SimplifyConstantExpression(clone);
       }
@@ -255 +255 @@
 
     private ISymbolicExpressionTreeNode SimplifyAverage(ISymbolicExpressionTreeNode original) {
-      if (original.SubTrees.Count() == 1) {
-        return GetSimplifiedTree(original.GetSubTree(0));
+      if (original.Subtrees.Count() == 1) {
+        return GetSimplifiedTree(original.GetSubtree(0));
       } else {
         // simplify expressions x0..xn
         // make sum(x0..xn) / n
-        Trace.Assert(original.SubTrees.Count() > 1);
-        var sum = original.SubTrees
+        Trace.Assert(original.Subtrees.Count() > 1);
+        var sum = original.Subtrees
           .Select(x => GetSimplifiedTree(x))
           .Aggregate((a, b) => MakeSum(a, b));
-        return MakeFraction(sum, MakeConstant(original.SubTrees.Count()));
+        return MakeFraction(sum, MakeConstant(original.Subtrees.Count()));
       }
     }
 
     private ISymbolicExpressionTreeNode SimplifyDivision(ISymbolicExpressionTreeNode original) {
-      if (original.SubTrees.Count() == 1) {
-        return Invert(GetSimplifiedTree(original.GetSubTree(0)));
+      if (original.Subtrees.Count() == 1) {
+        return Invert(GetSimplifiedTree(original.GetSubtree(0)));
       } else {
         // simplify expressions x0..xn
         // make multiplication (x0 * 1/(x1 * x1 * .. * xn))
-        Trace.Assert(original.SubTrees.Count() > 1);
-        var simplifiedTrees = original.SubTrees.Select(x => GetSimplifiedTree(x));
+        Trace.Assert(original.Subtrees.Count() > 1);
+        var simplifiedTrees = original.Subtrees.Select(x => GetSimplifiedTree(x));
         return
           MakeProduct(simplifiedTrees.First(), Invert(simplifiedTrees.Skip(1).Aggregate((a, b) => MakeProduct(a, b))));
@@ -282 +282 @@
 
     private ISymbolicExpressionTreeNode SimplifyMultiplication(ISymbolicExpressionTreeNode original) {
-      if (original.SubTrees.Count() == 1) {
-        return GetSimplifiedTree(original.GetSubTree(0));
-      } else {
-        Trace.Assert(original.SubTrees.Count() > 1);
-        return original.SubTrees
+      if (original.Subtrees.Count() == 1) {
+        return GetSimplifiedTree(original.GetSubtree(0));
+      } else {
+        Trace.Assert(original.Subtrees.Count() > 1);
+        return original.Subtrees
           .Select(x => GetSimplifiedTree(x))
           .Aggregate((a, b) => MakeProduct(a, b));
@@ -293 +293 @@
 
     private ISymbolicExpressionTreeNode SimplifySubtraction(ISymbolicExpressionTreeNode original) {
-      if (original.SubTrees.Count() == 1) {
-        return Negate(GetSimplifiedTree(original.GetSubTree(0)));
+      if (original.Subtrees.Count() == 1) {
+        return Negate(GetSimplifiedTree(original.GetSubtree(0)));
       } else {
         // simplify expressions x0..xn
         // make addition (x0,-x1..-xn)
-        Trace.Assert(original.SubTrees.Count() > 1);
-        var simplifiedTrees = original.SubTrees.Select(x => GetSimplifiedTree(x));
+        Trace.Assert(original.Subtrees.Count() > 1);
+        var simplifiedTrees = original.Subtrees.Select(x => GetSimplifiedTree(x));
         return simplifiedTrees.Take(1)
           .Concat(simplifiedTrees.Skip(1).Select(x => Negate(x)))
@@ -307 +307 @@
 
     private ISymbolicExpressionTreeNode SimplifyAddition(ISymbolicExpressionTreeNode original) {
-      if (original.SubTrees.Count() == 1) {
-        return GetSimplifiedTree(original.GetSubTree(0));
+      if (original.Subtrees.Count() == 1) {
+        return GetSimplifiedTree(original.GetSubtree(0));
       } else {
         // simplify expression x0..xn
         // make addition (x0..xn)
-        Trace.Assert(original.SubTrees.Count() > 1);
-        return original.SubTrees
+        Trace.Assert(original.Subtrees.Count() > 1);
+        return original.Subtrees
           .Select(x => GetSimplifiedTree(x))
           .Aggregate((a, b) => MakeSum(a, b));
@@ -320 +320 @@
 
     private ISymbolicExpressionTreeNode SimplifyNot(ISymbolicExpressionTreeNode original) {
-      return MakeNot(GetSimplifiedTree(original.GetSubTree(0)));
+      return MakeNot(GetSimplifiedTree(original.GetSubtree(0)));
     }
     private ISymbolicExpressionTreeNode SimplifyOr(ISymbolicExpressionTreeNode original) {
-      return original.SubTrees
+      return original.Subtrees
         .Select(x => GetSimplifiedTree(x))
         .Aggregate((a, b) => MakeOr(a, b));
     }
     private ISymbolicExpressionTreeNode SimplifyAnd(ISymbolicExpressionTreeNode original) {
-      return original.SubTrees
+      return original.Subtrees
         .Select(x => GetSimplifiedTree(x))
         .Aggregate((a, b) => MakeAnd(a, b));
     }
     private ISymbolicExpressionTreeNode SimplifyLessThan(ISymbolicExpressionTreeNode original) {
-      return MakeLessThan(GetSimplifiedTree(original.GetSubTree(0)), GetSimplifiedTree(original.GetSubTree(1)));
+      return MakeLessThan(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
     private ISymbolicExpressionTreeNode SimplifyGreaterThan(ISymbolicExpressionTreeNode original) {
-      return MakeGreaterThan(GetSimplifiedTree(original.GetSubTree(0)), GetSimplifiedTree(original.GetSubTree(1)));
+      return MakeGreaterThan(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
     private ISymbolicExpressionTreeNode SimplifyIfThenElse(ISymbolicExpressionTreeNode original) {
-      return MakeIfThenElse(GetSimplifiedTree(original.GetSubTree(0)), GetSimplifiedTree(original.GetSubTree(1)), GetSimplifiedTree(original.GetSubTree(2)));
+      return MakeIfThenElse(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)), GetSimplifiedTree(original.GetSubtree(2)));
     }
     private ISymbolicExpressionTreeNode SimplifyTangent(ISymbolicExpressionTreeNode original) {
-      return MakeTangent(GetSimplifiedTree(original.GetSubTree(0)));
+      return MakeTangent(GetSimplifiedTree(original.GetSubtree(0)));
     }
     private ISymbolicExpressionTreeNode SimplifyCosine(ISymbolicExpressionTreeNode original) {
-      return MakeCosine(GetSimplifiedTree(original.GetSubTree(0)));
+      return MakeCosine(GetSimplifiedTree(original.GetSubtree(0)));
     }
     private ISymbolicExpressionTreeNode SimplifySine(ISymbolicExpressionTreeNode original) {
-      return MakeSine(GetSimplifiedTree(original.GetSubTree(0)));
+      return MakeSine(GetSimplifiedTree(original.GetSubtree(0)));
     }
     private ISymbolicExpressionTreeNode SimplifyExp(ISymbolicExpressionTreeNode original) {
-      return MakeExp(GetSimplifiedTree(original.GetSubTree(0)));
+      return MakeExp(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
     private ISymbolicExpressionTreeNode SimplifyLog(ISymbolicExpressionTreeNode original) {
-      return MakeLog(GetSimplifiedTree(original.GetSubTree(0)));
+      return MakeLog(GetSimplifiedTree(original.GetSubtree(0)));
     }
     private ISymbolicExpressionTreeNode SimplifyRoot(ISymbolicExpressionTreeNode original) {
-      return MakeRoot(GetSimplifiedTree(original.GetSubTree(0)), GetSimplifiedTree(original.GetSubTree(1)));
+      return MakeRoot(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
 
     private ISymbolicExpressionTreeNode SimplifyPower(ISymbolicExpressionTreeNode original) {
-      return MakePower(GetSimplifiedTree(original.GetSubTree(0)), GetSimplifiedTree(original.GetSubTree(1)));
+      return MakePower(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
     #endregion
@@ -373 +373 @@
         else return MakeConstant(1.0);
       } else if (IsNot(t)) {
-        return t.GetSubTree(0);
+        return t.GetSubtree(0);
       } else if (!IsBoolean(t)) {
         var gtNode = gtSymbol.CreateTreeNode();
-        gtNode.AddSubTree(t); gtNode.AddSubTree(MakeConstant(0.0));
+        gtNode.AddSubtree(t); gtNode.AddSubtree(MakeConstant(0.0));
         var notNode = notSymbol.CreateTreeNode();
-        notNode.AddSubTree(gtNode);
+        notNode.AddSubtree(gtNode);
         return notNode;
       } else {
         var notNode = notSymbol.CreateTreeNode();
-        notNode.AddSubTree(t);
+        notNode.AddSubtree(t);
         return notNode;
       }
@@ -406 +406 @@
           // the constant value has no effect on the result of the boolean condition so we can drop the constant term
           var orNode = orSymbol.CreateTreeNode();
-          orNode.AddSubTree(a);
+          orNode.AddSubtree(a);
           return orNode;
         }
       } else {
         var orNode = orSymbol.CreateTreeNode();
-        orNode.AddSubTree(a);
-        orNode.AddSubTree(b);
+        orNode.AddSubtree(a);
+        orNode.AddSubtree(b);
         return orNode;
       }
@@ -432 +432 @@
           // the constant value has no effect on the result of the boolean condition so we can drop the constant term
           var andNode = andSymbol.CreateTreeNode();
-          andNode.AddSubTree(a);
+          andNode.AddSubtree(a);
           return andNode;
         } else {
@@ -440 +440 @@
       } else {
         var andNode = andSymbol.CreateTreeNode();
-        andNode.AddSubTree(a);
-        andNode.AddSubTree(b);
+        andNode.AddSubtree(a);
+        andNode.AddSubtree(b);
         return andNode;
       }
@@ -453 +453 @@
       } else {
         var ltNode = ltSymbol.CreateTreeNode();
-        ltNode.AddSubTree(leftSide);
-        ltNode.AddSubTree(rightSide);
+        ltNode.AddSubtree(leftSide);
+        ltNode.AddSubtree(rightSide);
         return ltNode;
       }
@@ -466 +466 @@
       } else {
         var gtNode = gtSymbol.CreateTreeNode();
-        gtNode.AddSubTree(leftSide);
-        gtNode.AddSubTree(rightSide);
+        gtNode.AddSubtree(leftSide);
+        gtNode.AddSubtree(rightSide);
         return gtNode;
       }
@@ -479 +479 @@
         var ifNode = ifThenElseSymbol.CreateTreeNode();
         if (IsBoolean(condition)) {
-          ifNode.AddSubTree(condition);
+          ifNode.AddSubtree(condition);
         } else {
           var gtNode = gtSymbol.CreateTreeNode();
-          gtNode.AddSubTree(condition); gtNode.AddSubTree(MakeConstant(0.0));
-          ifNode.AddSubTree(gtNode);
-        }
-        ifNode.AddSubTree(trueBranch);
-        ifNode.AddSubTree(falseBranch);
+          gtNode.AddSubtree(condition); gtNode.AddSubtree(MakeConstant(0.0));
+          ifNode.AddSubtree(gtNode);
+        }
+        ifNode.AddSubtree(trueBranch);
+        ifNode.AddSubtree(falseBranch);
         return ifNode;
       }
@@ -497 +497 @@
       } else {
         var sineNode = sineSymbol.CreateTreeNode();
-        sineNode.AddSubTree(node);
+        sineNode.AddSubtree(node);
         return sineNode;
       }
@@ -507 +507 @@
       } else {
         var tanNode = tanSymbol.CreateTreeNode();
-        tanNode.AddSubTree(node);
+        tanNode.AddSubtree(node);
         return tanNode;
       }
@@ -517 +517 @@
       } else {
         var cosNode = cosineSymbol.CreateTreeNode();
-        cosNode.AddSubTree(node);
+        cosNode.AddSubtree(node);
         return cosNode;
       }
@@ -526 +526 @@
         return MakeConstant(Math.Exp(constT.Value));
       } else if (IsLog(node)) {
-        return node.GetSubTree(0);
+        return node.GetSubtree(0);
       } else if (IsAddition(node)) {
-        return node.SubTrees.Select(s => MakeExp(s)).Aggregate((s, t) => MakeProduct(s, t));
+        return node.Subtrees.Select(s => MakeExp(s)).Aggregate((s, t) => MakeProduct(s, t));
       } else if (IsSubtraction(node)) {
-        return node.SubTrees.Select(s => MakeExp(s)).Aggregate((s, t) => MakeProduct(s, Negate(t)));
+        return node.Subtrees.Select(s => MakeExp(s)).Aggregate((s, t) => MakeProduct(s, Negate(t)));
       } else {
         var expNode = expSymbol.CreateTreeNode();
-        expNode.AddSubTree(node);
+        expNode.AddSubtree(node);
         return expNode;
       }
@@ -542 +542 @@
         return MakeConstant(Math.Log(constT.Value));
       } else if (IsExp(node)) {
-        return node.GetSubTree(0);
+        return node.GetSubtree(0);
       } else if (IsMultiplication(node)) {
-        return node.SubTrees.Select(s => MakeLog(s)).Aggregate((x, y) => MakeSum(x, y));
+        return node.Subtrees.Select(s => MakeLog(s)).Aggregate((x, y) => MakeSum(x, y));
       } else if (IsDivision(node)) {
         var subtractionNode = subSymbol.CreateTreeNode();
-        foreach (var subTree in node.SubTrees) {
-          subtractionNode.AddSubTree(MakeLog(subTree));
+        foreach (var subtree in node.Subtrees) {
+          subtractionNode.AddSubtree(MakeLog(subtree));
         }
         return subtractionNode;
       } else {
         var logNode = logSymbol.CreateTreeNode();
-        logNode.AddSubTree(node);
+        logNode.AddSubtree(node);
         return logNode;
       }
@@ -573 +573 @@
         } else if (constBValue < 0) {
           var rootNode = rootSymbol.CreateTreeNode();
-          rootNode.AddSubTree(a);
-          rootNode.AddSubTree(MakeConstant(-1.0 * constBValue));
+          rootNode.AddSubtree(a);
+          rootNode.AddSubtree(MakeConstant(-1.0 * constBValue));
           return MakeFraction(MakeConstant(1.0), rootNode);
         } else {
           var rootNode = rootSymbol.CreateTreeNode();
-          rootNode.AddSubTree(a);
-          rootNode.AddSubTree(MakeConstant(constBValue));
+          rootNode.AddSubtree(a);
+          rootNode.AddSubtree(MakeConstant(constBValue));
           return rootNode;
         }
       } else {
         var rootNode = rootSymbol.CreateTreeNode();
-        rootNode.AddSubTree(a);
-        rootNode.AddSubTree(b);
+        rootNode.AddSubtree(a);
+        rootNode.AddSubtree(b);
         return rootNode;
       }
@@ -605 +605 @@
         } else if (exponent < 0) {
           var powNode = powSymbol.CreateTreeNode();
-          powNode.AddSubTree(a);
-          powNode.AddSubTree(MakeConstant(-1.0 * exponent));
+          powNode.AddSubtree(a);
+          powNode.AddSubtree(MakeConstant(-1.0 * exponent));
           return MakeFraction(MakeConstant(1.0), powNode);
         } else {
           var powNode = powSymbol.CreateTreeNode();
-          powNode.AddSubTree(a);
-          powNode.AddSubTree(MakeConstant(exponent));
+          powNode.AddSubtree(a);
+          powNode.AddSubtree(MakeConstant(exponent));
           return powNode;
         }
       } else {
         var powNode = powSymbol.CreateTreeNode();
-        powNode.AddSubTree(a);
-        powNode.AddSubTree(b);
+        powNode.AddSubtree(a);
+        powNode.AddSubtree(b);
         return powNode;
       }
@@ -641 +641 @@
         return MakeConstant(aVar.Weight / bVar.Weight);
       } else if (IsAddition(a) && IsConstant(b)) {
-        return a.SubTrees
+        return a.Subtrees
           .Select(x => GetSimplifiedTree(x))
          .Select(x => MakeFraction(x, b))
@@ -649 +649 @@
       } else if (IsDivision(a) && IsConstant(b)) {
         // (a1 / a2) / c => (a1 / (a2 * c))
-        Trace.Assert(a.SubTrees.Count() == 2);
-        return MakeFraction(a.GetSubTree(0), MakeProduct(a.GetSubTree(1), b));
+        Trace.Assert(a.Subtrees.Count() == 2);
+        return MakeFraction(a.GetSubtree(0), MakeProduct(a.GetSubtree(1), b));
       } else if (IsDivision(a) && IsDivision(b)) {
         // (a1 / a2) / (b1 / b2) => 
-        Trace.Assert(a.SubTrees.Count() == 2);
-        Trace.Assert(b.SubTrees.Count() == 2);
-        return MakeFraction(MakeProduct(a.GetSubTree(0), b.GetSubTree(1)), MakeProduct(a.GetSubTree(1), b.GetSubTree(0)));
+        Trace.Assert(a.Subtrees.Count() == 2);
+        Trace.Assert(b.Subtrees.Count() == 2);
+        return MakeFraction(MakeProduct(a.GetSubtree(0), b.GetSubtree(1)), MakeProduct(a.GetSubtree(1), b.GetSubtree(0)));
       } else if (IsDivision(a)) {
         // (a1 / a2) / b => (a1 / (a2 * b))
-        Trace.Assert(a.SubTrees.Count() == 2);
-        return MakeFraction(a.GetSubTree(0), MakeProduct(a.GetSubTree(1), b));
+        Trace.Assert(a.Subtrees.Count() == 2);
+        return MakeFraction(a.GetSubtree(0), MakeProduct(a.GetSubtree(1), b));
       } else if (IsDivision(b)) {
         // a / (b1 / b2) => (a * b2) / b1
-        Trace.Assert(b.SubTrees.Count() == 2);
-        return MakeFraction(MakeProduct(a, b.GetSubTree(1)), b.GetSubTree(0));
+        Trace.Assert(b.Subtrees.Count() == 2);
+        return MakeFraction(MakeProduct(a, b.GetSubtree(1)), b.GetSubtree(0));
       } else {
         var div = divSymbol.CreateTreeNode();
-        div.AddSubTree(a);
-        div.AddSubTree(b);
+        div.AddSubtree(a);
+        div.AddSubtree(b);
         return div;
       }
@@ -688 +688 @@
         var add = addSymbol.CreateTreeNode();
         // add all sub trees except for the last
-        for (int i = 0; i < a.SubTrees.Count() - 1; i++) add.AddSubTree(a.GetSubTree(i));
-        for (int i = 0; i < b.SubTrees.Count() - 1; i++) add.AddSubTree(b.GetSubTree(i));
-        if (IsConstant(a.SubTrees.Last()) && IsConstant(b.SubTrees.Last())) {
-          add.AddSubTree(MakeSum(a.SubTrees.Last(), b.SubTrees.Last()));
-        } else if (IsConstant(a.SubTrees.Last())) {
-          add.AddSubTree(b.SubTrees.Last());
-          add.AddSubTree(a.SubTrees.Last());
-        } else {
-          add.AddSubTree(a.SubTrees.Last());
-          add.AddSubTree(b.SubTrees.Last());
+        for (int i = 0; i < a.Subtrees.Count() - 1; i++) add.AddSubtree(a.GetSubtree(i));
+        for (int i = 0; i < b.Subtrees.Count() - 1; i++) add.AddSubtree(b.GetSubtree(i));
+        if (IsConstant(a.Subtrees.Last()) && IsConstant(b.Subtrees.Last())) {
+          add.AddSubtree(MakeSum(a.Subtrees.Last(), b.Subtrees.Last()));
+        } else if (IsConstant(a.Subtrees.Last())) {
+          add.AddSubtree(b.Subtrees.Last());
+          add.AddSubtree(a.Subtrees.Last());
+        } else {
+          add.AddSubtree(a.Subtrees.Last());
+          add.AddSubtree(b.Subtrees.Last());
         }
         MergeVariablesInSum(add);
-        if (add.SubTrees.Count() == 1) {
-          return add.GetSubTree(0);
+        if (add.Subtrees.Count() == 1) {
+          return add.GetSubtree(0);
         } else {
           return add;
@@ -711 +711 @@
         var add = addSymbol.CreateTreeNode();
         // add all sub trees except for the last
-        for (int i = 0; i < a.SubTrees.Count() - 1; i++) add.AddSubTree(a.GetSubTree(i));
-        if (IsConstant(a.SubTrees.Last()))
-          add.AddSubTree(MakeSum(a.SubTrees.Last(), b));
+        for (int i = 0; i < a.Subtrees.Count() - 1; i++) add.AddSubtree(a.GetSubtree(i));
+        if (IsConstant(a.Subtrees.Last()))
+          add.AddSubtree(MakeSum(a.Subtrees.Last(), b));
         else {
-          add.AddSubTree(a.SubTrees.Last());
-          add.AddSubTree(b);
+          add.AddSubtree(a.Subtrees.Last());
+          add.AddSubtree(b);
         }
         return add;
@@ -722 +722 @@
         // a is already an addition => append b
         var add = addSymbol.CreateTreeNode();
-        add.AddSubTree(b);
-        foreach (var subTree in a.SubTrees) {
-          add.AddSubTree(subTree);
+        add.AddSubtree(b);
+        foreach (var subtree in a.Subtrees) {
+          add.AddSubtree(subtree);
         }
         MergeVariablesInSum(add);
-        if (add.SubTrees.Count() == 1) {
-          return add.GetSubTree(0);
+        if (add.Subtrees.Count() == 1) {
+          return add.GetSubtree(0);
         } else {
           return add;
@@ -734 +734 @@
       } else {
         var add = addSymbol.CreateTreeNode();
-        add.AddSubTree(a);
-        add.AddSubTree(b);
+        add.AddSubtree(a);
+        add.AddSubtree(b);
         MergeVariablesInSum(add);
-        if (add.SubTrees.Count() == 1) {
-          return add.GetSubTree(0);
+        if (add.Subtrees.Count() == 1) {
+          return add.GetSubtree(0);
         } else {
           return add;
@@ -748 +748 @@
     // possible improvement: combine sums of products where the products only reference the same variable
     private void MergeVariablesInSum(ISymbolicExpressionTreeNode sum) {
-      var subtrees = new List<ISymbolicExpressionTreeNode>(sum.SubTrees);
-      while (sum.SubTrees.Count() > 0) sum.RemoveSubTree(0);
+      var subtrees = new List<ISymbolicExpressionTreeNode>(sum.Subtrees);
+      while (sum.Subtrees.Count() > 0) sum.RemoveSubtree(0);
       var groupedVarNodes = from node in subtrees.OfType<VariableTreeNode>()
                             let lag = (node is LaggedVariableTreeNode) ? ((LaggedVariableTreeNode)node).Lag : 0
                             group node by node.VariableName + lag into g
                             select g;
-      var unchangedSubTrees = subtrees.Where(t => !(t is VariableTreeNode));
+      var unchangedSubtrees = subtrees.Where(t => !(t is VariableTreeNode));
 
       foreach (var variableNodeGroup in groupedVarNodes) {
@@ -760 +760 @@
         var representative = variableNodeGroup.First();
         representative.Weight = weightSum;
-        sum.AddSubTree(representative);
-      }
-      foreach (var unchangedSubtree in unchangedSubTrees)
-        sum.AddSubTree(unchangedSubtree);
+        sum.AddSubtree(representative);
+      }
+      foreach (var unchangedSubtree in unchangedSubtrees)
+        sum.AddSubtree(unchangedSubtree);
     }
 
@@ -784 +784 @@
       } else if (IsConstant(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(x, b)).Aggregate((c, d) => MakeSum(c, d));
       } else if (IsDivision(a) && IsDivision(b)) {
         // (a1 / a2) * (b1 / b2) => (a1 * b1) / (a2 * b2)
-        Trace.Assert(a.SubTrees.Count() == 2);
-        Trace.Assert(b.SubTrees.Count() == 2);
-        return MakeFraction(MakeProduct(a.GetSubTree(0), b.GetSubTree(0)), MakeProduct(a.GetSubTree(1), b.GetSubTree(1)));
+        Trace.Assert(a.Subtrees.Count() == 2);
+        Trace.Assert(b.Subtrees.Count() == 2);
+        return MakeFraction(MakeProduct(a.GetSubtree(0), b.GetSubtree(0)), MakeProduct(a.GetSubtree(1), b.GetSubtree(1)));
       } else if (IsDivision(a)) {
         // (a1 / a2) * b => (a1 * b) / a2
-        Trace.Assert(a.SubTrees.Count() == 2);
-        return MakeFraction(MakeProduct(a.GetSubTree(0), b), a.GetSubTree(1));
+        Trace.Assert(a.Subtrees.Count() == 2);
+        return MakeFraction(MakeProduct(a.GetSubtree(0), b), a.GetSubtree(1));
       } else if (IsDivision(b)) {
         // a * (b1 / b2) => (b1 * a) / b2
-        Trace.Assert(b.SubTrees.Count() == 2);
-        return MakeFraction(MakeProduct(b.GetSubTree(0), a), b.GetSubTree(1));
+        Trace.Assert(b.Subtrees.Count() == 2);
+        return MakeFraction(MakeProduct(b.GetSubtree(0), a), b.GetSubtree(1));
       } else if (IsMultiplication(a) && IsMultiplication(b)) {
         // merge multiplications (make sure constants are merged)
         var mul = mulSymbol.CreateTreeNode();
-        for (int i = 0; i < a.SubTrees.Count(); i++) mul.AddSubTree(a.GetSubTree(i));
-        for (int i = 0; i < b.SubTrees.Count(); i++) mul.AddSubTree(b.GetSubTree(i));
+        for (int i = 0; i < a.Subtrees.Count(); i++) mul.AddSubtree(a.GetSubtree(i));
+        for (int i = 0; i < b.Subtrees.Count(); i++) mul.AddSubtree(b.GetSubtree(i));
         MergeVariablesAndConstantsInProduct(mul);
         return mul;
@@ -809 +809 @@
       } else if (IsMultiplication(a)) {
         // a is already an multiplication => append b
-        a.AddSubTree(b);
+        a.AddSubtree(b);
         MergeVariablesAndConstantsInProduct(a);
         return a;
       } else {
         var mul = mulSymbol.CreateTreeNode();
-        mul.AddSubTree(a);
-        mul.AddSubTree(b);
+        mul.AddSubtree(a);
+        mul.AddSubtree(b);
         MergeVariablesAndConstantsInProduct(mul);
         return mul;
@@ -842 +842 @@
     // helper to combine the constant factors in products and to combine variables (powers of 2, 3...)
     private void MergeVariablesAndConstantsInProduct(ISymbolicExpressionTreeNode prod) {
-      var subtrees = new List<ISymbolicExpressionTreeNode>(prod.SubTrees);
-      while (prod.SubTrees.Count() > 0) prod.RemoveSubTree(0);
+      var subtrees = new List<ISymbolicExpressionTreeNode>(prod.Subtrees);
+      while (prod.Subtrees.Count() > 0) prod.RemoveSubtree(0);
       var groupedVarNodes = from node in subtrees.OfType<VariableTreeNode>()
                             let lag = (node is LaggedVariableTreeNode) ? ((LaggedVariableTreeNode)node).Lag : 0
@@ -856 +856 @@
                             .Aggregate((c1, c2) => c1 * c2);
 
-      var unchangedSubTrees = from tree in subtrees
+      var unchangedSubtrees = from tree in subtrees
                               where !(tree is VariableTreeNode)
                               where !(tree is ConstantTreeNode)
@@ -867 +867 @@
           var poly = mulSymbol.CreateTreeNode();
           for (int p = 0; p < variableNodeGroup.Count(); p++) {
-            poly.AddSubTree((ISymbolicExpressionTreeNode)representative.Clone());
+            poly.AddSubtree((ISymbolicExpressionTreeNode)representative.Clone());
           }
-          prod.AddSubTree(poly);
-        } else {
-          prod.AddSubTree(representative);
-        }
-      }
-
-      foreach (var unchangedSubtree in unchangedSubTrees)
-        prod.AddSubTree(unchangedSubtree);
+          prod.AddSubtree(poly);
+        } else {
+          prod.AddSubtree(representative);
+        }
+      }
+
+      foreach (var unchangedSubtree in unchangedSubtrees)
+        prod.AddSubtree(unchangedSubtree);
 
       if (!constantProduct.IsAlmost(1.0)) {
-        prod.AddSubTree(MakeConstant(constantProduct));
+        prod.AddSubtree(MakeConstant(constantProduct));
       }
     }
@@ -898 +898 @@
       } else if (IsAddition(x)) {
         // (x0 + x1 + .. + xn) * -1 => (-x0 + -x1 + .. + -xn)        
-        List<ISymbolicExpressionTreeNode> subTrees = new List<ISymbolicExpressionTreeNode>(x.SubTrees);
-        while (x.SubTrees.Count() > 0) x.RemoveSubTree(0);
-        foreach (var subTree in subTrees) {
-          x.AddSubTree(Negate(subTree));
+        List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(x.Subtrees);
+        while (x.Subtrees.Count() > 0) x.RemoveSubtree(0);
+        foreach (var subtree in subtrees) {
+          x.AddSubtree(Negate(subtree));
         }
       } else if (IsMultiplication(x) || IsDivision(x)) {
         // x0 * x1 * .. * xn * -1 => x0 * x1 * .. * -xn
-        x.RemoveSubTree(x.SubTrees.Count() - 1);
-        x.AddSubTree(Negate(x.SubTrees.Last())); // last is maybe a constant, prefer to negate the constant
+        x.RemoveSubtree(x.Subtrees.Count() - 1);
+        x.AddSubtree(Negate(x.Subtrees.Last())); // last is maybe a constant, prefer to negate the constant
       } else {
         // any other function
@@ -924 +924 @@
         return MakeConstant(1.0 / ((ConstantTreeNode)x).Value);
       } else if (IsDivision(x)) {
-        Trace.Assert(x.SubTrees.Count() == 2);
-        return MakeFraction(x.GetSubTree(1), x.GetSubTree(0));
+        Trace.Assert(x.Subtrees.Count() == 2);
+        return MakeFraction(x.GetSubtree(1), x.GetSubtree(0));
       } else {
         // any other function