Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
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)

Location:
trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Tests
Files:
4 added
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Tests/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.3.Tests.csproj

    r3297 r3338  
    3939  </ItemGroup>
    4040  <ItemGroup>
    41     <Compile Include="SubroutineCreaterTest.cs" />
    42     <Compile Include="SubtreeCrossoverTest.cs" />
     41    <Compile Include="ArgumentCreaterTest.cs" />
     42    <Compile Include="ArgumentDeleterTest.cs" />
     43    <Compile Include="Grammars.cs" />
     44    <Compile Include="SubtreeCrossoverTest.cs">
     45      <SubType>Code</SubType>
     46    </Compile>
     47    <Compile Include="Util.cs" />
    4348    <Compile Include="Properties\AssemblyInfo.cs" />
    4449    <Compile Include="ProbabilisticTreeCreaterTest.cs" />

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

    r3297 r3338  
    1111  [TestClass]
    1212  public class ProbabilisticTreeCreaterTest {
    13     public ProbabilisticTreeCreaterTest() {
    14       int populationSize = 1000;
    15       randomTrees = new List<SymbolicExpressionTree>();
    16       var grammar = new TestGrammar();
    17       var random = new MersenneTwister();
    18       for (int i = 0; i < populationSize; i++) {
    19         randomTrees.Add(ProbabilisticTreeCreator.Create(random, grammar, 100, 10));
    20       }
    21       foreach (var tree in randomTrees)
    22         Assert.IsTrue(grammar.IsValidExpression(tree));
    23     }
    24 
     13    private const int POPULATION_SIZE = 1000;
     14    private const int MAX_TREE_SIZE = 100;
     15    private const int MAX_TREE_HEIGHT = 10;
    2516    private TestContext testContextInstance;
    2617
    … …  
    3829    }
    3930
    40     private List<SymbolicExpressionTree> randomTrees;
    41 
    42 
    43     private class Addition : Symbol { }
    44     private class Subtraction : Symbol { }
    45     private class Multiplication : Symbol { }
    46     private class Division : Symbol { }
    47     private class Terminal : Symbol { }
    48 
    49     private class TestGrammar : DefaultSymbolicExpressionGrammar {
    50       public TestGrammar()
    51         : base(0, 0, 0, 0) {
    52         Initialize();
     31    [TestMethod()]
     32    public void ProbabilisticTreeCreaterDistributionsTest() {
     33      var randomTrees = new List<SymbolicExpressionTree>();
     34      var grammar = Grammars.CreateSimpleArithmeticGrammar();
     35      var random = new MersenneTwister();
     36      for (int i = 0; i < POPULATION_SIZE; i++) {
     37        randomTrees.Add(ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_SIZE, MAX_TREE_HEIGHT, 0, 0));
    5338      }
    5439
    55       private void Initialize() {
    56         var add = new Addition();
    57         var sub = new Subtraction();
    58         var mul = new Multiplication();
    59         var div = new Division();
    60         var terminal = new Terminal();
    61 
    62         var allSymbols = new List<Symbol>() { add, sub, mul, div, terminal };
    63         var functionSymbols = new List<Symbol>() { add, sub, mul, div };
    64         allSymbols.ForEach(s => AddAllowedSymbols(StartSymbol, 0, s));
    65 
    66         SetMinSubTreeCount(terminal, 0);
    67         SetMaxSubTreeCount(terminal, 0);
    68         int maxSubTrees = 3;
    69         foreach (var functionSymbol in functionSymbols) {
    70           SetMinSubTreeCount(functionSymbol, 1);
    71           SetMaxSubTreeCount(functionSymbol, maxSubTrees);
    72           foreach (var childSymbol in allSymbols) {
    73             for (int argumentIndex = 0; argumentIndex < maxSubTrees; argumentIndex++) {
    74               AddAllowedSymbols(functionSymbol, argumentIndex, childSymbol);
    75             }
    76           }
    77         }
    78       }
    79     }
    80 
    81     [TestMethod()]
    82     public void ProbabilisticTreeCreaterSizeDistributionTest() {
    83       int[] histogram = new int[105 / 5];
    84       for (int i = 0; i < randomTrees.Count; i++) {
    85         histogram[randomTrees[i].Size / 5]++;
    86       }
    87       StringBuilder strBuilder = new StringBuilder();
    88       for (int i = 0; i < histogram.Length; i++) {
    89         strBuilder.Append(Environment.NewLine);
    90         strBuilder.Append("< "); strBuilder.Append((i + 1) * 5);
    91         strBuilder.Append(": "); strBuilder.AppendFormat("{0:#0.00%}", histogram[i] / (double)randomTrees.Count);
    92       }
    93       Assert.Inconclusive("Size distribution of ProbabilisticTreeCreator: " + strBuilder);
    94     }
    95 
    96     [TestMethod()]
    97     public void ProbabilisticTreeCreaterFunctionDistributionTest() {
    98       Dictionary<Symbol, int> occurances = new Dictionary<Symbol, int>();
    99       double n = 0.0;
    100       for (int i = 0; i < randomTrees.Count; i++) {
    101         foreach (var node in randomTrees[i].IterateNodesPrefix()) {
    102           if (node.SubTrees.Count > 0) {
    103             if (!occurances.ContainsKey(node.Symbol))
    104               occurances[node.Symbol] = 0;
    105             occurances[node.Symbol]++;
    106             n++;
    107           }
    108         }
    109       }
    110       StringBuilder strBuilder = new StringBuilder();
    111       foreach (var function in occurances.Keys) {
    112         strBuilder.Append(Environment.NewLine);
    113         strBuilder.Append(function.Name); strBuilder.Append(": ");
    114         strBuilder.AppendFormat("{0:#0.00%}", occurances[function] / n);
    115       }
    116       Assert.Inconclusive("Function distribution of ProbabilisticTreeCreator: " + strBuilder);
    117     }
    118 
    119     [TestMethod()]
    120     public void ProbabilisticTreeCreaterNumberOfSubTreesDistributionTest() {
    121       Dictionary<int, int> occurances = new Dictionary<int, int>();
    122       double n = 0.0;
    123       for (int i = 0; i < randomTrees.Count; i++) {
    124         foreach (var node in randomTrees[i].IterateNodesPrefix()) {
    125           if (!occurances.ContainsKey(node.SubTrees.Count))
    126             occurances[node.SubTrees.Count] = 0;
    127           occurances[node.SubTrees.Count]++;
    128           n++;
    129         }
    130       }
    131       StringBuilder strBuilder = new StringBuilder();
    132       foreach (var arity in occurances.Keys) {
    133         strBuilder.Append(Environment.NewLine);
    134         strBuilder.Append(arity); strBuilder.Append(": ");
    135         strBuilder.AppendFormat("{0:#0.00%}", occurances[arity] / n);
    136       }
    137       Assert.Inconclusive("Distribution of function arities of ProbabilisticTreeCreator: " + strBuilder);
     40      foreach (var tree in randomTrees)
     41        Assert.IsTrue(tree.IsValidExpression());
     42      Assert.Inconclusive("ProbabilisticTreeCreator: " + Environment.NewLine +
     43        Util.GetSizeDistributionString(randomTrees, 105, 5) + Environment.NewLine +
     44        Util.GetFunctionDistributionString(randomTrees) + Environment.NewLine +
     45        Util.GetNumberOfSubTreesDistributionString(randomTrees) + Environment.NewLine +
     46        Util.GetTerminalDistributionString(randomTrees) + Environment.NewLine
     47        );
    13848    }
    13949
    14050
    14151    [TestMethod()]
    142     public void ProbabilisticTreeCreaterTerminalDistributionTest() {
    143       Dictionary<Symbol, int> occurances = new Dictionary<Symbol, int>();
    144       double n = 0.0;
    145       for (int i = 0; i < randomTrees.Count; i++) {
    146         foreach (var node in randomTrees[i].IterateNodesPrefix()) {
    147           if (node.SubTrees.Count == 0) {
    148             if (!occurances.ContainsKey(node.Symbol))
    149               occurances[node.Symbol] = 0;
    150             occurances[node.Symbol]++;
    151             n++;
    152           }
    153         }
     52    public void ProbabilisticTreeCreaterWithAdfDistributionsTest() {
     53      var randomTrees = new List<SymbolicExpressionTree>();
     54      var grammar = Grammars.CreateArithmeticAndAdfGrammar();
     55      var random = new MersenneTwister();
     56      for (int i = 0; i < POPULATION_SIZE; i++) {
     57        randomTrees.Add(ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_SIZE, MAX_TREE_HEIGHT, 3, 3));
    15458      }
    155       StringBuilder strBuilder = new StringBuilder();
    156       foreach (var function in occurances.Keys) {
    157         strBuilder.Append(Environment.NewLine);
    158         strBuilder.Append(function.Name); strBuilder.Append(": ");
    159         strBuilder.AppendFormat("{0:#0.00%}", occurances[function] / n);
    160       }
    161       Assert.Inconclusive("Terminal distribution of ProbabilisticTreeCreator: " + strBuilder);
     59      foreach (var tree in randomTrees)
     60        Assert.IsTrue(tree.IsValidExpression());
     61      Assert.Inconclusive("ProbabilisticTreeCreator: " + Environment.NewLine +
     62        Util.GetSizeDistributionString(randomTrees, 105, 5) + Environment.NewLine +
     63        Util.GetFunctionDistributionString(randomTrees) + Environment.NewLine +
     64        Util.GetNumberOfSubTreesDistributionString(randomTrees) + Environment.NewLine +
     65        Util.GetTerminalDistributionString(randomTrees) + Environment.NewLine
     66        );
    16267    }
    16368  }

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

    r3307 r3338  
    1313  [TestClass]
    1414  public class SubroutineCreaterTest {
    15     public SubroutineCreaterTest() {
    16     }
     15    private static ISymbolicExpressionGrammar grammar;
     16    private static List<SymbolicExpressionTree> subroutineTrees;
     17    private static int failedEvents;
    1718
    1819    private TestContext testContextInstance;
    … …  
    3637      subroutineTrees = new List<SymbolicExpressionTree>();
    3738      int populationSize = 1000;
    38       var grammar = new TestGrammar();
     39      failedEvents = 0;
     40      grammar = Grammars.CreateArithmeticAndAdfGrammar();
    3941      var random = new MersenneTwister();
    4042      for (int i = 0; i < populationSize; i++) {
    4143        var randTree = ProbabilisticTreeCreator.Create(random, grammar, 100, 10);
    42         Assert.IsTrue(grammar.IsValidExpression(randTree));
     44        // PTC create is tested separately
    4345        randomTrees.Add(randTree);
    4446      }
    … …  
    4749        var par0 = (SymbolicExpressionTree)randomTrees[random.Next(populationSize)].Clone();
    4850        bool success = SubroutineCreater.CreateSubroutine(random, par0, grammar, 100, 10, 3, 3);
    49         Assert.IsTrue(grammar.IsValidExpression(par0));
     51        if (!success) failedEvents++;
    5052        subroutineTrees.Add(par0);
    5153      }
    … …  
    5355
    5456
    55 
    56     private static List<SymbolicExpressionTree> subroutineTrees;
    57     private static int failedEvents;
    58 
    59     private class Addition : Symbol { }
    60     private class Subtraction : Symbol { }
    61     private class Multiplication : Symbol { }
    62     private class Division : Symbol { }
    63     private class Terminal : Symbol { }
    64 
    65     private class TestGrammar : DefaultSymbolicExpressionGrammar {
    66       public TestGrammar()
    67         : base(0, 3, 0, 3) {
    68         Initialize();
    69       }
    70 
    71       private void Initialize() {
    72         var add = new Addition();
    73         var sub = new Subtraction();
    74         var mul = new Multiplication();
    75         var div = new Division();
    76         var terminal = new Terminal();
    77 
    78         var defun = new Defun();
    79         var invoke = new InvokeFunction();
    80 
    81         var allSymbols = new List<Symbol>() { add, sub, mul, div, terminal, invoke };
    82         var functionSymbols = new List<Symbol>() { add, sub, mul, div };
    83         foreach (var symb in allSymbols) {
    84           AddAllowedSymbols(StartSymbol, 0, symb);
    85           AddAllowedSymbols(defun, 0, symb);
    86         }
    87         SetMinSubTreeCount(invoke, 0);
    88         SetMaxSubTreeCount(invoke, 3);
    89         for (int i = 0; i < 3; i++) {
    90           allSymbols.ForEach(s => AddAllowedSymbols(invoke, i, s));
    91         }
    92         SetMinSubTreeCount(terminal, 0);
    93         SetMaxSubTreeCount(terminal, 0);
    94         int maxSubTrees = 3;
    95         foreach (var functionSymbol in functionSymbols) {
    96           SetMinSubTreeCount(functionSymbol, 1);
    97           SetMaxSubTreeCount(functionSymbol, maxSubTrees);
    98           foreach (var childSymbol in allSymbols) {
    99             for (int argumentIndex = 0; argumentIndex < maxSubTrees; argumentIndex++) {
    100               AddAllowedSymbols(functionSymbol, argumentIndex, childSymbol);
    101             }
    102           }
    103         }
    104       }
     57    [TestMethod()]
     58    public void SubroutineCreaterCreateTest() {
     59      foreach (var tree in subroutineTrees)
     60        Assert.IsTrue(grammar.IsValidExpression(tree));
    10561    }
    10662
    10763    [TestMethod()]
    10864    public void SubroutineCreaterSizeDistributionTest() {
    109       int[] histogram = new int[105 / 5];
    110       for (int i = 0; i < subroutineTrees.Count; i++) {
    111         histogram[subroutineTrees[i].Size / 5]++;
    112       }
    113       StringBuilder strBuilder = new StringBuilder();
    114       for (int i = 0; i < histogram.Length; i++) {
    115         strBuilder.Append(Environment.NewLine);
    116         strBuilder.Append("< "); strBuilder.Append((i + 1) * 5);
    117         strBuilder.Append(": "); strBuilder.AppendFormat("{0:#0.00%}", histogram[i] / (double)subroutineTrees.Count);
    118       }
    119       Assert.Inconclusive("Size distribution of SubroutineCreater: " + strBuilder);
     65      Assert.Inconclusive("SubroutineCreater: " + Util.GetSizeDistributionString(subroutineTrees, 105, 5));
    12066    }
    12167
    12268    [TestMethod()]
    12369    public void SubroutineCreaterFunctionDistributionTest() {
    124       Dictionary<Symbol, int> occurances = new Dictionary<Symbol, int>();
    125       double n = 0.0;
    126       for (int i = 0; i < subroutineTrees.Count; i++) {
    127         foreach (var node in subroutineTrees[i].IterateNodesPrefix()) {
    128           if (node.SubTrees.Count > 0) {
    129             if (!occurances.ContainsKey(node.Symbol))
    130               occurances[node.Symbol] = 0;
    131             occurances[node.Symbol]++;
    132             n++;
    133           }
    134         }
    135       }
    136       StringBuilder strBuilder = new StringBuilder();
    137       foreach (var function in occurances.Keys) {
    138         strBuilder.Append(Environment.NewLine);
    139         strBuilder.Append(function.Name); strBuilder.Append(": ");
    140         strBuilder.AppendFormat("{0:#0.00%}", occurances[function] / n);
    141       }
    142       Assert.Inconclusive("Function distribution of SubroutineCreater: " + strBuilder);
     70      Assert.Inconclusive("SubroutineCreater: " + Util.GetFunctionDistributionString(subroutineTrees));
    14371    }
    14472
    14573    [TestMethod()]
    14674    public void SubroutineCreaterNumberOfSubTreesDistributionTest() {
    147       Dictionary<int, int> occurances = new Dictionary<int, int>();
    148       double n = 0.0;
    149       for (int i = 0; i < subroutineTrees.Count; i++) {
    150         foreach (var node in subroutineTrees[i].IterateNodesPrefix()) {
    151           if (!occurances.ContainsKey(node.SubTrees.Count))
    152             occurances[node.SubTrees.Count] = 0;
    153           occurances[node.SubTrees.Count]++;
    154           n++;
    155         }
    156       }
    157       StringBuilder strBuilder = new StringBuilder();
    158       foreach (var arity in occurances.Keys) {
    159         strBuilder.Append(Environment.NewLine);
    160         strBuilder.Append(arity); strBuilder.Append(": ");
    161         strBuilder.AppendFormat("{0:#0.00%}", occurances[arity] / n);
    162       }
    163       Assert.Inconclusive("Distribution of function arities of SubroutineCreater: " + strBuilder);
     75      Assert.Inconclusive("SubroutineCreater: " + Util.GetNumberOfSubTreesDistributionString(subroutineTrees));
    16476    }
    16577
    … …  
    16779    [TestMethod()]
    16880    public void SubroutineCreaterTerminalDistributionTest() {
    169       Dictionary<Symbol, int> occurances = new Dictionary<Symbol, int>();
    170       double n = 0.0;
    171       for (int i = 0; i < subroutineTrees.Count; i++) {
    172         foreach (var node in subroutineTrees[i].IterateNodesPrefix()) {
    173           if (node.SubTrees.Count == 0) {
    174             if (!occurances.ContainsKey(node.Symbol))
    175               occurances[node.Symbol] = 0;
    176             occurances[node.Symbol]++;
    177             n++;
    178           }
    179         }
    180       }
    181       StringBuilder strBuilder = new StringBuilder();
    182       foreach (var function in occurances.Keys) {
    183         strBuilder.Append(Environment.NewLine);
    184         strBuilder.Append(function.Name); strBuilder.Append(": ");
    185         strBuilder.AppendFormat("{0:#0.00%}", occurances[function] / n);
    186       }
    187       Assert.Inconclusive("Terminal distribution of SubroutineCreater: " + strBuilder);
     81      Assert.Inconclusive("SubroutineCreater: " + Util.GetTerminalDistributionString(subroutineTrees));
    18882    }
    18983  }

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

    r3297 r3338  
    1111  [TestClass]
    1212  public class SubtreeCrossoverTest {
    13     public SubtreeCrossoverTest() {
    14     }
     13    private static ISymbolicExpressionGrammar grammar;
     14    private static List<SymbolicExpressionTree> crossoverTrees;
     15    private static double msPerCrossoverEvent;
    1516
    1617    private TestContext testContextInstance;
    … …  
    3435      int populationSize = 1000;
    3536      int generations = 5;
    36       var grammar = new TestGrammar();
     37      int failedEvents = 0;
     38      grammar = Grammars.CreateArithmeticAndAdfGrammar();
    3739      var random = new MersenneTwister();
    3840      for (int i = 0; i < populationSize; i++) {
    39         crossoverTrees.Add(ProbabilisticTreeCreator.Create(random, grammar, 100, 10));
     41        crossoverTrees.Add(ProbabilisticTreeCreator.Create(random, grammar, 100, 10, 3, 3));
    4042      }
    4143      Stopwatch stopwatch = new Stopwatch();
    … …  
    4749          var par1 = (SymbolicExpressionTree)crossoverTrees[random.Next(populationSize)].Clone();
    4850          bool success;
    49           newPopulation.Add(SubtreeCrossover.Cross(random, grammar, par0, par1, 0.9, 100, 10, out success));
     51          newPopulation.Add(SubtreeCrossover.Cross(random, par0, par1, 0.9, 100, 10, out success));
     52          if (!success) failedEvents++;
    5053        }
    5154        crossoverTrees = newPopulation;
    … …  
    5356      stopwatch.Stop();
    5457      foreach (var tree in crossoverTrees)
    55         Assert.IsTrue(grammar.IsValidExpression(tree));
    56       msPerCrossoverEvent = stopwatch.ElapsedMilliseconds / (double)populationSize / (double)generations;
     58        Assert.IsTrue(tree.IsValidExpression());
     59      msPerCrossoverEvent = stopwatch.ElapsedMilliseconds / (double)populationSize / (double)generations;     
    5760    }
    5861
    5962
    6063
    61     private static List<SymbolicExpressionTree> crossoverTrees;
    62     private static double msPerCrossoverEvent;
    63 
    64     private class Addition : Symbol { }
    65     private class Subtraction : Symbol { }
    66     private class Multiplication : Symbol { }
    67     private class Division : Symbol { }
    68     private class Terminal : Symbol { }
    69 
    70     private class TestGrammar : DefaultSymbolicExpressionGrammar {
    71       public TestGrammar()
    72         : base(0, 0, 0, 0) {
    73         Initialize();
    74       }
    75 
    76       private void Initialize() {
    77         var add = new Addition();
    78         var sub = new Subtraction();
    79         var mul = new Multiplication();
    80         var div = new Division();
    81         var terminal = new Terminal();
    82 
    83         var allSymbols = new List<Symbol>() { add, sub, mul, div, terminal };
    84         var functionSymbols = new List<Symbol>() { add, sub, mul, div };
    85         allSymbols.ForEach(s => AddAllowedSymbols(StartSymbol, 0, s));
    86 
    87         SetMinSubTreeCount(terminal, 0);
    88         SetMaxSubTreeCount(terminal, 0);
    89         int maxSubTrees = 3;
    90         foreach (var functionSymbol in functionSymbols) {
    91           SetMinSubTreeCount(functionSymbol, 1);
    92           SetMaxSubTreeCount(functionSymbol, maxSubTrees);
    93           foreach (var childSymbol in allSymbols) {
    94             for (int argumentIndex = 0; argumentIndex < maxSubTrees; argumentIndex++) {
    95               AddAllowedSymbols(functionSymbol, argumentIndex, childSymbol);
    96             }
    97           }
    98         }
    99       }
    100     }
    101 
    10264    [TestMethod()]
    10365    public void SubtreeCrossoverSpeed() {
     66
    10467      Assert.Inconclusive(msPerCrossoverEvent + " ms per crossover event (~" +
    10568        Math.Round(1000.0 / (msPerCrossoverEvent)) + "crossovers / s)");
    … …  
    10770
    10871    [TestMethod()]
    109     public void SubtreeCrossoverSizeDistributionTest() {
    110       int[] histogram = new int[105 / 5];
    111       for (int i = 0; i < crossoverTrees.Count; i++) {
    112         histogram[crossoverTrees[i].Size / 5]++;
    113       }
    114       StringBuilder strBuilder = new StringBuilder();
    115       for (int i = 0; i < histogram.Length; i++) {
    116         strBuilder.Append(Environment.NewLine);
    117         strBuilder.Append("< "); strBuilder.Append((i + 1) * 5);
    118         strBuilder.Append(": "); strBuilder.AppendFormat("{0:#0.00%}", histogram[i] / (double)crossoverTrees.Count);
    119       }
    120       Assert.Inconclusive("Size distribution of SubtreeCrossover: " + strBuilder);
     72    public void SubtreeCrossoverSizeDistributions() {
     73      Assert.Inconclusive("SubtreeCrossover: " + Util.GetSizeDistributionString(crossoverTrees, 105, 5));
    12174    }
    12275
    12376    [TestMethod()]
    12477    public void SubtreeCrossoverFunctionDistributionTest() {
    125       Dictionary<Symbol, int> occurances = new Dictionary<Symbol, int>();
    126       double n = 0.0;
    127       for (int i = 0; i < crossoverTrees.Count; i++) {
    128         foreach (var node in crossoverTrees[i].IterateNodesPrefix()) {
    129           if (node.SubTrees.Count > 0) {
    130             if (!occurances.ContainsKey(node.Symbol))
    131               occurances[node.Symbol] = 0;
    132             occurances[node.Symbol]++;
    133             n++;
    134           }
    135         }
    136       }
    137       StringBuilder strBuilder = new StringBuilder();
    138       foreach (var function in occurances.Keys) {
    139         strBuilder.Append(Environment.NewLine);
    140         strBuilder.Append(function.Name); strBuilder.Append(": ");
    141         strBuilder.AppendFormat("{0:#0.00%}", occurances[function] / n);
    142       }
    143       Assert.Inconclusive("Function distribution of SubtreeCrossover: " + strBuilder);
     78      Assert.Inconclusive("SubtreeCrossover: " + Util.GetFunctionDistributionString(crossoverTrees));
    14479    }
    14580
    14681    [TestMethod()]
    14782    public void SubtreeCrossoverNumberOfSubTreesDistributionTest() {
    148       Dictionary<int, int> occurances = new Dictionary<int, int>();
    149       double n = 0.0;
    150       for (int i = 0; i < crossoverTrees.Count; i++) {
    151         foreach (var node in crossoverTrees[i].IterateNodesPrefix()) {
    152           if (!occurances.ContainsKey(node.SubTrees.Count))
    153             occurances[node.SubTrees.Count] = 0;
    154           occurances[node.SubTrees.Count]++;
    155           n++;
    156         }
    157       }
    158       StringBuilder strBuilder = new StringBuilder();
    159       foreach (var arity in occurances.Keys) {
    160         strBuilder.Append(Environment.NewLine);
    161         strBuilder.Append(arity); strBuilder.Append(": ");
    162         strBuilder.AppendFormat("{0:#0.00%}", occurances[arity] / n);
    163       }
    164       Assert.Inconclusive("Distribution of function arities of SubtreeCrossover: " + strBuilder);
     83      Assert.Inconclusive("SubtreeCrossover: " + Util.GetNumberOfSubTreesDistributionString(crossoverTrees));
    16584    }
    16685
    … …  
    16887    [TestMethod()]
    16988    public void SubtreeCrossoverTerminalDistributionTest() {
    170       Dictionary<Symbol, int> occurances = new Dictionary<Symbol, int>();
    171       double n = 0.0;
    172       for (int i = 0; i < crossoverTrees.Count; i++) {
    173         foreach (var node in crossoverTrees[i].IterateNodesPrefix()) {
    174           if (node.SubTrees.Count == 0) {
    175             if (!occurances.ContainsKey(node.Symbol))
    176               occurances[node.Symbol] = 0;
    177             occurances[node.Symbol]++;
    178             n++;
    179           }
    180         }
    181       }
    182       StringBuilder strBuilder = new StringBuilder();
    183       foreach (var function in occurances.Keys) {
    184         strBuilder.Append(Environment.NewLine);
    185         strBuilder.Append(function.Name); strBuilder.Append(": ");
    186         strBuilder.AppendFormat("{0:#0.00%}", occurances[function] / n);
    187       }
    188       Assert.Inconclusive("Terminal distribution of SubtreeCrossover: " + strBuilder);
     89      Assert.Inconclusive("SubtreeCrossover: " + Util.GetTerminalDistributionString(crossoverTrees));
    18990    }
    19091  }
Note: See TracChangeset for help on using the changeset viewer.