Changeset 4106 for trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Tests

Timestamp:

07/26/10 16:18:45 (14 years ago)

Author:

gkronber

Message:

Fixed bugs in SubtreeCrossover, ArgumentCreater and ArgumentDuplicater and updated unit tests for symbolic expression tree operators. #1103

Location:

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Tests

Files:

• Grammars.cs (modified) (2 diffs)
• ProbabilisticTreeCreaterTest.cs (modified) (1 diff)
• Util.cs (modified) (3 diffs)

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Tests/Grammars.cs

@@ -26 +26 @@
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding_3._3.Tests {
   public static class Grammars {
-    private class Addition : Symbol { }
-    private class Subtraction : Symbol { }
-    private class Multiplication : Symbol { }
-    private class Division : Symbol { }
-    private class Terminal : Symbol { }
+    private class Addition : Symbol { public Addition() : base("Addition", "") { } }
+    private class Subtraction : Symbol { public Subtraction() : base("Subtraction", "") { } }
+    private class Multiplication : Symbol { public Multiplication() : base("Multiplication", "") { } }
+    private class Division : Symbol { public Division() : base("Division", "") { } }
+    private class Terminal : Symbol { public Terminal() : base("Terminal", "") { } }
 
     private class SimpleArithmeticGrammar : DefaultSymbolicExpressionGrammar {
@@ -89 +89 @@
       return g;
     }
-
-    public static void HasValidAdfGrammars(SymbolicExpressionTree tree) {
-      //Assert.AreEqual(tree.Root.Grammar.Symbols.Count(), 8);
-      //Assert.AreEqual(tree.Root.GetAllowedSymbols(0).Count(), 1); // only the start symbol is allowed
-      //// we allow 3 ADF branches
-      //Assert.AreEqual(tree.Root.GetAllowedSymbols(1).Count(), 1); // only the defun branch is allowed
-      //Assert.AreEqual(tree.Root.GetAllowedSymbols(2).Count(), 1); // only the defun symbol is allowed
-      //Assert.AreEqual(tree.Root.GetAllowedSymbols(3).Count(), 1); // only the defun symbol is allowed
-      //foreach (var subtree in tree.Root.SubTrees) {
-      //  // check consistency of each sub-tree grammar independently
-      //  var allowedSymbols = subtree.GetAllowedSymbols(0);
-      //  int numberOfAllowedSymbols = allowedSymbols.Count();
-      //  foreach (var parent in allowedSymbols) {
-      //    for (int argIndex = 0; argIndex < subtree.Grammar.GetMaxSubtreeCount(parent); argIndex++) {
-      //      var allowedChildren = from child in subtree.Grammar.Symbols
-      //                            where subtree.Grammar.IsAllowedChild(parent, child, argIndex)
-      //                            select child;
-      //      Assert.AreEqual(numberOfAllowedSymbols, allowedChildren.Count());
-      //    }
-      //  }
-      //}
-    }
-
   }
 }

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Tests/ProbabilisticTreeCreaterTest.cs

@@ -76 +76 @@
       for (int i = 0; i < POPULATION_SIZE; i++) {
         var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_SIZE, MAX_TREE_HEIGHT, 3, 3);
-        Grammars.HasValidAdfGrammars(tree);
         Util.IsValid(tree);
         randomTrees.Add(tree);

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Tests/Util.cs

@@ -26 +26 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding_3._3.Tests {
@@ -114 +115 @@
 
     public static void IsValid(SymbolicExpressionTree tree) {
-      Grammars.HasValidAdfGrammars(tree);
+      foreach (var defunTreeNode in tree.Root.SubTrees.OfType<DefunTreeNode>()) {
+        int arity = defunTreeNode.NumberOfArguments;
+        var invoke = new InvokeFunction(defunTreeNode.FunctionName);
+        foreach (var otherRootNode in tree.Root.SubTrees) {
+          if (otherRootNode.Grammar.ContainsSymbol(invoke)) {
+            Assert.IsTrue(otherRootNode.Grammar.GetMinSubtreeCount(invoke) == arity);
+            Assert.IsTrue(otherRootNode.Grammar.GetMaxSubtreeCount(invoke) == arity);
+          }
+        }
+      }
       //Assert.AreEqual(tree.Root.Symbol, tree.Root.Grammar.StartSymbol);
       //foreach (var subtree in tree.Root.SubTrees)
@@ -122 +132 @@
 
     public static void IsValid(SymbolicExpressionTreeNode treeNode) {
-      //var matchingSymbol = (from symb in treeNode.Grammar.Symbols
-      //                      where symb.Name == treeNode.Symbol.Name
-      //                      select symb).SingleOrDefault();
-      //Assert.IsTrue(treeNode.SubTrees.Count >= treeNode.Grammar.GetMinSubtreeCount(matchingSymbol));
-      //Assert.IsTrue(treeNode.SubTrees.Count <= treeNode.Grammar.GetMaxSubtreeCount(matchingSymbol));
+      var matchingSymbol = (from symb in treeNode.Grammar.Symbols
+                            where symb.Name == treeNode.Symbol.Name
+                            select symb).SingleOrDefault();
+      Assert.IsTrue(treeNode.SubTrees.Count >= treeNode.Grammar.GetMinSubtreeCount(matchingSymbol));
+      Assert.IsTrue(treeNode.SubTrees.Count <= treeNode.Grammar.GetMaxSubtreeCount(matchingSymbol));
       for (int i = 0; i < treeNode.SubTrees.Count; i++) {
         Assert.IsTrue(treeNode.GetAllowedSymbols(i).Select(x => x.Name).Contains(treeNode.SubTrees[i].Symbol.Name));