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

Timestamp:

04/15/10 19:58:42 (15 years ago)

Author:

gkronber

Message:

Fixed bugs in ADF operators and added test classes for ADF operators. #290 (Implement ADFs)

Location:

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

Files:

• . (modified) (1 prop)
• AllArchitectureAlteringOperatorsTest.cs (added)
• ArgumentCreaterTest.cs (modified) (2 diffs)
• ArgumentDeleterTest.cs (modified) (2 diffs)
• ArgumentDuplicaterTest.cs (added)
• Grammars.cs (modified) (2 diffs)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.3.Tests.csproj (modified) (2 diffs)
• ProbabilisticTreeCreaterTest.cs (modified) (3 diffs)
• SubroutineCreaterTest.cs (modified) (3 diffs)
• SubroutineDeleterTest.cs (added)
• SubroutineDuplicaterTest.cs (added)
• SubtreeCrossoverTest.cs (modified) (5 diffs)
• Util.cs (modified) (3 diffs)

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

@@ -1 +1 @@
 bin
 obj
+*.user

@@ -1 +1 @@
 bin
 obj
+*.user

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

@@ -1 @@
-using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
 using System.Text;
 using System.Collections.Generic;
@@ -34 +55 @@
       var trees = new List<SymbolicExpressionTree>();
       var grammar = Grammars.CreateArithmeticAndAdfGrammar();
-      var random = new MersenneTwister();
+      var random = new MersenneTwister(31415);
+      int failedEvents = 0;
       for (int i = 0; i < POPULATION_SIZE; i++) {
         var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_SIZE, MAX_TREE_HEIGHT, 3, 3);
-        ArgumentCreater.CreateNewArgument(random, tree, grammar, MAX_TREE_SIZE, MAX_TREE_HEIGHT, 3, 3);
-        Assert.IsTrue(tree.IsValidExpression());
+        if (!ArgumentCreater.CreateNewArgument(random, tree, grammar, MAX_TREE_SIZE, MAX_TREE_HEIGHT, 3, 3))
+          failedEvents++;
+        Util.IsValid(tree);
         trees.Add(tree);
       }
       Assert.Inconclusive("ArgumentCreator: " + Environment.NewLine +
-        Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
+        "Failed events: " + failedEvents / (double)POPULATION_SIZE * 100 + " %" + Environment.NewLine +
+        Util.GetSizeDistributionString(trees, 200, 20) + Environment.NewLine +
         Util.GetFunctionDistributionString(trees) + Environment.NewLine +
         Util.GetNumberOfSubTreesDistributionString(trees) + Environment.NewLine +

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

@@ -1 @@
-using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
 using System.Text;
 using System.Collections.Generic;
@@ -34 +55 @@
       var trees = new List<SymbolicExpressionTree>();
       var grammar = Grammars.CreateArithmeticAndAdfGrammar();
-      var random = new MersenneTwister();
+      var random = new MersenneTwister(31415);
+      int failedEvents = 0;
       for (int i = 0; i < POPULATION_SIZE; i++) {
         var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_SIZE, MAX_TREE_HEIGHT, 3, 3);
-        ArgumentDeleter.DeleteArgument(random, tree, grammar, MAX_TREE_SIZE, MAX_TREE_HEIGHT, 3, 3);
-        Assert.IsTrue(tree.IsValidExpression());
+        if (!ArgumentDeleter.DeleteArgument(random, tree, grammar, MAX_TREE_SIZE, MAX_TREE_HEIGHT, 3, 3))
+          failedEvents++;
+        Util.IsValid(tree);
         trees.Add(tree);
       }
       Assert.Inconclusive("ArgumentDeleter: " + Environment.NewLine +
+        "Failed events: " + failedEvents / (double)POPULATION_SIZE * 100 + " %" + Environment.NewLine +
         Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
         Util.GetFunctionDistributionString(trees) + Environment.NewLine +

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

@@ -1 @@
-using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
 using System.Text;
 using System.Collections.Generic;
@@ -74 +95 @@
       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/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.3.Tests.csproj

@@ -41 +41 @@
     <Compile Include="ArgumentCreaterTest.cs" />
     <Compile Include="ArgumentDeleterTest.cs" />
+    <Compile Include="ArgumentDuplicaterTest.cs" />
+    <Compile Include="AllArchitectureAlteringOperatorsTest.cs" />
+    <Compile Include="SubroutineDeleterTest.cs" />
+    <Compile Include="SubroutineDuplicaterTest.cs" />
     <Compile Include="Grammars.cs" />
+    <Compile Include="SubroutineCreaterTest.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="SubtreeCrossoverTest.cs">
       <SubType>Code</SubType>
@@ -50 +57 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
       <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
       <Name>HeuristicLab.Core-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
+      <Project>{BBAB9DF5-5EF3-4BA8-ADE9-B36E82114937}</Project>
+      <Name>HeuristicLab.Data-3.3</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\..\HeuristicLab.Operators\3.3\HeuristicLab.Operators-3.3.csproj">

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

@@ -1 @@
-using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
 using System.Text;
 using System.Collections.Generic;
@@ -38 +59 @@
       }
 
