Changeset 2633

Timestamp:

01/18/10 09:28:53 (14 years ago)

Author:

gkronber

Message:

Fixed test-cases for constant expressions and expressions of one argument and fixed a bug in the network transformation operator. #833

Location:

trunk/sources

Files:

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

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

@@ -58 +58 @@
         exprScope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("FunctionTree"), new GeneticProgrammingModel(transformedTree)));
         exprScope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TargetVariable"), new StringData(targetVariableEnumerator.Current)));
+        Debug.Assert(!(transformedTree is VariableFunctionTree) || ((VariableFunctionTree)transformedTree).VariableName != targetVariableEnumerator.Current);
       }
 
@@ -214 +215 @@
     /// <returns></returns>
     private static IFunctionTree TransformExpression(IFunctionTree tree, string targetVariable, IEnumerable<string> parameters) {
-      if (tree.Function is Variable || tree.Function is Constant || tree.Function is Differential) return tree;
+      if (tree.Function is Constant) return tree;
+      if (tree.Function is Variable || tree.Function is Differential) {
+        VariableFunctionTree varTree = (VariableFunctionTree)tree;
+        varTree.Weight = 1.0;
+        if (varTree.VariableName == targetVariable) varTree.VariableName = parameters.First();
+        return varTree;
+      }
       if (tree.Function is Addition || tree.Function is Subtraction ||
           tree.Function is Multiplication || tree.Function is Division ||

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

@@ -235 +235 @@
       {
         // expression with one parameter
-        IFunctionTree tree = importer.Import(@"(f1-* (variable 1.0 a 0) (variable 1.0 d 0))");
+        IFunctionTree tree = importer.Import(@"(f1-* (open-param - 0) (variable 1.0 d 0))");
 
         IEnumerable<IFunctionTree> actualTrees = NetworkToFunctionTransformer_Accessor.Transform(tree, new List<string>() { "a", "b", "c" });
@@ -250 +250 @@
       {
         // expression with one parameter
-        IFunctionTree tree = importer.Import(@"(open-log (variable 1.0 a 0))");
+        IFunctionTree tree = importer.Import(@"(open-log (open-param - 0))");
 
         IEnumerable<IFunctionTree> actualTrees = NetworkToFunctionTransformer_Accessor.Transform(tree, new List<string>() { "a", "b", "c" });
@@ -265 +265 @@
       {
         // expression with flip and one parameter
-        IFunctionTree tree = importer.Import(@"(flip (open-log (variable 1.0 a 0)))");
+        IFunctionTree tree = importer.Import(@"(flip (open-log (open-param - 0)))");
 
         IEnumerable<IFunctionTree> actualTrees = NetworkToFunctionTransformer_Accessor.Transform(tree, new List<string>() { "a", "b", "c" });
@@ -272 +272 @@
         IFunctionTree t1 = importer.Import("(exp (variable 1.0 a 0))");
         IFunctionTree t2 = importer.Import("(exp (variable 1.0 a 0))");
+
+
+        CompareTrees(actualTrees, new List<IFunctionTree>() {
+        t0, t1, t2
+        });
+      }
+
+      {
+        // expression with flip and one parameter
+        IFunctionTree tree = importer.Import(@"(open-param - 0)");
+
+        IEnumerable<IFunctionTree> actualTrees = NetworkToFunctionTransformer_Accessor.Transform(tree, new List<string>() { "a", "b", "c" });
+
+        IFunctionTree t0 = importer.Import("(variable 1.0 b 0)");
+        IFunctionTree t1 = importer.Import("(variable 1.0 a 0)");
+        IFunctionTree t2 = importer.Import("(variable 1.0 a 0)");