Changeset 2625 for trunk/sources

Timestamp:

01/13/10 19:31:02 (15 years ago)

Author:

gkronber

Message:

Fixed bugs in network transformation operator. Added test cases. #833.

Location:

trunk/sources

Files:

• HeuristicLab.GP.StructureIdentification.Networks/3.2/NetworkToFunctionTransformer.cs (modified) (3 diffs)
• HeuristicLab.GP.Tests/NetworkToFunctionTransformerTest.cs (modified) (2 diffs)
• HeuristicLab.GP.Tests/Token.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.GP.StructureIdentification.Networks/3.2/NetworkToFunctionTransformer.cs

@@ -94 +94 @@
         return tree;
       } else if (tree.Function is Flip) {
-        return InvertChain(tree.SubTrees[0]);
+        if (tree.SubTrees[0].Function is OpenParameter) return tree.SubTrees[0];
+        else return ApplyFlips(InvertChain(tree.SubTrees[0]));
       } else {
         IFunctionTree tmp = ApplyFlips(tree.SubTrees[0]);
@@ -134 +135 @@
       }
       // append open param at the end
-      invParent.AddSubTree(openParam);
+      invParent.InsertSubTree(0, openParam);
       return root;
     }
@@ -194 +195 @@
     private static IFunctionTree AppendLeft(IFunctionTree tree, IFunctionTree node) {
       IFunctionTree originalTree = tree;
-      while (tree.SubTrees[0].SubTrees.Count > 0) tree = tree.SubTrees[0];
+      while (!IsBottomLeft(tree)) tree = tree.SubTrees[0];
       tree.InsertSubTree(0, node);
       return originalTree;
+    }
+
+    private static bool IsBottomLeft(IFunctionTree tree) {
+      if(tree.SubTrees.Count==0) return true;
+      else if(tree.SubTrees[0].Function is Variable) return true;
+      else if(tree.SubTrees[0].Function is Constant) return true;
+      else return false;
     }
 

trunk/sources/HeuristicLab.GP.Tests/NetworkToFunctionTransformerTest.cs

@@ -162 +162 @@
       });
       }
-
-
+      {
+        IFunctionTree tree = importer.Import("(open-- (open-log (open-log (open-param - 0))) (open-exp (open-exp (open-param - 0))) (f1-* (open-param - 0) 2.0))");
+
+        IEnumerable<IFunctionTree> actualTrees = NetworkToFunctionTransformer_Accessor.Transform(tree, new List<string>() { "a", "b", "c" });
+
+        IFunctionTree t0 = importer.Import(@"(exp (exp (- (exp (exp (variable 1.0 b 0)))
+                                                          (* (variable 1.0 c 0) 2.0)))))");
+        IFunctionTree t1 = importer.Import(@"(log (log (+ (log (log (variable 1.0 a 0)))
+                                                          (* (variable 1.0 c 0) 2.0))))");
+        IFunctionTree t2 = importer.Import(@"(/ (+ (log (log (variable 1.0 a 0)))
+                                                   (exp (exp (variable 1.0 b 0)))) 2.0)");
+
+        CompareTrees(actualTrees, new List<IFunctionTree>() {
+        t0, t1, t2
+      });
+      }
+      {
+        IFunctionTree tree = importer.Import(@"(open-- (flip (open-log (open-param - 0))) 
+                                                       (flip (f1-* (open-param - 0) 2.0)) 
+                                                       (flip (flip (f1-* (open-param - 0) 2.0))))");
+
+        IEnumerable<IFunctionTree> actualTrees = NetworkToFunctionTransformer_Accessor.Transform(tree, new List<string>() { "a", "b", "c" });
+
+        IFunctionTree t0 = importer.Import(@"(log (- (/ (variable 1.0 b 0) 2.0)
+                                                     (* (variable 1.0 c 0) 2.0)))");
+        IFunctionTree t1 = importer.Import(@"(* (+ (exp (variable 1.0 a 0))
+                                                   (* (variable 1.0 c 0) 2.0)) 2.0)");
+        IFunctionTree t2 = importer.Import(@"(/ (+ (exp (variable 1.0 a 0))
+                                                   (/ (variable 1.0 b 0) 2.0)) 2.0)");
+
+        CompareTrees(actualTrees, new List<IFunctionTree>() {
+        t0, t1, t2
+      });
+      }
+      {
+        IFunctionTree tree = importer.Import(@"(cycle (open-+
+                                                         (flip (f1-+ 
+                                                           (flip (f1-- 
+                                                             (flip (f1-/ 
+                                                               (open-param - 0) 4.0)) 3.0)) 2.0))
+                                                         (open-param - 0) 
+                                                         (open-param - 0)))");
+        // -3*4-2 x
+        IEnumerable<IFunctionTree> actualTrees = NetworkToFunctionTransformer_Accessor.Transform(tree, new List<string>() { "a", "b", "c" });
+
+        IFunctionTree t0 = importer.Import("(+ (/ (- (+ (variable 1.0 b 0) (variable 1.0 c 0)) 3.0) 4.0) 2.0)");
+        IFunctionTree t1 = importer.Import("(- (- (* (- (variable 1.0 a 0) 2.0) 4.0) 3.0) (variable 1.0 c 0))");
+        IFunctionTree t2 = importer.Import("(- (- (* (- (variable 1.0 a 0) 2.0) 4.0) 3.0) (variable 1.0 b 0))");
+
+
+        CompareTrees(actualTrees, new List<IFunctionTree>() {
+        t0, t1, t2
+      });
+      }
 
     }
@@ -172 +224 @@
         if (!expectedEnumerator.MoveNext()) Assert.Fail();
         IFunctionTree expectedTree = expectedEnumerator.Current;
-        var e = (from x in FunctionTreeIterator.IteratePostfix(expectedTree)
+        var e = (from x in FunctionTreeIterator.IteratePrefix(expectedTree)
                  select x).GetEnumerator();
-        var a = (from x in FunctionTreeIterator.IteratePostfix(actualTree)
+        var a = (from x in FunctionTreeIterator.IteratePrefix(actualTree)
                  select x).GetEnumerator();
         Assert.AreEqual(expectedTree.GetSize(), actualTree.GetSize());
         while (e.MoveNext() && a.MoveNext()) {
-          Assert.AreEqual(e.Current.GetType(), a.Current.GetType());
+          Assert.AreEqual(e.Current.Function.GetType(), a.Current.Function.GetType());
           if (e.Current.Function is HeuristicLab.GP.StructureIdentification.Variable) {
             var expectedVar = (VariableFunctionTree)e.Current;

trunk/sources/HeuristicLab.GP.Tests/Token.cs

@@ -29 +29 @@
 using HeuristicLab.GP.StructureIdentification;
 using System.Diagnostics;
+using System.Globalization;
 
 namespace HeuristicLab.GP.Test {
@@ -59 +60 @@
       } else if (strToken == ")") {
         t.Symbol = TokenSymbol.RPAR;
-      } else if (double.TryParse(strToken, out temp)) {
+      } else if (double.TryParse(strToken, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out temp)) {
         t.Symbol = TokenSymbol.NUMBER;
-        t.DoubleValue = double.Parse(strToken);
+        t.DoubleValue = double.Parse(strToken, CultureInfo.InvariantCulture.NumberFormat);
       } else {
         t.Symbol = TokenSymbol.SYMB;