-      foreach (var tree in randomTrees)
-        Assert.IsTrue(tree.IsValidExpression());
+      foreach (var tree in randomTrees) {
+        Util.IsValid(tree);
+      }
       Assert.Inconclusive("ProbabilisticTreeCreator: " + Environment.NewLine +
         Util.GetSizeDistributionString(randomTrees, 105, 5) + Environment.NewLine +
@@ -55 +77 @@
       var random = new MersenneTwister();
       for (int i = 0; i < POPULATION_SIZE; i++) {
-        randomTrees.Add(ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_SIZE, MAX_TREE_HEIGHT, 3, 3));
+        var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_SIZE, MAX_TREE_HEIGHT, 3, 3);
+        Grammars.HasValidAdfGrammars(tree);
+        Util.IsValid(tree);
+        randomTrees.Add(tree);
       }
-      foreach (var tree in randomTrees)
-        Assert.IsTrue(tree.IsValidExpression());
       Assert.Inconclusive("ProbabilisticTreeCreator: " + Environment.NewLine +
         Util.GetSizeDistributionString(randomTrees, 105, 5) + Environment.NewLine +

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

@@ -1 @@
-using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
 using System.Text;
 using System.Collections.Generic;
@@ -8 +29 @@
 using System.Diagnostics;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.ArchitectureAlteringOperators;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.GeneralSymbols;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding_3._3.Tests {
   [TestClass]
   public class SubroutineCreaterTest {
-    private static ISymbolicExpressionGrammar grammar;
-    private static List<SymbolicExpressionTree> subroutineTrees;
-    private static int failedEvents;
-
+    private const int POPULATION_SIZE = 1000;
+    private const int MAX_TREE_SIZE = 100;
+    private const int MAX_TREE_HEIGHT = 10;
     private TestContext testContextInstance;
 
@@ -32 +51 @@
     }
 
-    [ClassInitialize()]
-    public static void SubroutineCreaterTestInitialize(TestContext testContext) {
-      var randomTrees = new List<SymbolicExpressionTree>();
-      subroutineTrees = new List<SymbolicExpressionTree>();
-      int populationSize = 1000;
-      failedEvents = 0;
-      grammar = Grammars.CreateArithmeticAndAdfGrammar();
-      var random = new MersenneTwister();
-      for (int i = 0; i < populationSize; i++) {
-        var randTree = ProbabilisticTreeCreator.Create(random, grammar, 100, 10);
-        // PTC create is tested separately
-        randomTrees.Add(randTree);
+    [TestMethod()]
+    public void SubroutineCreaterDistributionsTest() {
+      var trees = new List<SymbolicExpressionTree>();
+      var grammar = Grammars.CreateArithmeticAndAdfGrammar();
+      var random = new MersenneTwister(31415);
+      int failedEvents = 0;
+      for (int i = 0; i < POPULATION_SIZE; i++) {
+        var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_SIZE, MAX_TREE_HEIGHT, 3, 3);
+        if (!SubroutineCreater.CreateSubroutine(random, tree, grammar, MAX_TREE_SIZE, MAX_TREE_HEIGHT, 3, 3))
+          failedEvents++;
+        Util.IsValid(tree);
+        trees.Add(tree);
       }
-      var newPopulation = new List<SymbolicExpressionTree>();
-      for (int i = 0; i < populationSize; i++) {
-        var par0 = (SymbolicExpressionTree)randomTrees[random.Next(populationSize)].Clone();
-        bool success = SubroutineCreater.CreateSubroutine(random, par0, grammar, 100, 10, 3, 3);
-        if (!success) failedEvents++;
-        subroutineTrees.Add(par0);
-      }
-    }
-
-
-    [TestMethod()]
-    public void SubroutineCreaterCreateTest() {
-      foreach (var tree in subroutineTrees)
-        Assert.IsTrue(grammar.IsValidExpression(tree));
-    }
-
-    [TestMethod()]
-    public void SubroutineCreaterSizeDistributionTest() {
-      Assert.Inconclusive("SubroutineCreater: " + Util.GetSizeDistributionString(subroutineTrees, 105, 5));
-    }
-
-    [TestMethod()]
-    public void SubroutineCreaterFunctionDistributionTest() {
-      Assert.Inconclusive("SubroutineCreater: " + Util.GetFunctionDistributionString(subroutineTrees));
-    }
-
-    [TestMethod()]
-    public void SubroutineCreaterNumberOfSubTreesDistributionTest() {
-      Assert.Inconclusive("SubroutineCreater: " + Util.GetNumberOfSubTreesDistributionString(subroutineTrees));
-    }
-
-
-    [TestMethod()]
-    public void SubroutineCreaterTerminalDistributionTest() {
-      Assert.Inconclusive("SubroutineCreater: " + Util.GetTerminalDistributionString(subroutineTrees));
+      Assert.Inconclusive("SubroutineCreator: " + Environment.NewLine +
+        "Failed events: " + failedEvents / (double)POPULATION_SIZE * 100 + " %" + Environment.NewLine +
+        Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
+        Util.GetFunctionDistributionString(trees) + Environment.NewLine +
+        Util.GetNumberOfSubTreesDistributionString(trees) + Environment.NewLine +
+        Util.GetTerminalDistributionString(trees) + Environment.NewLine
+        );
     }
   }

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

@@ -1 @@
-using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
 using System.Text;
 using System.Collections.Generic;
@@ -11 +32 @@
   [TestClass]
   public class SubtreeCrossoverTest {
-    private static ISymbolicExpressionGrammar grammar;
-    private static List<SymbolicExpressionTree> crossoverTrees;
-    private static double msPerCrossoverEvent;
-
+    private const int POPULATION_SIZE = 1000;
     private TestContext testContextInstance;
 
@@ -30 +48 @@
     }
 
-    [ClassInitialize()]
-    public static void SubtreeCrossoverTestInitialize(TestContext testContext) {
-      crossoverTrees = new List<SymbolicExpressionTree>();
-      int populationSize = 1000;
+    [TestMethod()]
+    public void SubtreeCrossoverDistributionsTest() {
       int generations = 5;
+      var trees = new List<SymbolicExpressionTree>();
+      var grammar = Grammars.CreateArithmeticAndAdfGrammar();
+      var random = new MersenneTwister();
       int failedEvents = 0;
-      grammar = Grammars.CreateArithmeticAndAdfGrammar();
-      var random = new MersenneTwister();
-      for (int i = 0; i < populationSize; i++) {
-        crossoverTrees.Add(ProbabilisticTreeCreator.Create(random, grammar, 100, 10, 3, 3));
+      List<SymbolicExpressionTree> crossoverTrees;
+      double msPerCrossoverEvent;
+
+      for (int i = 0; i < POPULATION_SIZE; i++) {
+        trees.Add(ProbabilisticTreeCreator.Create(random, grammar, 100, 10, 3, 3));
       }
       Stopwatch stopwatch = new Stopwatch();
@@ -45 +65 @@
       for (int gCount = 0; gCount < generations; gCount++) {
         var newPopulation = new List<SymbolicExpressionTree>();
-        for (int i = 0; i < populationSize; i++) {
-          var par0 = (SymbolicExpressionTree)crossoverTrees[random.Next(populationSize)].Clone();
-          var par1 = (SymbolicExpressionTree)crossoverTrees[random.Next(populationSize)].Clone();
+        for (int i = 0; i < POPULATION_SIZE; i++) {
+          var par0 = (SymbolicExpressionTree)trees.SelectRandom(random).Clone();
+          var par1 = (SymbolicExpressionTree)trees.SelectRandom(random).Clone();
           bool success;
           newPopulation.Add(SubtreeCrossover.Cross(random, par0, par1, 0.9, 100, 10, out success));
@@ -55 +75 @@
       }
       stopwatch.Stop();
-      foreach (var tree in crossoverTrees)
-        Assert.IsTrue(tree.IsValidExpression());
-      msPerCrossoverEvent = stopwatch.ElapsedMilliseconds / (double)populationSize / (double)generations;      
-    }
+      foreach (var tree in trees)
+        Util.IsValid(tree);
 
+      msPerCrossoverEvent = stopwatch.ElapsedMilliseconds / (double)POPULATION_SIZE / (double)generations;
 
-
-    [TestMethod()]
-    public void SubtreeCrossoverSpeed() {
-
-      Assert.Inconclusive(msPerCrossoverEvent + " ms per crossover event (~" +
-        Math.Round(1000.0 / (msPerCrossoverEvent)) + "crossovers / s)");
-    }
-
-    [TestMethod()]
-    public void SubtreeCrossoverSizeDistributions() {
-      Assert.Inconclusive("SubtreeCrossover: " + Util.GetSizeDistributionString(crossoverTrees, 105, 5));
-    }
-
-    [TestMethod()]
-    public void SubtreeCrossoverFunctionDistributionTest() {
-      Assert.Inconclusive("SubtreeCrossover: " + Util.GetFunctionDistributionString(crossoverTrees));
-    }
-
-    [TestMethod()]
-    public void SubtreeCrossoverNumberOfSubTreesDistributionTest() {
-      Assert.Inconclusive("SubtreeCrossover: " + Util.GetNumberOfSubTreesDistributionString(crossoverTrees));
-    }
-
-
-    [TestMethod()]
-    public void SubtreeCrossoverTerminalDistributionTest() {
-      Assert.Inconclusive("SubtreeCrossover: " + Util.GetTerminalDistributionString(crossoverTrees));
+      Assert.Inconclusive("SubtreeCrossover: " + Environment.NewLine +
+        "Failed events: " + failedEvents / (double)POPULATION_SIZE * 100 + " %" + Environment.NewLine +
+        msPerCrossoverEvent + " ms per crossover event (~" + Math.Round(1000.0 / (msPerCrossoverEvent)) + "crossovers / s)" + Environment.NewLine +
+        Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
+        Util.GetFunctionDistributionString(trees) + Environment.NewLine +
+        Util.GetNumberOfSubTreesDistributionString(trees) + Environment.NewLine +
+        Util.GetTerminalDistributionString(trees) + Environment.NewLine
+        );
     }
   }

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

@@ -1 @@
-using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
 using System.Text;
 using System.Collections.Generic;
@@ -13 +34 @@
       int[] histogram = new int[maxTreeSize / binSize];
       for (int i = 0; i < trees.Count; i++) {
-        histogram[trees[i].Size / binSize]++;
+        int binIndex = Math.Min(histogram.Length - 1, trees[i].Size / binSize);
+        histogram[binIndex]++;
       }
       StringBuilder strBuilder = new StringBuilder();
-      for (int i = 0; i < histogram.Length; i++) {
+      for (int i = 0; i < histogram.Length - 1; i++) {
         strBuilder.Append(Environment.NewLine);
         strBuilder.Append("< "); strBuilder.Append((i + 1) * binSize);
         strBuilder.Append(": "); strBuilder.AppendFormat("{0:#0.00%}", histogram[i] / (double)trees.Count);
       }
+      strBuilder.Append(Environment.NewLine);
+      strBuilder.Append(">= "); strBuilder.Append(histogram.Length * binSize);
+      strBuilder.Append(": "); strBuilder.AppendFormat("{0:#0.00%}", histogram[histogram.Length - 1] / (double)trees.Count);
+
       return "Size distribution: " + strBuilder;
     }
@@ -88 +114 @@
       return "Terminal distribution: " + strBuilder;
     }
+
+    public static void IsValid(SymbolicExpressionTree tree) {
+      Grammars.HasValidAdfGrammars(tree);
+      Assert.AreEqual(tree.Root.Symbol, tree.Root.Grammar.StartSymbol);
+      foreach (var subtree in tree.Root.SubTrees)
+        Assert.AreNotSame(subtree.Grammar, tree.Root.Grammar);
+      IsValid(tree.Root);
+    }
+
+    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));
+      for (int i = 0; i < treeNode.SubTrees.Count; i++) {
+        Assert.IsTrue(treeNode.GetAllowedSymbols(i).Select(x => x.Name).Contains(treeNode.SubTrees[i].Symbol.Name));
+        IsValid(treeNode.SubTrees[i]);
+      }
+    }
   }
 }

@@ -1 +1 @@
 bin
 obj
+*.user