Index: /trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/OffspringSelectionGeneticAlgorithmMainLoop.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/OffspringSelectionGeneticAlgorithmMainLoop.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/OffspringSelectionGeneticAlgorithmMainLoop.cs	(revision 14354)
@@ -162,5 +162,4 @@
       Comparator maxSelectionPressureComparator = new Comparator();
       Comparator maxEvaluatedSolutionsComparator = new Comparator();
-      Comparator maxSolutionQualityComparator = new Comparator();
       Placeholder comparisonFactorModifier = new Placeholder();
       Placeholder analyzer2 = new Placeholder();
@@ -168,5 +167,4 @@
       ConditionalBranch conditionalBranch2 = new ConditionalBranch();
       ConditionalBranch conditionalBranch3 = new ConditionalBranch();
-      ConditionalBranch conditionalBranch4 = new ConditionalBranch();
 
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class OffspringSelectionGeneticAlgorithm expects this to be called Generations
@@ -225,9 +223,4 @@
       maxEvaluatedSolutionsComparator.RightSideParameter.ActualName = "MaximumEvaluatedSolutions";
 
-      maxSolutionQualityComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
-      maxSolutionQualityComparator.LeftSideParameter.ActualName = "MaximumQuality";
-      maxSolutionQualityComparator.ResultParameter.ActualName = "TerminateMaximumQuality";
-      maxSolutionQualityComparator.RightSideParameter.ActualName = "BestQuality";
-
       comparisonFactorModifier.Name = "Update ComparisonFactor (placeholder)";
       comparisonFactorModifier.OperatorParameter.ActualName = ComparisonFactorModifierParameter.Name;
@@ -244,7 +237,4 @@
       conditionalBranch3.Name = "MaximumEvaluatedSolutions reached?";
       conditionalBranch3.ConditionParameter.ActualName = "TerminateEvaluatedSolutions";
-
-      conditionalBranch4.Name = "MaximumQuality reached?";
-      conditionalBranch3.ConditionParameter.ActualName = "TerminateMaximumQuality";
       #endregion
 
@@ -259,6 +249,5 @@
       maxGenerationsComparator.Successor = maxSelectionPressureComparator;
       maxSelectionPressureComparator.Successor = maxEvaluatedSolutionsComparator;
-      maxEvaluatedSolutionsComparator.Successor = maxSolutionQualityComparator;
-      maxSolutionQualityComparator.Successor = comparisonFactorModifier;
+      maxEvaluatedSolutionsComparator.Successor = comparisonFactorModifier;
       comparisonFactorModifier.Successor = analyzer2;
       analyzer2.Successor = conditionalBranch1;
@@ -269,10 +258,7 @@
       conditionalBranch2.TrueBranch = null;
       conditionalBranch2.Successor = null;
-      conditionalBranch3.FalseBranch = conditionalBranch4;
+      conditionalBranch3.FalseBranch = mainOperator;
       conditionalBranch3.TrueBranch = null;
       conditionalBranch3.Successor = null;
-      conditionalBranch4.FalseBranch = mainOperator;
-      conditionalBranch4.TrueBranch = null;
-      conditionalBranch4.Successor = null;
       #endregion
     }
Index: /trunk/sources/HeuristicLab.Analysis/3.3/PopulationSimilarityAnalysis/PopulationSimilarityAnalyzer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Analysis/3.3/PopulationSimilarityAnalysis/PopulationSimilarityAnalyzer.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Analysis/3.3/PopulationSimilarityAnalysis/PopulationSimilarityAnalyzer.cs	(revision 14354)
@@ -136,5 +136,4 @@
       var similarityCalculators = SimilarityCalculatorParameter.ValidValues;
       foreach (var similarityCalculator in similarityCalculators) {
-        if (similarityCalculator == null) continue;
         similarityCalculator.ExecuteInParallel = ExecuteInParallel;
         similarityCalculator.MaxDegreeOfParallelism = MaxDegreeOfParallelism;
Index: /trunk/sources/HeuristicLab.Clients.Hive.Slave/3.3/Manager/ConfigManager.cs
===================================================================
--- /trunk/sources/HeuristicLab.Clients.Hive.Slave/3.3/Manager/ConfigManager.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Clients.Hive.Slave/3.3/Manager/ConfigManager.cs	(revision 14354)
@@ -70,5 +70,5 @@
       slave.Name = Environment.MachineName;
       if (Settings.Default.NrOfCoresToScavenge < 1 || Settings.Default.NrOfCoresToScavenge > Environment.ProcessorCount) {
-        slave.Cores = Environment.ProcessorCount / 2;
+        slave.Cores = Environment.ProcessorCount;
       } else {
         slave.Cores = Settings.Default.NrOfCoresToScavenge;
Index: /trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/GrammarUtils.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/GrammarUtils.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/GrammarUtils.cs	(revision 14354)
@@ -66,6 +66,7 @@
                 continue;
 
-              if (visited.Add(childSymbol))
+              if (visited.Add(childSymbol)) {
                 numberedSymbols.Add(Tuple.Create(childSymbol, ++index));
+              }
             }
           }
@@ -87,18 +88,4 @@
             minLength = Math.Min(minLength, oldLength);
           minimumExpressionLengths[symbol.Name] = (int)Math.Min(int.MaxValue, minLength);
-        }
-        // correction step for cycles
-        bool changed = true;
-        while (changed) {
-          changed = false;
-          foreach (var symbol in numberedSymbols.Select(x => x.Item1)) {
-            long minLength = Enumerable.Range(0, grammar.GetMinimumSubtreeCount(symbol))
-              .Sum(x => grammar.GetAllowedChildSymbols(symbol, x)
-              .Min(s => (long)minimumExpressionLengths[s.Name])) + 1;
-            if (minLength < minimumExpressionLengths[symbol.Name]) {
-              minimumExpressionLengths[symbol.Name] = (int)Math.Min(minLength, int.MaxValue);
-              changed = true;
-            }
-          }
         }
       }
@@ -134,6 +121,7 @@
                 continue;
 
-              if (visited.Add(childSymbol))
+              if (visited.Add(childSymbol)) {
                 numberedSymbols.Add(Tuple.Create(childSymbol, ++index));
+              }
             }
           }
@@ -144,10 +132,10 @@
         // going bottom-up (reverse breadth order), we ensure depths are calculated bottom-up
         foreach (var symbol in numberedSymbols.Select(x => x.Item1)) {
-          long minDepth = -1;
+          long minDepth = int.MaxValue;
           for (int argIndex = 0; argIndex < grammar.GetMinimumSubtreeCount(symbol); ++argIndex) {
             long depth = grammar.GetAllowedChildSymbols(symbol, argIndex)
               .Where(x => minimumExpressionDepths.ContainsKey(x.Name))
-              .Select(x => (long)minimumExpressionDepths[x.Name]).DefaultIfEmpty(int.MaxValue).Min() + 1;
-            minDepth = Math.Max(minDepth, depth);
+              .Select(x => minimumExpressionDepths[x.Name]).DefaultIfEmpty(int.MaxValue).Min();
+            minDepth = Math.Min(minDepth, depth + 1);
           }
           int oldDepth;
@@ -155,18 +143,4 @@
             minDepth = Math.Min(minDepth, oldDepth);
           minimumExpressionDepths[symbol.Name] = (int)Math.Min(int.MaxValue, minDepth);
-        }
-        // correction step for cycles
-        bool changed = true;
-        while (changed) {
-          changed = false;
-          foreach (var symbol in numberedSymbols.Select(x => x.Item1)) {
-            long minDepth = Enumerable.Range(0, grammar.GetMinimumSubtreeCount(symbol))
-              .Max(x => grammar.GetAllowedChildSymbols(symbol, x)
-              .Min(s => (long)minimumExpressionDepths[s.Name])) + 1;
-            if (minDepth < minimumExpressionDepths[symbol.Name]) {
-              minimumExpressionDepths[symbol.Name] = (int)Math.Min(minDepth, int.MaxValue);
-              changed = true;
-            }
-          }
         }
       }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs	(revision 14354)
