Changeset 3338 for trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Tests/SubroutineCreaterTest.cs

Timestamp:

04/13/10 20:44:31 (14 years ago)

Author:

gkronber

Message:

Fixed bugs related to dynamic symbol constraints with ADFs. #290 (Implement ADFs)

File:

• trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Tests/SubroutineCreaterTest.cs (modified) (5 diffs)

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

@@ -13 +13 @@
   [TestClass]
   public class SubroutineCreaterTest {
-    public SubroutineCreaterTest() {
-    }
+    private static ISymbolicExpressionGrammar grammar;
+    private static List<SymbolicExpressionTree> subroutineTrees;
+    private static int failedEvents;
 
     private TestContext testContextInstance;
@@ -36 +37 @@
       subroutineTrees = new List<SymbolicExpressionTree>();
       int populationSize = 1000;
-      var grammar = new TestGrammar();
+      failedEvents = 0;
+      grammar = Grammars.CreateArithmeticAndAdfGrammar();
       var random = new MersenneTwister();
       for (int i = 0; i < populationSize; i++) {
         var randTree = ProbabilisticTreeCreator.Create(random, grammar, 100, 10);
-        Assert.IsTrue(grammar.IsValidExpression(randTree));
+        // PTC create is tested separately
         randomTrees.Add(randTree);
       }
@@ -47 +49 @@
         var par0 = (SymbolicExpressionTree)randomTrees[random.Next(populationSize)].Clone();
         bool success = SubroutineCreater.CreateSubroutine(random, par0, grammar, 100, 10, 3, 3);
-        Assert.IsTrue(grammar.IsValidExpression(par0));
+        if (!success) failedEvents++;
         subroutineTrees.Add(par0);
       }
