Changeset 5465 for trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Tests

Timestamp:

02/15/11 13:36:45 (14 years ago)

Author:

gkronber

Message:

#1227 implemented test cases and transformation rules for root and power symbols.

Location:

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

Files:

• SymbolicExpressionImporter.cs (modified) (1 diff)
• SymbolicSimplifierTest.cs (modified) (2 diffs)

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

@@ -42 +42 @@
         {"EXP", new Exponential()},
         {"LOG", new Logarithm()},
+        {"POW", new Power()},
+        {"ROOT", new Root()},
         {"SIN",new Sine()},
         {"COS", new Cosine()},

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

@@ -170 +170 @@
       {
         // cancellation
-        var actualTree = simplifier.Simplify(importer.Import("(exp (log (variable 2.0 a)))"));
-        var expectedTree = importer.Import("(variable 2.0 a)");
-        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
-      }
-      {
-        // cancellation
         var actualTree = simplifier.Simplify(importer.Import("(log (exp (variable 2.0 a)))"));
         var expectedTree = importer.Import("(variable 2.0 a)");
@@ -190 +184 @@
         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));
+      }
+      #endregion
+      #region exponentiation rules
+      {
+        // cancellation
+        var actualTree = simplifier.Simplify(importer.Import("(exp (log (variable 2.0 a)))"));
+        var expectedTree = importer.Import("(variable 2.0 a)");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      {
+        // exp transformation
+        var actualTree = simplifier.Simplify(importer.Import("(exp (+ (variable 2.0 a) (variable 3.0 b)))"));
+        var expectedTree = importer.Import("(* (exp (variable 2.0 a)) (exp (variable 3.0 b)))");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      {
+        // exp transformation
+        var actualTree = simplifier.Simplify(importer.Import("(exp (- (variable 2.0 a) (variable 3.0 b)))"));
+        var expectedTree = importer.Import("(* (exp (variable 2.0 a)) (exp (variable -3.0 b)))");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      #endregion
+      #region power rules
+      {
+        // cancellation
+        var actualTree = simplifier.Simplify(importer.Import("(pow (variable 2.0 a) 0.0)"));
+        var expectedTree = importer.Import("1.0");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      {
+        // fixed point
+        var actualTree = simplifier.Simplify(importer.Import("(pow (variable 2.0 a) 1.0)"));
+        var expectedTree = importer.Import("(variable 2.0 a)");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      {
+        // inversion fixed point
+        var actualTree = simplifier.Simplify(importer.Import("(pow (variable 2.0 a) -1.0)"));
+        var expectedTree = importer.Import("(/ 1.0 (variable 2.0 a))");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      {
+        // inversion 
+        var actualTree = simplifier.Simplify(importer.Import("(pow (variable 2.0 a) -2.0)"));
+        var expectedTree = importer.Import("(/ 1.0 (pow (variable 2.0 a) 2.0))");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      {
+        // constant folding
+        var actualTree = simplifier.Simplify(importer.Import("(pow 3.0 2.0)"));
+        var expectedTree = importer.Import("9.0");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      #endregion
+      #region root rules
+      {
+        // cancellation
+        var actualTree = simplifier.Simplify(importer.Import("(root (variable 2.0 a) 0.0)"));
+        var expectedTree = importer.Import("1.0");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      {
+        // fixed point
+        var actualTree = simplifier.Simplify(importer.Import("(root (variable 2.0 a) 1.0)"));
+        var expectedTree = importer.Import("(variable 2.0 a)");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      {
+        // inversion fixed point
+        var actualTree = simplifier.Simplify(importer.Import("(root (variable 2.0 a) -1.0)"));
+        var expectedTree = importer.Import("(/ 1.0 (variable 2.0 a))");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      {
+        // inversion
+        var actualTree = simplifier.Simplify(importer.Import("(root (variable 2.0 a) -2.0)"));
+        var expectedTree = importer.Import("(/ 1.0 (root (variable 2.0 a) 2.0))");
+        Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
+      }
+      {
+        // constant folding
+        var actualTree = simplifier.Simplify(importer.Import("(root 9.0 2.0)"));
+        var expectedTree = importer.Import("3.0");
         Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
       }