Changeset 7842 for branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs

Timestamp:

05/16/12 16:28:49 (12 years ago)

Author:

gkronber

Message:

merged r7609:7840 from trunk into time series branch

Location:

branches/HeuristicLab.TimeSeries

Files:

• . (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs (modified) (10 diffs)

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

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using HeuristicLab.Common;
@@ -41 +40 @@
     private Exponential expSymbol = new Exponential();
     private Root rootSymbol = new Root();
+    private Square sqrSymbol = new Square();
+    private SquareRoot sqrtSymbol = new SquareRoot();
     private Power powSymbol = new Power();
     private Sine sineSymbol = new Sine();
@@ -128 +129 @@
     private bool IsRoot(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Root;
+    }
+    private bool IsSquare(ISymbolicExpressionTreeNode node) {
+      return node.Symbol is Square;
+    }
+    private bool IsSquareRoot(ISymbolicExpressionTreeNode node) {
+      return node.Symbol is SquareRoot;
     }
     private bool IsPower(ISymbolicExpressionTreeNode node) {
@@ -212 +219 @@
       } else if (IsExp(original)) {
         return SimplifyExp(original);
+      } else if (IsSquare(original)) {
+        return SimplifySquare(original);
+      } else if (IsSquareRoot(original)) {
+        return SimplifySquareRoot(original);
+      } else if (IsPower(original)) {
+        return SimplifyPower(original);
       } else if (IsRoot(original)) {
         return SimplifyRoot(original);
-      } else if (IsPower(original)) {
-        return SimplifyPower(original);
       } else if (IsSine(original)) {
         return SimplifySine(original);
@@ -363 +374 @@
       return MakeExp(GetSimplifiedTree(original.GetSubtree(0)));
     }
+    private ISymbolicExpressionTreeNode SimplifySquare(ISymbolicExpressionTreeNode original) {
+      return MakeSquare(GetSimplifiedTree(original.GetSubtree(0)));
+    }
+    private ISymbolicExpressionTreeNode SimplifySquareRoot(ISymbolicExpressionTreeNode original) {
+      return MakeSquareRoot(GetSimplifiedTree(original.GetSubtree(0)));
+    }
 
     private ISymbolicExpressionTreeNode SimplifyLog(ISymbolicExpressionTreeNode original) {
@@ -587 +604 @@
       }
     }
+
+    private ISymbolicExpressionTreeNode MakeSquare(ISymbolicExpressionTreeNode node) {
+      if (IsConstant(node)) {
+        var constT = node as ConstantTreeNode;
+        return MakeConstant(constT.Value * constT.Value);
+      } else if (IsSquareRoot(node)) {
+        return node.GetSubtree(0);
+      } else {
+        var sqrNode = sqrSymbol.CreateTreeNode();
+        sqrNode.AddSubtree(node);
+        return sqrNode;
+      }
+    }
+    private ISymbolicExpressionTreeNode MakeSquareRoot(ISymbolicExpressionTreeNode node) {
+      if (IsConstant(node)) {
+        var constT = node as ConstantTreeNode;
+        return MakeConstant(Math.Sqrt(constT.Value));
+      } else if (IsSquare(node)) {
+        return node.GetSubtree(0);
+      } else {
+        var sqrtNode = sqrtSymbol.CreateTreeNode();
+        sqrtNode.AddSubtree(node);
+        return sqrtNode;
+      }
+    }
+
     private ISymbolicExpressionTreeNode MakeLog(ISymbolicExpressionTreeNode node) {
       if (IsConstant(node)) {
@@ -593 +636 @@
       } else if (IsExp(node)) {
         return node.GetSubtree(0);
+      } else if (IsSquareRoot(node)) {
+        return MakeFraction(MakeLog(node.GetSubtree(0)), MakeConstant(2.0));
       } else {
         var logNode = logSymbol.CreateTreeNode();
@@ -691 +736 @@
       } 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));
       } 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)));
       } 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));
       } 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));
       } else {
@@ -829 +869 @@
       } 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)));
       } 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));
       } 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));
       } else if (IsMultiplication(a) && IsMultiplication(b)) {
@@ -995 +1031 @@
         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));
       } else {