@@ -53 +55 @@
 
 
-
-    private static List<SymbolicExpressionTree> subroutineTrees;
-    private static int failedEvents;
-
-    private class Addition : Symbol { }
-    private class Subtraction : Symbol { }
-    private class Multiplication : Symbol { }
-    private class Division : Symbol { }
-    private class Terminal : Symbol { }
-
-    private class TestGrammar : DefaultSymbolicExpressionGrammar {
-      public TestGrammar()
-        : base(0, 3, 0, 3) {
-        Initialize();
-      }
-
-      private void Initialize() {
-        var add = new Addition();
-        var sub = new Subtraction();
-        var mul = new Multiplication();
-        var div = new Division();
-        var terminal = new Terminal();
-
-        var defun = new Defun();
-        var invoke = new InvokeFunction();
-
-        var allSymbols = new List<Symbol>() { add, sub, mul, div, terminal, invoke };
-        var functionSymbols = new List<Symbol>() { add, sub, mul, div };
-        foreach (var symb in allSymbols) {
-          AddAllowedSymbols(StartSymbol, 0, symb);
-          AddAllowedSymbols(defun, 0, symb);
-        }
-        SetMinSubTreeCount(invoke, 0);
-        SetMaxSubTreeCount(invoke, 3);
-        for (int i = 0; i < 3; i++) {
-          allSymbols.ForEach(s => AddAllowedSymbols(invoke, i, s));
-        }
-        SetMinSubTreeCount(terminal, 0);
-        SetMaxSubTreeCount(terminal, 0);
-        int maxSubTrees = 3;
-        foreach (var functionSymbol in functionSymbols) {
-          SetMinSubTreeCount(functionSymbol, 1);
-          SetMaxSubTreeCount(functionSymbol, maxSubTrees);
-          foreach (var childSymbol in allSymbols) {
-            for (int argumentIndex = 0; argumentIndex < maxSubTrees; argumentIndex++) {
-              AddAllowedSymbols(functionSymbol, argumentIndex, childSymbol);
-            }
-          }
-        }
-      }
+    [TestMethod()]
+    public void SubroutineCreaterCreateTest() {
+      foreach (var tree in subroutineTrees)
+        Assert.IsTrue(grammar.IsValidExpression(tree));
     }
 
     [TestMethod()]
     public void SubroutineCreaterSizeDistributionTest() {
-      int[] histogram = new int[105 / 5];
-      for (int i = 0; i < subroutineTrees.Count; i++) {
-        histogram[subroutineTrees[i].Size / 5]++;
-      }
-      StringBuilder strBuilder = new StringBuilder();
-      for (int i = 0; i < histogram.Length; i++) {
-        strBuilder.Append(Environment.NewLine);
-        strBuilder.Append("< "); strBuilder.Append((i + 1) * 5);
-        strBuilder.Append(": "); strBuilder.AppendFormat("{0:#0.00%}", histogram[i] / (double)subroutineTrees.Count);
-      }
-      Assert.Inconclusive("Size distribution of SubroutineCreater: " + strBuilder);
+      Assert.Inconclusive("SubroutineCreater: " + Util.GetSizeDistributionString(subroutineTrees, 105, 5));
     }
 
     [TestMethod()]
     public void SubroutineCreaterFunctionDistributionTest() {
-      Dictionary<Symbol, int> occurances = new Dictionary<Symbol, int>();
-      double n = 0.0;
-      for (int i = 0; i < subroutineTrees.Count; i++) {
-        foreach (var node in subroutineTrees[i].IterateNodesPrefix()) {
-          if (node.SubTrees.Count > 0) {
-            if (!occurances.ContainsKey(node.Symbol))
-              occurances[node.Symbol] = 0;
-            occurances[node.Symbol]++;
-            n++;
-          }
-        }
-      }
-      StringBuilder strBuilder = new StringBuilder();
-      foreach (var function in occurances.Keys) {
-        strBuilder.Append(Environment.NewLine);
-        strBuilder.Append(function.Name); strBuilder.Append(": ");
-        strBuilder.AppendFormat("{0:#0.00%}", occurances[function] / n);
-      }
-      Assert.Inconclusive("Function distribution of SubroutineCreater: " + strBuilder);
+      Assert.Inconclusive("SubroutineCreater: " + Util.GetFunctionDistributionString(subroutineTrees));
     }
 
     [TestMethod()]
     public void SubroutineCreaterNumberOfSubTreesDistributionTest() {
-      Dictionary<int, int> occurances = new Dictionary<int, int>();
-      double n = 0.0;
-      for (int i = 0; i < subroutineTrees.Count; i++) {
-        foreach (var node in subroutineTrees[i].IterateNodesPrefix()) {
-          if (!occurances.ContainsKey(node.SubTrees.Count))
-            occurances[node.SubTrees.Count] = 0;
-          occurances[node.SubTrees.Count]++;
-          n++;
-        }
-      }
-      StringBuilder strBuilder = new StringBuilder();
-      foreach (var arity in occurances.Keys) {
-        strBuilder.Append(Environment.NewLine);
-        strBuilder.Append(arity); strBuilder.Append(": ");
-        strBuilder.AppendFormat("{0:#0.00%}", occurances[arity] / n);
-      }
-      Assert.Inconclusive("Distribution of function arities of SubroutineCreater: " + strBuilder);
+      Assert.Inconclusive("SubroutineCreater: " + Util.GetNumberOfSubTreesDistributionString(subroutineTrees));
     }
 
@@ -167 +79 @@
     [TestMethod()]
     public void SubroutineCreaterTerminalDistributionTest() {
-      Dictionary<Symbol, int> occurances = new Dictionary<Symbol, int>();
-      double n = 0.0;
-      for (int i = 0; i < subroutineTrees.Count; i++) {
-        foreach (var node in subroutineTrees[i].IterateNodesPrefix()) {
-          if (node.SubTrees.Count == 0) {
-            if (!occurances.ContainsKey(node.Symbol))
-              occurances[node.Symbol] = 0;
-            occurances[node.Symbol]++;
-            n++;
-          }
-        }
-      }
-      StringBuilder strBuilder = new StringBuilder();
-      foreach (var function in occurances.Keys) {
-        strBuilder.Append(Environment.NewLine);
-        strBuilder.Append(function.Name); strBuilder.Append(": ");
-        strBuilder.AppendFormat("{0:#0.00%}", occurances[function] / n);
-      }
-      Assert.Inconclusive("Terminal distribution of SubroutineCreater: " + strBuilder);
+      Assert.Inconclusive("SubroutineCreater: " + Util.GetTerminalDistributionString(subroutineTrees));
     }
   }