@@ -70,5 +70,5 @@
       }
       if (errorState != OnlineCalculatorError.None) return double.NaN;
-      return r * r;
+      return r*r;
     }
 
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPhenotypicDiversityAnalyzer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPhenotypicDiversityAnalyzer.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPhenotypicDiversityAnalyzer.cs	(revision 14354)
@@ -42,5 +42,4 @@
     private const string ProblemDataParameterName = "ProblemData";
     private const string EstimationLimitsParameterName = "EstimationLimits";
-    private const string ApplyLinearScalingParameterName = "ApplyLinearScaling";
     #endregion
 
@@ -61,7 +60,4 @@
       get { return (IValueLookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
     }
-    public ILookupParameter<BoolValue> ApplyLinearScalingParameter {
-      get { return (ILookupParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
-    }
     #endregion
 
@@ -74,5 +70,4 @@
       Parameters.Add(new ValueLookupParameter<IRegressionProblemData>(ProblemDataParameterName, "The problem data on which the symbolic data analysis solution should be evaluated."));
       Parameters.Add(new ValueLookupParameter<DoubleLimit>(EstimationLimitsParameterName, "The upper and lower limit that should be used as cut off value for the output values of symbolic data analysis trees."));
-      Parameters.Add(new LookupParameter<BoolValue>(ApplyLinearScalingParameterName, "Whether or not to apply linear scaling to the estimated values"));
       #endregion
 
@@ -84,10 +79,4 @@
     protected SymbolicRegressionPhenotypicDiversityAnalyzer(bool deserializing)
       : base(deserializing) {
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      if (!Parameters.ContainsKey(ApplyLinearScalingParameterName))
-        Parameters.Add(new LookupParameter<BoolValue>(ApplyLinearScalingParameterName, "Whether or not to apply linear scaling to the estimated values"));
     }
 
@@ -109,38 +98,12 @@
       }
 
-      if (updateCounter.Value != updateInterval) return base.Apply();
-
-      var scopes = ExecutionContext.Scope.SubScopes;
-      var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
-
-      foreach (var scope in scopes.Where(x => !x.Variables.ContainsKey("EstimatedValues"))) {
-        var tree = (ISymbolicExpressionTree)scope.Variables["SymbolicExpressionTree"].Value;
+      if (updateCounter.Value == updateInterval) {
+        var trees = SymbolicExpressionTreeParameter.ActualValue;
         var interpreter = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
         var ds = ProblemDataParameter.ActualValue.Dataset;
         var rows = ProblemDataParameter.ActualValue.TrainingIndices;
-        var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(tree, ds, rows).ToArray();
 
-        var estimationLimits = EstimationLimitsParameter.ActualValue;
-
-        if (applyLinearScaling) {
-          var linearScalingCalculator = new OnlineLinearScalingParameterCalculator();
-          var targetValues = ds.GetDoubleValues(ProblemDataParameter.ActualValue.TargetVariable, rows);
-          int i = 0;
-          foreach (var target in targetValues) {
-            var estimated = estimatedValues[i];
-            if (!double.IsNaN(estimated) && !double.IsInfinity(estimated))
-              linearScalingCalculator.Add(estimated, target);
-            i++;
-          }
-          if (linearScalingCalculator.ErrorState == OnlineCalculatorError.None) {
-            var alpha = linearScalingCalculator.Alpha;
-            var beta = linearScalingCalculator.Beta;
-            for (i = 0; i < estimatedValues.Length; ++i) {
-              estimatedValues[i] = estimatedValues[i] * beta + alpha;
-            }
-          }
-        }
-        // add estimated values to escope
-        scope.Variables.Add(new Core.Variable("EstimatedValues", new DoubleArray(estimatedValues.LimitToRange(estimationLimits.Lower, estimationLimits.Upper).ToArray())));
+        var evaluatedValues = new ItemArray<DoubleArray>(trees.Select(t => new DoubleArray(interpreter.GetSymbolicExpressionTreeValues(t, ds, rows).ToArray())));
+        EvaluatedValuesParameter.ActualValue = evaluatedValues;
       }
       return base.Apply();
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeBottomUpSimilarityCalculator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeBottomUpSimilarityCalculator.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeBottomUpSimilarityCalculator.cs	(revision 14354)
@@ -61,8 +61,4 @@
     }
 
-    public static double CalculateBottomUpSimilarity(ISymbolicExpressionTree t1, ISymbolicExpressionTree t2) {
-      return new SymbolicExpressionTreeBottomUpSimilarityCalculator().CalculateSimilarity(t1, t2);
-    }
-
     public override double CalculateSolutionSimilarity(IScope leftSolution, IScope rightSolution) {
       if (leftSolution == rightSolution)
@@ -77,5 +73,5 @@
       var similarity = CalculateSimilarity(t1, t2);
       if (similarity > 1.0)
-        throw new Exception("Similarity value " + similarity + " cannot be greater than 1");
+        throw new Exception("Similarity value cannot be greater than 1");
 
       return similarity;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreePhenotypicSimilarityCalculator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreePhenotypicSimilarityCalculator.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreePhenotypicSimilarityCalculator.cs	(revision 14354)
@@ -92,4 +92,8 @@
 
       var r2 = error == OnlineCalculatorError.None ? r * r : 0;
+
+      if (r2 > 1.0)
+        r2 = 1.0;
+
       return r2;
     }
Index: unk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.4/ArtificialAnt/GEArtificialAntEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.4/ArtificialAnt/GEArtificialAntEvaluator.cs	(revision 14353)
+++ 	(revision )
@@ -1,135 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2016 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/>.
- * 
- * Author: Sabine Winkler
- */
-#endregion
-
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.ArtificialAnt;
-using HeuristicLab.Problems.GrammaticalEvolution.Mappers;
-
-namespace HeuristicLab.Problems.GrammaticalEvolution {
-  [Item("GEArtificialAntEvaluator", "Evaluates an artificial ant solution for grammatical evolution.")]
-  [StorableClass]
-  public class GEArtificialAntEvaluator : SingleSuccessorOperator,
-    ISingleObjectiveEvaluator, ISymbolicExpressionTreeGrammarBasedOperator {
-
-    #region Parameter Properties
-    public ILookupParameter<DoubleValue> QualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
-    }
-    // genotype:
-    public ILookupParameter<IntegerVector> IntegerVectorParameter {
-      get { return (ILookupParameter<IntegerVector>)Parameters["IntegerVector"]; }
-    }
-    // phenotype:
-    public ILookupParameter<ISymbolicExpressionTree> SymbolicExpressionTreeParameter {
-      get { return (ILookupParameter<ISymbolicExpressionTree>)Parameters["SymbolicExpressionTree"]; }
-    }
-    public ILookupParameter<BoolMatrix> WorldParameter {
-      get { return (ILookupParameter<BoolMatrix>)Parameters["World"]; }
-    }
-    public ILookupParameter<IntValue> MaxTimeStepsParameter {
-      get { return (ILookupParameter<IntValue>)Parameters["MaxTimeSteps"]; }
-    }
-    public IValueLookupParameter<ISymbolicExpressionGrammar> SymbolicExpressionTreeGrammarParameter {
-      get { return (IValueLookupParameter<ISymbolicExpressionGrammar>)Parameters["SymbolicExpressionTreeGrammar"]; }
-    }
-    // genotype-to-phenotype-mapper:
-    public ILookupParameter<IGenotypeToPhenotypeMapper> GenotypeToPhenotypeMapperParameter {
-      get { return (ILookupParameter<IGenotypeToPhenotypeMapper>)Parameters["GenotypeToPhenotypeMapper"]; }
-    }
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public ILookupParameter<IntMatrix> BoundsParameter {
-      get { return (ILookupParameter<IntMatrix>)Parameters["Bounds"]; }
-    }
-    public ILookupParameter<IntValue> MaxExpressionLengthParameter {
-      get { return (ILookupParameter<IntValue>)Parameters["MaximumExpressionLength"]; }
-    }
-    #endregion
-
-    [StorableConstructor]
-    protected GEArtificialAntEvaluator(bool deserializing) : base(deserializing) { }
-    protected GEArtificialAntEvaluator(GEArtificialAntEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public override IDeepCloneable Clone(Cloner cloner) { return new GEArtificialAntEvaluator(this, cloner); }
-    public GEArtificialAntEvaluator()
-      : base() {
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the evaluated artificial ant solution."));
-      Parameters.Add(new LookupParameter<IntegerVector>("IntegerVector", "The artificial ant solution encoded as an integer vector genome."));
-      Parameters.Add(new LookupParameter<ISymbolicExpressionTree>("SymbolicExpressionTree", "The artificial ant solution encoded as a symbolic expression tree that should be evaluated"));
-      Parameters.Add(new LookupParameter<BoolMatrix>("World", "The world for the artificial ant with scattered food items."));
-      Parameters.Add(new LookupParameter<IntValue>("MaxTimeSteps", "The maximal number of time steps that the artificial ant should be simulated."));
-      Parameters.Add(new ValueLookupParameter<ISymbolicExpressionGrammar>("SymbolicExpressionTreeGrammar", "The tree grammar that defines the correct syntax of symbolic expression trees that should be created."));
-      Parameters.Add(new LookupParameter<IGenotypeToPhenotypeMapper>("GenotypeToPhenotypeMapper", "Maps the genotype (an integer vector) to the phenotype (a symbolic expression tree)."));
-      Parameters.Add(new LookupParameter<IRandom>("Random", "Random number generator for the genotype creation and the genotype-to-phenotype mapping."));
-
-      Parameters.Add(new LookupParameter<IntMatrix>("Bounds", "The integer number range in which the single genomes of a genotype are created."));
-      Parameters.Add(new LookupParameter<IntValue>("MaximumExpressionLength", "Maximal length of the expression to control the artificial ant (genotype length)."));
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      // BackwardsCompatibility3.3
-      #region Backwards compatible code, remove with 3.4
-
-      if (Parameters.ContainsKey("SymbolicExpressionTree") &&
-          Parameters["SymbolicExpressionTree"] is ILookupParameter<SymbolicExpressionTree>) {
-        var previousActualName = ((ILookupParameter<SymbolicExpressionTree>)Parameters["SymbolicExpressionTree"]).ActualName;
-        Parameters.Remove("SymbolicExpressionTree");
-        Parameters.Add(new LookupParameter<ISymbolicExpressionTree>("SymbolicExpressionTree", "The artificial ant solution encoded as a symbolic expression tree that should be evaluated", previousActualName));
-      }
-
-      #endregion
-
-    }
-
-    public sealed override IOperation Apply() {
-      SymbolicExpressionTree tree = GenotypeToPhenotypeMapperParameter.ActualValue.Map(
-        RandomParameter.ActualValue,
-        BoundsParameter.ActualValue,
-        MaxExpressionLengthParameter.ActualValue.Value,
-        SymbolicExpressionTreeGrammarParameter.ActualValue,
-        IntegerVectorParameter.ActualValue
-      );
-      SymbolicExpressionTreeParameter.ActualValue = tree;
-      BoolMatrix world = WorldParameter.ActualValue;
-      IntValue maxTimeSteps = MaxTimeStepsParameter.ActualValue;
-
-      AntInterpreter interpreter = new AntInterpreter();
-      interpreter.MaxTimeSteps = maxTimeSteps.Value;
-      interpreter.World = world;
-      interpreter.Expression = tree;
-      interpreter.Run();
-
-      QualityParameter.ActualValue = new DoubleValue(interpreter.FoodEaten);
-      return null;
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.4/HeuristicLab.Problems.GrammaticalEvolution-3.4.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.4/HeuristicLab.Problems.GrammaticalEvolution-3.4.csproj	(revision 14353)
+++ /trunk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.4/HeuristicLab.Problems.GrammaticalEvolution-3.4.csproj	(revision 14354)
@@ -252,7 +252,4 @@
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup>
-    <Content Include="ArtificialAnt\GEArtificialAntEvaluator.cs" />
-  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab-3.3/ContentViewTests.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab-3.3/ContentViewTests.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab-3.3/ContentViewTests.cs	(revision 14354)
@@ -24,4 +24,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.MainForm;
+using HeuristicLab.MainForm.WindowsForms;
 using HeuristicLab.PluginInfrastructure;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/NPointCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/NPointCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/NPointCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Tests;
@@ -32,39 +31,4 @@
   [TestClass()]
   public class NPointCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.BinaryVector")]
-    [TestProperty("Time", "short")]
-    public void NPointCrossoverCrossTest() {
-      var privateObject = new PrivateObject(typeof(NPointCrossover));
-      ItemArray<BinaryVector> parents;
-      TestRandom random = new TestRandom();
-      bool exceptionFired;
-      // The following test checks if there is an exception when there are more than 2 parents
-      random.Reset();
-      parents = new ItemArray<BinaryVector>(new BinaryVector[] { new BinaryVector(5), new BinaryVector(6), new BinaryVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (BinaryVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-      // The following test checks if there is an exception when there are less than 2 parents
-      random.Reset();
-      parents = new ItemArray<BinaryVector>(new BinaryVector[] { new BinaryVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (BinaryVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: unk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/SinglePointCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/SinglePointCrossoverTest.cs	(revision 14353)
+++ 	(revision )
@@ -1,69 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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 HeuristicLab.Core;
-using HeuristicLab.Tests;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace HeuristicLab.Encodings.BinaryVectorEncoding.Tests {
-  /// <summary>
-  ///This is a test class for SinglePointCrossoverTest and is intended
-  ///to contain all SinglePointCrossoverTest Unit Tests
-  ///</summary>
-  [TestClass()]
-  public class SinglePointCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.BinaryVector")]
-    [TestProperty("Time", "short")]
-    public void SinglePointCrossoverCrossTest() {
-      var privateObject = new PrivateObject(typeof(SinglePointCrossover));
-      ItemArray<BinaryVector> parents;
-      TestRandom random = new TestRandom();
-      bool exceptionFired;
-      // The following test checks if there is an exception when there are more than 2 parents
-      random.Reset();
-      parents = new ItemArray<BinaryVector>(new BinaryVector[] { new BinaryVector(5), new BinaryVector(6), new BinaryVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (BinaryVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-      // The following test checks if there is an exception when there are less than 2 parents
-      random.Reset();
-      parents = new ItemArray<BinaryVector>(new BinaryVector[] { new BinaryVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (BinaryVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/UniformCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/UniformCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/UniformCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,41 +30,4 @@
   [TestClass()]
   public class UniformCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.BinaryVector")]
-    [TestProperty("Time", "short")]
-    public void SinglePointCrossoverCrossTest() {
-      var target = new PrivateObject(typeof(UniformCrossover));
-      ItemArray<BinaryVector> parents;
-      TestRandom random = new TestRandom();
-      bool exceptionFired;
-      // The following test checks if there is an exception when there are more than 2 parents
-      random.Reset();
-      parents = new ItemArray<BinaryVector>(new BinaryVector[] { new BinaryVector(5), new BinaryVector(6), new BinaryVector(4) });
-      exceptionFired = false;
-      try {
-        BinaryVector actual;
-        actual = (BinaryVector)target.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-      // The following test checks if there is an exception when there are less than 2 parents
-      random.Reset();
-      parents = new ItemArray<BinaryVector>(new BinaryVector[] { new BinaryVector(4) });
-      exceptionFired = false;
-      try {
-        BinaryVector actual;
-        actual = (BinaryVector)target.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.IntegerVectorEncoding-3.3/DiscreteCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.IntegerVectorEncoding-3.3/DiscreteCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.IntegerVectorEncoding-3.3/DiscreteCrossoverTest.cs	(revision 14354)
@@ -31,28 +31,4 @@
   [TestClass()]
   public class DiscreteCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.IntegerVector")]
-    [TestProperty("Time", "short")]
-    public void DiscreteCrossoverCrossTest() {
-      var privateObject = new PrivateObject(typeof(DiscreteCrossover));
-      ItemArray<IntegerVector> parents;
-      TestRandom random = new TestRandom();
-      bool exceptionFired;
-      // The following test checks if there is an exception when there are less than 2 parents
-      random.Reset();
-      parents = new ItemArray<IntegerVector>(new IntegerVector[] { new IntegerVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (IntegerVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.IntegerVectorEncoding-3.3/SinglePointCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.IntegerVectorEncoding-3.3/SinglePointCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.IntegerVectorEncoding-3.3/SinglePointCrossoverTest.cs	(revision 14354)
@@ -38,5 +38,5 @@
     [TestProperty("Time", "short")]
     public void SinglePointCrossoverCrossTest() {
-      var privateObject = new PrivateObject(typeof(SinglePointCrossover));
+      var target = new PrivateObject(typeof(SinglePointCrossover));
       ItemArray<IntegerVector> parents;
       TestRandom random = new TestRandom();
@@ -47,5 +47,6 @@
       exceptionFired = false;
       try {
-        var actual = (IntegerVector)privateObject.Invoke("Cross", random, parents);
+        IntegerVector actual;
+        actual = (IntegerVector)target.Invoke("Cross", random, parents);
       }
       catch (System.ArgumentException) {
@@ -58,5 +59,6 @@
       exceptionFired = false;
       try {
-        var actual = (IntegerVector)privateObject.Invoke("Cross", random, parents);
+        IntegerVector actual;
+        actual = (IntegerVector)target.Invoke("Cross", random, parents);
       }
       catch (System.ArgumentException) {
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CosaCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CosaCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CosaCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,26 +30,4 @@
   [TestClass()]
   public class CosaCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.Permutation")]
-    [TestProperty("Time", "short")]
-    public void CosaCrossoverCrossTest() {
-      TestRandom random = new TestRandom();
-      var privateObject = new PrivateObject(typeof(CosaCrossover));
-      // perform a test with more than two parents
-      random.Reset();
-      bool exceptionFired = false;
-      try {
-        privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
-          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
-      }
-      catch (System.InvalidOperationException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CyclicCrossover2Test.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CyclicCrossover2Test.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CyclicCrossover2Test.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,26 +30,4 @@
   [TestClass()]
   public class CyclicCrossover2Test {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.Permutation")]
-    [TestProperty("Time", "short")]
-    public void CyclicCrossover2CrossTest() {
-      TestRandom random = new TestRandom();
-      var privateObject = new PrivateObject(typeof(CyclicCrossover2));
-      // perform a test with more than two parents
-      random.Reset();
-      bool exceptionFired = false;
-      try {
-        privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
-          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
-      }
-      catch (System.InvalidOperationException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CyclicCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CyclicCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CyclicCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,26 +30,4 @@
   [TestClass()]
   public class CyclicCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.Permutation")]
-    [TestProperty("Time", "short")]
-    public void CyclicCrossoverCrossTest() {
-      TestRandom random = new TestRandom();
-      var privateObject = new PrivateObject(typeof(CyclicCrossover));
-      // perform a test with more than two parents
-      random.Reset();
-      bool exceptionFired = false;
-      try {
-        privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
-          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
-      }
-      catch (System.InvalidOperationException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/EdgeRecombinationCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/EdgeRecombinationCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/EdgeRecombinationCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,26 +30,4 @@
   [TestClass()]
   public class EdgeRecombinationCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.Permutation")]
-    [TestProperty("Time", "short")]
-    public void EdgeRecombinationCrossoverCrossoverCrossTest() {
-      TestRandom random = new TestRandom();
-      var privateObject = new PrivateObject(typeof(EdgeRecombinationCrossover));
-      // perform a test with more than two parents
-      random.Reset();
-      bool exceptionFired = false;
-      try {
-        privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
-          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
-      }
-      catch (System.InvalidOperationException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/MaximalPreservativeCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/MaximalPreservativeCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/MaximalPreservativeCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,26 +30,4 @@
   [TestClass()]
   public class MaximalPreservativeCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.Permutation")]
-    [TestProperty("Time", "short")]
-    public void MaximalPreservativeCrossoverCrossTest() {
-      TestRandom random = new TestRandom();
-      var privateObject = new PrivateObject(typeof(MaximalPreservativeCrossover));
-      // perform a test with more than two parents
-      random.Reset();
-      bool exceptionFired = false;
-      try {
-        privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
-          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
-      }
-      catch (System.InvalidOperationException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderBasedCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderBasedCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderBasedCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,26 +30,4 @@
   [TestClass()]
   public class OrderBasedCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.Permutation")]
-    [TestProperty("Time", "short")]
-    public void OrderBasedCrossoverCrossTest() {
-      TestRandom random = new TestRandom();
-      var privateObject = new PrivateObject(typeof(OrderBasedCrossover));
-      // perform a test with more than two parents
-      random.Reset();
-      bool exceptionFired = false;
-      try {
-        privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
-          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
-      }
-      catch (System.InvalidOperationException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderCrossover2Test.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderCrossover2Test.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderCrossover2Test.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,25 +30,4 @@
   [TestClass()]
   public class OrderCrossover2Test {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.Permutation")]
-    [TestProperty("Time", "short")]
-    public void OrderCrossover2CrossTest() {
-      TestRandom random = new TestRandom();
-      var privateObject = new PrivateObject(typeof(OrderCrossover2));
-      random.Reset();
-      bool exceptionFired = false;
-      try {
-        privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
-          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
-      }
-      catch (System.InvalidOperationException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,26 +30,4 @@
   [TestClass()]
   public class OrderCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.Permutation")]
-    [TestProperty("Time", "short")]
-    public void OrderCrossoverCrossTest() {
-      TestRandom random = new TestRandom();
-      var privateObject = new PrivateObject(typeof(OrderCrossover));
-      // perform a test with more than two parents
-      random.Reset();
-      bool exceptionFired = false;
-      try {
-        privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
-          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
-      }
-      catch (System.InvalidOperationException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/PartiallyMatchedCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/PartiallyMatchedCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/PartiallyMatchedCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,26 +30,4 @@
   [TestClass()]
   public class PartiallyMatchedCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.Permutation")]
-    [TestProperty("Time", "short")]
-    public void PartiallyMatchedCrossTest() {
-      TestRandom random = new TestRandom();
-      var privateObject = new PrivateObject(typeof(PartiallyMatchedCrossover));
-      // perform a test with more than two parents
-      random.Reset();
-      bool exceptionFired = false;
-      try {
-        privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
-          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
-      }
-      catch (System.InvalidOperationException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/PositionBasedCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/PositionBasedCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/PositionBasedCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,27 +30,4 @@
   [TestClass()]
   public class PositionBasedCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.Permutation")]
-    [TestProperty("Time", "short")]
-    public void PositionBasedCrossoverCrossTest() {
-      TestRandom random = new TestRandom();
-      var privateObject = new PrivateObject(typeof(PositionBasedCrossover));
-
-      // perform a test with more than two parents
-      random.Reset();
-      bool exceptionFired = false;
-      try {
-        privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
-          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4) }));
-      }
-      catch (System.InvalidOperationException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/UniformLikeCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/UniformLikeCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/UniformLikeCrossoverTest.cs	(revision 14354)
@@ -54,26 +54,4 @@
       Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
     }
-
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod]
-    [TestCategory("Encodings.Permutation")]
-    [TestProperty("Time", "short")]
-    public void UniformLikeCrossoverCrossTest() {
-      var privateObject = new PrivateObject(typeof(UniformLikeCrossover));
-      IRandom random = new TestRandom(new int[] { }, new double[] { 0.1, 0.2, 0.3, 0.4 });
-      random.Reset();
-      bool exceptionFired = false;
-      try {
-        privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
-
-          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
-      }
-      catch (System.InvalidOperationException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
   }
 }
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/BlendAlphaBetaCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/BlendAlphaBetaCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/BlendAlphaBetaCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Tests;
@@ -32,39 +31,4 @@
   [TestClass()]
   public class BlendAlphaBetaCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod()]
-    [TestCategory("Encodings.RealVector")]
-    [TestProperty("Time", "short")]
-    public void BlendAlphaBetaCrossoverCrossTest() {
-      var privateObject = new PrivateObject(typeof(BlendAlphaBetaCrossover));
-      ItemArray<RealVector> parents;
-      TestRandom random = new TestRandom();
-      bool exceptionFired;
-      // The following test checks if there is an exception when there are more than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(5), new RealVector(6), new RealVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-      // The following test checks if there is an exception when there are less than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/BlendAlphaCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/BlendAlphaCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/BlendAlphaCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Tests;
@@ -32,39 +31,4 @@
   [TestClass()]
   public class BlendAlphaCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod()]
-    [TestCategory("Encodings.RealVector")]
-    [TestProperty("Time", "short")]
-    public void BlendAlphaCrossoverCrossTest() {
-      var privateObject = new PrivateObject(typeof(BlendAlphaCrossover));
-      ItemArray<RealVector> parents;
-      TestRandom random = new TestRandom();
-      bool exceptionFired;
-      // The following test checks if there is an exception when there are more than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(5), new RealVector(6), new RealVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-      // The following test checks if there is an exception when there are less than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/DiscreteCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/DiscreteCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/DiscreteCrossoverTest.cs	(revision 14354)
@@ -31,28 +31,4 @@
   [TestClass()]
   public class DiscreteCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod()]
-    [TestCategory("Encodings.RealVector")]
-    [TestProperty("Time", "short")]
-    public void DiscreteCrossoverCrossTest() {
-      var privateObject = new PrivateObject(typeof(DiscreteCrossover));
-      ItemArray<RealVector> parents;
-      TestRandom random = new TestRandom();
-      bool exceptionFired;
-      // The following test checks if there is an exception when there are less than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/HeuristicCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/HeuristicCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/HeuristicCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,39 +30,4 @@
   [TestClass()]
   public class HeuristicCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod()]
-    [TestCategory("Encodings.RealVector")]
-    [TestProperty("Time", "short")]
-    public void HeuristicCrossoverCrossTest() {
-      var privateObject = new PrivateObject(typeof(HeuristicCrossover));
-      ItemArray<RealVector> parents;
-      TestRandom random = new TestRandom();
-      bool exceptionFired;
-      // The following test checks if there is an exception when there are more than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(5), new RealVector(6), new RealVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-      // The following test checks if there is an exception when there are less than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/LocalCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/LocalCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/LocalCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,39 +30,4 @@
   [TestClass()]
   public class LocalCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod()]
-    [TestCategory("Encodings.RealVector")]
-    [TestProperty("Time", "short")]
-    public void LocalCrossoverCrossTest() {
-      var privateObject = new PrivateObject(typeof(LocalCrossover));
-      ItemArray<RealVector> parents;
-      TestRandom random = new TestRandom();
-      bool exceptionFired;
-      // The following test checks if there is an exception when there are more than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(5), new RealVector(6), new RealVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-      // The following test checks if there is an exception when there are less than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/RandomConvexCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/RandomConvexCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/RandomConvexCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,39 +30,4 @@
   [TestClass()]
   public class RandomConvexCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod()]
-    [TestCategory("Encodings.RealVector")]
-    [TestProperty("Time", "short")]
-    public void RandomConvexCrossoverCrossTest() {
-      var privateObject = new PrivateObject(typeof(RandomConvexCrossover));
-      ItemArray<RealVector> parents;
-      TestRandom random = new TestRandom();
-      bool exceptionFired;
-      // The following test checks if there is an exception when there are more than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(5), new RealVector(6), new RealVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-      // The following test checks if there is an exception when there are less than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/SimulatedBinaryCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/SimulatedBinaryCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/SimulatedBinaryCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Tests;
@@ -32,39 +31,4 @@
   [TestClass()]
   public class SimulatedBinaryCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod()]
-    [TestCategory("Encodings.RealVector")]
-    [TestProperty("Time", "short")]
-    public void SimulatedBinaryCrossoverCrossTest() {
-      var privateObject = new PrivateObject(typeof(SimulatedBinaryCrossover));
-      ItemArray<RealVector> parents;
-      TestRandom random = new TestRandom();
-      bool exceptionFired;
-      // The following test checks if there is an exception when there are more than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(5), new RealVector(6), new RealVector(4) });
-      exceptionFired = false;
-      try {
-        RealVector actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-      // The following test checks if there is an exception when there are less than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
-      exceptionFired = false;
-      try {
-        RealVector actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/SinglePointCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/SinglePointCrossoverTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/SinglePointCrossoverTest.cs	(revision 14354)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Tests;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,50 +30,4 @@
   [TestClass()]
   public class SinglePointCrossoverTest {
-    /// <summary>
-    ///A test for Cross
-    ///</summary>
-    [TestMethod()]
-    [TestCategory("Encodings.RealVector")]
-    [TestProperty("Time", "short")]
-    public void SinglePointCrossoverCrossTest() {
-      var privateObject = new PrivateObject(typeof(SinglePointCrossover));
-      ItemArray<RealVector> parents;
-      TestRandom random = new TestRandom();
-      bool exceptionFired;
-      // The following test checks if there is an exception when there are more than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(5), new RealVector(6), new RealVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-      // The following test checks if there is an exception when there are less than 2 parents
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
-      exceptionFired = false;
-      try {
-        var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-      // The following test checks if there is an exception when the vector has just one dimension
-      random.Reset();
-      parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(1) });
-      exceptionFired = false;
-      try {
-        var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
-      }
-      catch (System.ArgumentException) {
-        exceptionFired = true;
-      }
-      Assert.IsTrue(exceptionFired);
-    }
-
     /// <summary>
     ///A test for Apply
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4/GrammarsTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4/GrammarsTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4/GrammarsTest.cs	(revision 14354)
@@ -86,24 +86,4 @@
         Assert.AreEqual(3, grammar.GetMinimumExpressionLength(x));
         Assert.AreEqual(2, grammar.GetMinimumExpressionLength(y));
-      }
-
-      {
-        var grammar = CreateTestGrammar6();
-        var prs = grammar.ProgramRootSymbol;
-        var ss = grammar.StartSymbol;
-        var x = grammar.Symbols.First(s => s.Name == "<x>");
-        var s_ = grammar.Symbols.First(s => s.Name == "<s>");
-        var a = grammar.Symbols.First(s => s.Name == "<a>");
-        var b = grammar.Symbols.First(s => s.Name == "<b>");
-        var c = grammar.Symbols.First(s => s.Name == "<c>");
-        var d = grammar.Symbols.First(s => s.Name == "<d>");
-        Assert.AreEqual(4, grammar.GetMinimumExpressionLength(prs));
-        Assert.AreEqual(3, grammar.GetMinimumExpressionLength(ss));
-        Assert.AreEqual(2, grammar.GetMinimumExpressionLength(x));
-        Assert.AreEqual(5, grammar.GetMinimumExpressionLength(s_));
-        Assert.AreEqual(4, grammar.GetMinimumExpressionLength(a));
-        Assert.AreEqual(3, grammar.GetMinimumExpressionLength(b));
-        Assert.AreEqual(4, grammar.GetMinimumExpressionLength(c));
-        Assert.AreEqual(3, grammar.GetMinimumExpressionLength(d));
       }
     }
@@ -190,24 +170,4 @@
         Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(y));
       }
-
-      {
-        var grammar = CreateTestGrammar6();
-        var prs = grammar.ProgramRootSymbol;
-        var ss = grammar.StartSymbol;
-        var x = grammar.Symbols.First(s => s.Name == "<x>");
-        var s_ = grammar.Symbols.First(s => s.Name == "<s>");
-        var a = grammar.Symbols.First(s => s.Name == "<a>");
-        var b = grammar.Symbols.First(s => s.Name == "<b>");
-        var c = grammar.Symbols.First(s => s.Name == "<c>");
-        var d = grammar.Symbols.First(s => s.Name == "<d>");
-        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(prs));
-        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(ss));
-        Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(x));
-        Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(s_));
-        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(a));
-        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(b));
-        Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(c));
-        Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(d));
-      }
     }
 
@@ -326,41 +286,4 @@
       return grammar;
     }
-
-    private static ISymbolicExpressionGrammar CreateTestGrammar6() {
-      var grammar = new SimpleSymbolicExpressionGrammar();
-      var x = new SimpleSymbol("<x>", 1);
-      var s = new SimpleSymbol("<s>", 1);
-      var a = new SimpleSymbol("<a>", 1);
-      var b = new SimpleSymbol("<b>", 1);
-      var c = new SimpleSymbol("<c>", 1);
-      var d = new SimpleSymbol("<d>", 1);
-      var e = new SimpleSymbol("<e>", 1);
-
-      var _x = new SimpleSymbol("x", 0);
-      var _y = new SimpleSymbol("y", 0);
-
-      grammar.AddSymbol(x);
-      grammar.AddSymbol(s);
-      grammar.AddSymbol(a);
-      grammar.AddSymbol(b);
-      grammar.AddSymbol(c);
-      grammar.AddSymbol(d);
-      grammar.AddSymbol(e);
-      grammar.AddSymbol(_x);
-      grammar.AddSymbol(_y);
-
-      grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
-      grammar.AddAllowedChildSymbol(x, s);
-      grammar.AddAllowedChildSymbol(x, _x);
-      grammar.AddAllowedChildSymbol(s, a);
-      grammar.AddAllowedChildSymbol(a, b);
-      grammar.AddAllowedChildSymbol(a, c);
-      grammar.AddAllowedChildSymbol(b, x);
-      grammar.AddAllowedChildSymbol(c, d);
-      grammar.AddAllowedChildSymbol(d, e);
-      grammar.AddAllowedChildSymbol(e, _y);
-
-      return grammar;
-    }
   }
 }
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionTreeInterpreterTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionTreeInterpreterTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionTreeInterpreterTest.cs	(revision 14354)
@@ -33,5 +33,5 @@
   public class SymbolicDataAnalysisExpressionTreeInterpreterTest {
     private const int N = 1000;
-    private const int Rows = 5000;
+    private const int Rows = 1000;
     private const int Columns = 50;
 
@@ -73,4 +73,23 @@
     [TestCategory("Problems.DataAnalysis.Symbolic")]
     [TestProperty("Time", "long")]
+    public void CompiledInterpreterTestTypeCoherentGrammarPerformance() {
+      TestTypeCoherentGrammarPerformance(new SymbolicDataAnalysisExpressionCompiledTreeInterpreter(), 12.5e6);
+    }
+    [TestMethod]
+    [TestCategory("Problems.DataAnalysis.Symbolic")]
+    [TestProperty("Time", "long")]
+    public void CompiledInterpreterTestFullGrammarPerformance() {
+      TestFullGrammarPerformance(new SymbolicDataAnalysisExpressionCompiledTreeInterpreter(), 12.5e6);
+    }
+    [TestMethod]
+    [TestCategory("Problems.DataAnalysis.Symbolic")]
+    [TestProperty("Time", "long")]
+    public void CompiledInterpreterTestArithmeticGrammarPerformance() {
+      TestArithmeticGrammarPerformance(new SymbolicDataAnalysisExpressionCompiledTreeInterpreter(), 12.5e6);
+    }
+
+    [TestMethod]
+    [TestCategory("Problems.DataAnalysis.Symbolic")]
+    [TestProperty("Time", "long")]
     public void ILEmittingInterpreterTestTypeCoherentGrammarPerformance() {
       TestTypeCoherentGrammarPerformance(new SymbolicDataAnalysisExpressionTreeILEmittingInterpreter(), 7.5e6);
@@ -166,4 +185,15 @@
     [TestCategory("Problems.DataAnalysis.Symbolic")]
     [TestProperty("Time", "short")]
+    public void CompiledInterpreterTestEvaluation() {
+      var interpreter = new SymbolicDataAnalysisExpressionCompiledTreeInterpreter();
+      // ADFs are not supported by the compiled tree interpreter
+      EvaluateTerminals(interpreter, ds);
+      EvaluateOperations(interpreter, ds);
+      EvaluateSpecialFunctions(interpreter, ds);
+    }
+
+    [TestMethod]
+    [TestCategory("Problems.DataAnalysis.Symbolic")]
+    [TestProperty("Time", "short")]
     public void LinearInterpreterTestEvaluation() {
       var interpreter = new SymbolicDataAnalysisExpressionTreeLinearInterpreter();
@@ -239,4 +269,5 @@
 
       var interpreters = new ISymbolicDataAnalysisExpressionTreeInterpreter[] {
+        new SymbolicDataAnalysisExpressionCompiledTreeInterpreter(),
         new SymbolicDataAnalysisExpressionTreeInterpreter(),
         new SymbolicDataAnalysisExpressionTreeLinearInterpreter(),
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicExpressionTreeBottomUpSimilarityCalculatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicExpressionTreeBottomUpSimilarityCalculatorTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicExpressionTreeBottomUpSimilarityCalculatorTest.cs	(revision 14354)
@@ -15,8 +15,5 @@
 
     public BottomUpSimilarityCalculatorTest() {
-      busCalculator = new SymbolicExpressionTreeBottomUpSimilarityCalculator {
-        //        MatchConstantValues = true,
-        //        MatchVariableWeights = true
-      };
+      busCalculator = new SymbolicExpressionTreeBottomUpSimilarityCalculator();
       importer = new SymbolicExpressionImporter();
     }
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/AckleyEvaluatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/AckleyEvaluatorTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/AckleyEvaluatorTest.cs	(revision 14354)
@@ -37,13 +37,11 @@
     [TestProperty("Time", "short")]
     public void AckleyEvaluateFunctionTest() {
-      var privateObject = new PrivateObject(typeof(AckleyEvaluator));
+      AckleyEvaluator target = new AckleyEvaluator();
       RealVector point = null;
-      double expected = (double)privateObject.GetProperty("BestKnownQuality");
+      double expected = target.BestKnownQuality;
       double actual;
-      int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
-      int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
-      for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
-        point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
-        actual = (double)privateObject.Invoke("Evaluate", point);
+      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
+        point = target.GetBestKnownSolution(dimension);
+        actual = target.Evaluate(point);
         Assert.AreEqual(expected, actual);
       }
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/BealeEvaluatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/BealeEvaluatorTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/BealeEvaluatorTest.cs	(revision 14354)
@@ -37,13 +37,11 @@
     [TestProperty("Time", "short")]
     public void BealeEvaluateFunctionTest() {
-      var privateObject = new PrivateObject(typeof(BealeEvaluator));
+      BealeEvaluator target = new BealeEvaluator();
       RealVector point = null;
-      double expected = (double)privateObject.GetProperty("BestKnownQuality");
+      double expected = target.BestKnownQuality;
       double actual;
-      int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
-      int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
-      for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
-        point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
-        actual = (double)privateObject.Invoke("Evaluate", point);
+      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
+        point = target.GetBestKnownSolution(dimension);
+        actual = target.Evaluate(point);
         Assert.AreEqual(expected, actual);
       }
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/BoothEvaluatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/BoothEvaluatorTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/BoothEvaluatorTest.cs	(revision 14354)
@@ -37,13 +37,11 @@
     [TestProperty("Time", "short")]
     public void BoothEvaluateFunctionTest() {
-      var privateObject = new PrivateObject(typeof(BoothEvaluator));
+      BoothEvaluator target = new BoothEvaluator();
       RealVector point = null;
-      double expected = (double)privateObject.GetProperty("BestKnownQuality");
+      double expected = target.BestKnownQuality;
       double actual;
-      int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
-      int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
-      for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
-        point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
-        actual = (double)privateObject.Invoke("Evaluate", point);
+      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
+        point = target.GetBestKnownSolution(dimension);
+        actual = target.Evaluate(point);
         Assert.AreEqual(expected, actual);
       }
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/GriewankEvaluatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/GriewankEvaluatorTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/GriewankEvaluatorTest.cs	(revision 14354)
@@ -37,13 +37,11 @@
     [TestProperty("Time", "short")]
     public void GriewankEvaluateFunctionTest() {
-      var privateObject = new PrivateObject(typeof(GriewankEvaluator));
+      GriewankEvaluator target = new GriewankEvaluator();
       RealVector point = null;
-      double expected = (double)privateObject.GetProperty("BestKnownQuality");
+      double expected = target.BestKnownQuality;
       double actual;
-      int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
-      int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
-      for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
-        point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
-        actual = (double)privateObject.Invoke("Evaluate", point);
+      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
+        point = target.GetBestKnownSolution(dimension);
+        actual = target.Evaluate(point);
         Assert.AreEqual(expected, actual);
       }
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/LevyEvaluatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/LevyEvaluatorTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/LevyEvaluatorTest.cs	(revision 14354)
@@ -37,13 +37,11 @@
     [TestProperty("Time", "short")]
     public void LevyEvaluateFunctionTest() {
-      var privateObject = new PrivateObject(typeof(LevyEvaluator));
+      LevyEvaluator target = new LevyEvaluator();
       RealVector point = null;
-      double expected = (double)privateObject.GetProperty("BestKnownQuality");
+      double expected = target.BestKnownQuality;
       double actual;
-      int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
-      int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
-      for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
-        point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
-        actual = (double)privateObject.Invoke("Evaluate", point);
+      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
+        point = target.GetBestKnownSolution(dimension);
+        actual = target.Evaluate(point);
         Assert.AreEqual(expected, actual);
       }
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/MatyasEvaluatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/MatyasEvaluatorTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/MatyasEvaluatorTest.cs	(revision 14354)
@@ -37,13 +37,11 @@
     [TestProperty("Time", "short")]
     public void MatyasEvaluateFunctionTest() {
-      var privateObject = new PrivateObject(typeof(MatyasEvaluator));
+      MatyasEvaluator target = new MatyasEvaluator();
       RealVector point = null;
-      double expected = (double)privateObject.GetProperty("BestKnownQuality");
+      double expected = target.BestKnownQuality;
       double actual;
-      int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
-      int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
-      for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
-        point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
-        actual = (double)privateObject.Invoke("Evaluate", point);
+      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
+        point = target.GetBestKnownSolution(dimension);
+        actual = target.Evaluate(point);
         Assert.AreEqual(expected, actual);
       }
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/RastriginEvaluatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/RastriginEvaluatorTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/RastriginEvaluatorTest.cs	(revision 14354)
@@ -37,13 +37,11 @@
     [TestProperty("Time", "short")]
     public void RastriginEvaluateFunctionTest() {
-      var privateObject = new PrivateObject(typeof(RastriginEvaluator));
+      RastriginEvaluator target = new RastriginEvaluator();
       RealVector point = null;
-      double expected = (double)privateObject.GetProperty("BestKnownQuality");
+      double expected = target.BestKnownQuality;
       double actual;
-      int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
-      int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
-      for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
-        point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
-        actual = (double)privateObject.Invoke("Evaluate", point);
+      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
+        point = target.GetBestKnownSolution(dimension);
+        actual = target.Evaluate(point);
         Assert.AreEqual(expected, actual);
       }
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/RosenbrockEvaluatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/RosenbrockEvaluatorTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/RosenbrockEvaluatorTest.cs	(revision 14354)
@@ -37,13 +37,11 @@
     [TestProperty("Time", "short")]
     public void RosenbrockEvaluateFunctionTest() {
-      var privateObject = new PrivateObject(typeof(RosenbrockEvaluator));
+      RosenbrockEvaluator target = new RosenbrockEvaluator();
       RealVector point = null;
-      double expected = (double)privateObject.GetProperty("BestKnownQuality");
+      double expected = target.BestKnownQuality;
       double actual;
-      int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
-      int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
-      for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
-        point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
-        actual = (double)privateObject.Invoke("Evaluate", point);
+      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
+        point = target.GetBestKnownSolution(dimension);
+        actual = target.Evaluate(point);
         Assert.AreEqual(expected, actual);
       }
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/SphereEvaluatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/SphereEvaluatorTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/SphereEvaluatorTest.cs	(revision 14354)
@@ -37,13 +37,11 @@
     [TestProperty("Time", "short")]
     public void SphereEvaluateFunctionTest() {
-      var privateObject = new PrivateObject(typeof(SphereEvaluator));
+      SphereEvaluator target = new SphereEvaluator();
       RealVector point = null;
-      double expected = (double)privateObject.GetProperty("BestKnownQuality");
+      double expected = target.BestKnownQuality;
       double actual;
-      int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
-      int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
-      for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
-        point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
-        actual = (double)privateObject.Invoke("Evaluate", point);
+      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
+        point = target.GetBestKnownSolution(dimension);
+        actual = target.Evaluate(point);
         Assert.AreEqual(expected, actual);
       }
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/SumSquaresEvaluatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/SumSquaresEvaluatorTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/SumSquaresEvaluatorTest.cs	(revision 14354)
@@ -37,13 +37,11 @@
     [TestProperty("Time", "short")]
     public void SumSquaresEvaluateFunctionTest() {
-      var privateObject = new PrivateObject(typeof(SumSquaresEvaluator));
+      SumSquaresEvaluator target = new SumSquaresEvaluator();
       RealVector point = null;
-      double expected = (double)privateObject.GetProperty("BestKnownQuality");
+      double expected = target.BestKnownQuality;
       double actual;
-      int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
-      int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
-      for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
-        point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
-        actual = (double)privateObject.Invoke("Evaluate", point);
+      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
+        point = target.GetBestKnownSolution(dimension);
+        actual = target.Evaluate(point);
         Assert.AreEqual(expected, actual);
       }
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/ZakharovEvaluatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/ZakharovEvaluatorTest.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/ZakharovEvaluatorTest.cs	(revision 14354)
@@ -37,13 +37,11 @@
     [TestProperty("Time", "short")]
     public void ZakharovEvaluateFunctionTest() {
-      var privateObject = new PrivateObject(typeof(ZakharovEvaluator));
+      ZakharovEvaluator target = new ZakharovEvaluator();
       RealVector point = null;
-      double expected = (double)privateObject.GetProperty("BestKnownQuality");
+      double expected = target.BestKnownQuality;
       double actual;
-      int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
-      int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
-      for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
-        point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
-        actual = (double)privateObject.Invoke("Evaluate", point);
+      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
+        point = target.GetBestKnownSolution(dimension);
+        actual = target.Evaluate(point);
         Assert.AreEqual(expected, actual);
       }
Index: /trunk/sources/HeuristicLab.Tests/HeuristicLab.Tests.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 14353)
+++ /trunk/sources/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 14354)
@@ -500,4 +500,5 @@
     <Compile Include="HeuristicLab.Collections-3.3\BidirectionalLookupTest.cs" />
     <Compile Include="HeuristicLab.Collections-3.3\ObservableKeyedListTest.cs" />
+    <Compile Include="HeuristicLab.Common-3.3\EnumerableStatisticExtensions.cs" />
     <Compile Include="HeuristicLab.Encodings.BinaryVectorEncoding-3.3\Auxiliary.cs" />
     <Compile Include="HeuristicLab.Encodings.BinaryVectorEncoding-3.3\NPointCrossoverTest.cs" />
@@ -573,5 +574,5 @@
     <Compile Include="HeuristicLab.Problems.DataAnalysis-3.4\OnlineCalculatorPerformanceTest.cs" />
     <Compile Include="HeuristicLab.Problems.DataAnalysis-3.4\StatisticCalculatorsTest.cs" />
-    <Compile Include="HeuristicLab.Problems.DataAnalysis.Symbolic-3.4\DoubleConverter.cs" />
+    <Compile Include="HeuristicLab.Problems.DataAnalysis.Symbolic-3.4\InfixExpressionParserTest.cs" />
     <Compile Include="HeuristicLab.Problems.DataAnalysis.Symbolic-3.4\SymbolicExpressionTreeBottomUpSimilarityCalculatorTest.cs" />
     <Compile Include="HeuristicLab.Problems.DataAnalysis.Symbolic-3.4\SymbolicExpressionTreeMaxCommonSubtreeSimilarityCalculatorTest.cs" />
@@ -684,7 +685,6 @@
     </EmbeddedResource>
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Test References\" />
-  </ItemGroup>  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <ItemGroup />
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
Index: /trunk/sources/HeuristicLab.Visualization.ChartControlsExtensions/3.3/ChartUtil.cs
===================================================================
--- /trunk/sources/HeuristicLab.Visualization.ChartControlsExtensions/3.3/ChartUtil.cs	(revision 14353)
+++ /trunk/sources/HeuristicLab.Visualization.ChartControlsExtensions/3.3/ChartUtil.cs	(revision 14354)
@@ -37,7 +37,7 @@
 
       // if one of the interval ends is a multiple of 5 or 10, change the other interval end to be a multiple as well
-      if (Math.Abs(aMax) >= 5 && aMin.Mod(5).IsAlmost(0) && !(aMax.Mod(5).IsAlmost(0) || aMax.Mod(10).IsAlmost(0))) {
+      if ((aMin.Mod(5).IsAlmost(0) || aMin.Mod(10).IsAlmost(0)) && Math.Abs(aMax) >= 5 && !(aMax.Mod(5).IsAlmost(0) || aMax.Mod(10).IsAlmost(0))) {
         aMax = Math.Min(aMax + 5 - aMax.Mod(5), aMax + 10 - aMax.Mod(10));
-      } else if (Math.Abs(aMin) >= 5 && aMax.Mod(5).IsAlmost(0) && !(aMin.Mod(5).IsAlmost(0) || aMin.Mod(10).IsAlmost(0))) {
+      } else if ((aMax.Mod(5).IsAlmost(0) || aMax.Mod(10).IsAlmost(0)) && Math.Abs(aMin) >= 5 && !(aMin.Mod(5).IsAlmost(0) || aMin.Mod(10).IsAlmost(0))) {
         aMin = Math.Max(aMin - aMin.Mod(5), aMin - aMin.Mod(10));
       }
