Changeset 5461 for trunk/sources/HeuristicLab.Problems.DataAnalysis

Timestamp:

02/15/11 10:34:38 (14 years ago)

Author:

gkronber

Message:

#1227 implemented transformations in simplifier to successfully run current set of test cases.

Location:

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3

Files:

• Symbolic/SymbolicSimplifier.cs (modified) (13 diffs)
• Tests/SymbolicSimplifierTest.cs (modified) (6 diffs)

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/SymbolicSimplifier.cs

@@ -35 +35 @@
   public class SymbolicSimplifier {
     private Addition addSymbol = new Addition();
+    private Subtraction subSymbol = new Subtraction();
     private Multiplication mulSymbol = new Multiplication();
     private Division divSymbol = new Division();
@@ -151 +152 @@
     private bool IsLessThan(SymbolicExpressionTreeNode node) {
       return node.Symbol is LessThan;
+    }
+
+    private bool IsBoolean(SymbolicExpressionTreeNode node) {
+      return
+        node.Symbol is GreaterThan ||
+        node.Symbol is LessThan ||
+        node.Symbol is And ||
+        node.Symbol is Or;
     }
 
@@ -439 +448 @@
       } else {
         var ifNode = ifThenElseSymbol.CreateTreeNode();
-        ifNode.AddSubTree(condition);
+        if (IsBoolean(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);
@@ -445 +460 @@
       }
     }
+
     private SymbolicExpressionTreeNode MakeSine(SymbolicExpressionTreeNode node) {
       // todo implement more transformation rules
@@ -483 +499 @@
         var constT = node as ConstantTreeNode;
         return MakeConstant(Math.Exp(constT.Value));
+      } else if (IsLog(node)) {
+        return node.SubTrees[0];
       } else {
         var expNode = expSymbol.CreateTreeNode();
@@ -494 +512 @@
         var constT = node as ConstantTreeNode;
         return MakeConstant(Math.Log(constT.Value));
+      } else if (IsExp(node)) {
+        return node.SubTrees[0];
+      } else if (IsMultiplication(node)) {
+        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));
+        }
+        return subtractionNode;
       } else {
         var logNode = logSymbol.CreateTreeNode();
@@ -503 +531 @@
 
     // MakeFraction, MakeProduct and MakeSum take two already simplified trees and create a new simplified tree
-
     private SymbolicExpressionTreeNode MakeFraction(SymbolicExpressionTreeNode a, SymbolicExpressionTreeNode b) {
       if (IsConstant(a) && IsConstant(b)) {
@@ -515 +542 @@
         ((VariableTreeNode)a).Weight /= constB;
         return a;
+      } else if (IsVariable(a) && IsVariable(b) && AreSameVariable(a, b)) {
+        // cancel variables
+        var aVar = a as VariableTreeNode;
+        var bVar = b as VariableTreeNode;
+        return MakeConstant(aVar.Weight / bVar.Weight);
       } else if (IsAddition(a) && IsConstant(b)) {
         return a.SubTrees
@@ -574 +606 @@
         }
         MergeVariablesInSum(add);
-        return add;
+        if (add.SubTrees.Count == 1) {
+          return add.SubTrees[0];
+        } else {
+          return add;
+        }
       } else if (IsAddition(b)) {
         return MakeSum(b, a);
@@ -596 +632 @@
         }
         MergeVariablesInSum(add);
-        return add;
+        if (add.SubTrees.Count == 1) {
+          return add.SubTrees[0];
+        } else {
+          return add;
+        }
       } else {
         var add = addSymbol.CreateTreeNode();
@@ -602 +642 @@
         add.AddSubTree(b);
         MergeVariablesInSum(add);
-        return add;
+        if (add.SubTrees.Count == 1) {
+          return add.SubTrees[0];
+        } else {
+          return add;
+        }
       }
     }
 
     // makes sure variable symbols in sums are combined
-    // possible improvment: combine sums of products where the products only reference the same variable
+    // possible improvement: combine sums of products where the products only reference the same variable
     private void MergeVariablesInSum(SymbolicExpressionTreeNode sum) {
       var subtrees = new List<SymbolicExpressionTreeNode>(sum.SubTrees);
@@ -683 +727 @@
     #endregion
 
+
+    #region helper functions
+
+    private bool AreSameVariable(SymbolicExpressionTreeNode a, SymbolicExpressionTreeNode b) {
+      var aLaggedVar = a as LaggedVariableTreeNode;
+      var bLaggedVar = b as LaggedVariableTreeNode;
+      if (aLaggedVar != null && bLaggedVar != null) {
+        return aLaggedVar.VariableName == bLaggedVar.VariableName &&
+          aLaggedVar.Lag == bLaggedVar.Lag;
+      }
+      var aVar = a as VariableTreeNode;
+      var bVar = b as VariableTreeNode;
+      if (aVar != null && bVar != null) {
+        return aVar.VariableName == bVar.VariableName;
+      }
+      return false;
+    }
+
     // helper to combine the constant factors in products and to combine variables (powers of 2, 3...)
     private void MergeVariablesAndConstantsInProduct(SymbolicExpressionTreeNode prod) {
@@ -727 +789 @@
 
 
-    #region helper functions
     /// <summary>
     /// x => x * -1

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Tests/SymbolicSimplifierTest.cs

@@ -140 +140 @@
       }
       #endregion
+      #region constant and variable folding
+      {
+        var actualTree = simplifier.Simplify(importer.Import("(+ 1.0 2.0)"));
+        var expectedTree = importer.Import("3.0");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      {
+        var actualTree = simplifier.Simplify(importer.Import("(+ (variable 2.0 a) (variable 2.0 a))"));
+        var expectedTree = importer.Import("(variable 4.0 a)");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      {
+        var actualTree = simplifier.Simplify(importer.Import("(- (variable 2.0 a) (variable 1.0 a))"));
+        var expectedTree = importer.Import("(variable 1.0 a)");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      {
+        var actualTree = simplifier.Simplify(importer.Import("(* (variable 2.0 a) (variable 2.0 a))"));
+        var expectedTree = importer.Import("(* (* (variable 1.0 a) (variable 1.0 a)) 4.0)");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      {
+        var actualTree = simplifier.Simplify(importer.Import("(/ (variable 1.0 a) (variable 2.0 a))"));
+        var expectedTree = importer.Import("0.5");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      #endregion
       #region logarithm rules
       {
@@ -155 +182 @@
       {
         // log transformation
-        var actualTree = simplifier.Simplify(importer.Import("(log (* (variable 2.0 a) (variable 3.0 b))"));
-        var expectedTree = importer.Import("(+ (log (variable 2.0 a)) (log (variable 3.0 b)))");
+        var actualTree = simplifier.Simplify(importer.Import("(log (* (variable 2.0 a) (variable 3.0 b)))"));
+        var expectedTree = importer.Import("(+ (log (variable 1.0 a)) (log (variable 1.0 b)) 1.7918)");
         Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
       }
       {
         // log transformation
-        var actualTree = simplifier.Simplify(importer.Import("(log (/ (variable 2.0 a) (variable 3.0 b))"));
+        var actualTree = simplifier.Simplify(importer.Import("(log (/ (variable 2.0 a) (variable 3.0 b)))"));
         var expectedTree = importer.Import("(- (log (variable 2.0 a)) (log (variable 3.0 b)))");
         Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
@@ -194 +221 @@
         // constant not 
         var actualTree = simplifier.Simplify(importer.Import("(not -2.0)"));
-        var expectedTree = importer.Import("1.0");
+        var expectedTree = importer.Import("2.0");
         Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
       }
@@ -200 +227 @@
         // constant not 
         var actualTree = simplifier.Simplify(importer.Import("(not 2.0)"));
-        var expectedTree = importer.Import("-1.0");
+        var expectedTree = importer.Import("-2.0");
         Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
       }
@@ -206 +233 @@
         // constant not 
         var actualTree = simplifier.Simplify(importer.Import("(not 0.0)"));
-        var expectedTree = importer.Import("1.0");
+        var expectedTree = importer.Import("0.0");
         Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
       }
@@ -245 +272 @@
         var actualTree = simplifier.Simplify(importer.Import("(if (variable 1.0 a) (variable 2.0 a) (variable 3.0 a))"));
         var expectedTree = importer.Import("(if (> (variable 1.0 a) 0.0) (variable 2.0 a) (variable 3.0 a))");
-        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
-      }
-      #endregion
-      #region constant and variable folding
-      {
-        var actualTree = simplifier.Simplify(importer.Import("(+ 1.0 2.0)"));
-        var expectedTree = importer.Import("3.0");
-        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
-      }
-      {
-        var actualTree = simplifier.Simplify(importer.Import("(+ (variable 2.0 a) (variable 2.0 a))"));
-        var expectedTree = importer.Import("(variable 4.0 a)");
-        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
-      }
-      {
-        var actualTree = simplifier.Simplify(importer.Import("(- (variable 2.0 a) (variable 1.0 a))"));
-        var expectedTree = importer.Import("(variable 1.0 a)");
-        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
-      }
-      {
-        var actualTree = simplifier.Simplify(importer.Import("(* (variable 2.0 a) (variable 2.0 a))"));
-        var expectedTree = importer.Import("(* (* (variable 1.0 a) (variable 1.0 a)) 4.0)");
-        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
-      }
-      {
-        var actualTree = simplifier.Simplify(importer.Import("(/ (variable 1.0 a) (variable 2.0 a))"));
-        var expectedTree = importer.Import("0.5");
         Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
       }