Changeset 14354


Ignore:
Timestamp:
10/23/16 19:33:03 (3 years ago)
Author:
bburlacu
Message:

#2685: Revert accidental commit.

Location:
trunk/sources
Files:
2 deleted
49 edited

Legend:

Unmodified
Added
Removed
  • trunk/sources/HeuristicLab.Algorithms.OffspringSelectionGeneticAlgorithm/3.3/OffspringSelectionGeneticAlgorithmMainLoop.cs

    r14353 r14354  
    162162      Comparator maxSelectionPressureComparator = new Comparator();
    163163      Comparator maxEvaluatedSolutionsComparator = new Comparator();
    164       Comparator maxSolutionQualityComparator = new Comparator();
    165164      Placeholder comparisonFactorModifier = new Placeholder();
    166165      Placeholder analyzer2 = new Placeholder();
     
    168167      ConditionalBranch conditionalBranch2 = new ConditionalBranch();
    169168      ConditionalBranch conditionalBranch3 = new ConditionalBranch();
    170       ConditionalBranch conditionalBranch4 = new ConditionalBranch();
    171169
    172170      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class OffspringSelectionGeneticAlgorithm expects this to be called Generations
     
    225223      maxEvaluatedSolutionsComparator.RightSideParameter.ActualName = "MaximumEvaluatedSolutions";
    226224
    227       maxSolutionQualityComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
    228       maxSolutionQualityComparator.LeftSideParameter.ActualName = "MaximumQuality";
    229       maxSolutionQualityComparator.ResultParameter.ActualName = "TerminateMaximumQuality";
    230       maxSolutionQualityComparator.RightSideParameter.ActualName = "BestQuality";
    231 
    232225      comparisonFactorModifier.Name = "Update ComparisonFactor (placeholder)";
    233226      comparisonFactorModifier.OperatorParameter.ActualName = ComparisonFactorModifierParameter.Name;
     
    244237      conditionalBranch3.Name = "MaximumEvaluatedSolutions reached?";
    245238      conditionalBranch3.ConditionParameter.ActualName = "TerminateEvaluatedSolutions";
    246 
    247       conditionalBranch4.Name = "MaximumQuality reached?";
    248       conditionalBranch3.ConditionParameter.ActualName = "TerminateMaximumQuality";
    249239      #endregion
    250240
     
    259249      maxGenerationsComparator.Successor = maxSelectionPressureComparator;
    260250      maxSelectionPressureComparator.Successor = maxEvaluatedSolutionsComparator;
    261       maxEvaluatedSolutionsComparator.Successor = maxSolutionQualityComparator;
    262       maxSolutionQualityComparator.Successor = comparisonFactorModifier;
     251      maxEvaluatedSolutionsComparator.Successor = comparisonFactorModifier;
    263252      comparisonFactorModifier.Successor = analyzer2;
    264253      analyzer2.Successor = conditionalBranch1;
     
    269258      conditionalBranch2.TrueBranch = null;
    270259      conditionalBranch2.Successor = null;
    271       conditionalBranch3.FalseBranch = conditionalBranch4;
     260      conditionalBranch3.FalseBranch = mainOperator;
    272261      conditionalBranch3.TrueBranch = null;
    273262      conditionalBranch3.Successor = null;
    274       conditionalBranch4.FalseBranch = mainOperator;
    275       conditionalBranch4.TrueBranch = null;
    276       conditionalBranch4.Successor = null;
    277263      #endregion
    278264    }
  • trunk/sources/HeuristicLab.Analysis/3.3/PopulationSimilarityAnalysis/PopulationSimilarityAnalyzer.cs

    r14353 r14354  
    136136      var similarityCalculators = SimilarityCalculatorParameter.ValidValues;
    137137      foreach (var similarityCalculator in similarityCalculators) {
    138         if (similarityCalculator == null) continue;
    139138        similarityCalculator.ExecuteInParallel = ExecuteInParallel;
    140139        similarityCalculator.MaxDegreeOfParallelism = MaxDegreeOfParallelism;
  • trunk/sources/HeuristicLab.Clients.Hive.Slave/3.3/Manager/ConfigManager.cs

    r14353 r14354  
    7070      slave.Name = Environment.MachineName;
    7171      if (Settings.Default.NrOfCoresToScavenge < 1 || Settings.Default.NrOfCoresToScavenge > Environment.ProcessorCount) {
    72         slave.Cores = Environment.ProcessorCount / 2;
     72        slave.Cores = Environment.ProcessorCount;
    7373      } else {
    7474        slave.Cores = Settings.Default.NrOfCoresToScavenge;
  • trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/GrammarUtils.cs

    r14353 r14354  
    6666                continue;
    6767
    68               if (visited.Add(childSymbol))
     68              if (visited.Add(childSymbol)) {
    6969                numberedSymbols.Add(Tuple.Create(childSymbol, ++index));
     70              }
    7071            }
    7172          }
     
    8788            minLength = Math.Min(minLength, oldLength);
    8889          minimumExpressionLengths[symbol.Name] = (int)Math.Min(int.MaxValue, minLength);
    89         }
    90         // correction step for cycles
    91         bool changed = true;
    92         while (changed) {
    93           changed = false;
    94           foreach (var symbol in numberedSymbols.Select(x => x.Item1)) {
    95             long minLength = Enumerable.Range(0, grammar.GetMinimumSubtreeCount(symbol))
    96               .Sum(x => grammar.GetAllowedChildSymbols(symbol, x)
    97               .Min(s => (long)minimumExpressionLengths[s.Name])) + 1;
    98             if (minLength < minimumExpressionLengths[symbol.Name]) {
    99               minimumExpressionLengths[symbol.Name] = (int)Math.Min(minLength, int.MaxValue);
    100               changed = true;
    101             }
    102           }
    10390        }
    10491      }
     
    134121                continue;
    135122
    136               if (visited.Add(childSymbol))
     123              if (visited.Add(childSymbol)) {
    137124                numberedSymbols.Add(Tuple.Create(childSymbol, ++index));
     125              }
    138126            }
    139127          }
     
    144132        // going bottom-up (reverse breadth order), we ensure depths are calculated bottom-up
    145133        foreach (var symbol in numberedSymbols.Select(x => x.Item1)) {
    146           long minDepth = -1;
     134          long minDepth = int.MaxValue;
    147135          for (int argIndex = 0; argIndex < grammar.GetMinimumSubtreeCount(symbol); ++argIndex) {
    148136            long depth = grammar.GetAllowedChildSymbols(symbol, argIndex)
    149137              .Where(x => minimumExpressionDepths.ContainsKey(x.Name))
    150               .Select(x => (long)minimumExpressionDepths[x.Name]).DefaultIfEmpty(int.MaxValue).Min() + 1;
    151             minDepth = Math.Max(minDepth, depth);
     138              .Select(x => minimumExpressionDepths[x.Name]).DefaultIfEmpty(int.MaxValue).Min();
     139            minDepth = Math.Min(minDepth, depth + 1);
    152140          }
    153141          int oldDepth;
     
    155143            minDepth = Math.Min(minDepth, oldDepth);
    156144          minimumExpressionDepths[symbol.Name] = (int)Math.Min(int.MaxValue, minDepth);
    157         }
    158         // correction step for cycles
    159         bool changed = true;
    160         while (changed) {
    161           changed = false;
    162           foreach (var symbol in numberedSymbols.Select(x => x.Item1)) {
    163             long minDepth = Enumerable.Range(0, grammar.GetMinimumSubtreeCount(symbol))
    164               .Max(x => grammar.GetAllowedChildSymbols(symbol, x)
    165               .Min(s => (long)minimumExpressionDepths[s.Name])) + 1;
    166             if (minDepth < minimumExpressionDepths[symbol.Name]) {
    167               minimumExpressionDepths[symbol.Name] = (int)Math.Min(minDepth, int.MaxValue);
    168               changed = true;
    169             }
    170           }
    171145        }
    172146      }
  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs

    r14353 r14354  
    7070      }
    7171      if (errorState != OnlineCalculatorError.None) return double.NaN;
    72       return r * r;
     72      return r*r;
    7373    }
    7474
  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPhenotypicDiversityAnalyzer.cs

    r14353 r14354  
    4242    private const string ProblemDataParameterName = "ProblemData";
    4343    private const string EstimationLimitsParameterName = "EstimationLimits";
    44     private const string ApplyLinearScalingParameterName = "ApplyLinearScaling";
    4544    #endregion
    4645
     
    6160      get { return (IValueLookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
    6261    }
    63     public ILookupParameter<BoolValue> ApplyLinearScalingParameter {
    64       get { return (ILookupParameter<BoolValue>)Parameters[ApplyLinearScalingParameterName]; }
    65     }
    6662    #endregion
    6763
     
    7470      Parameters.Add(new ValueLookupParameter<IRegressionProblemData>(ProblemDataParameterName, "The problem data on which the symbolic data analysis solution should be evaluated."));
    7571      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."));
    76       Parameters.Add(new LookupParameter<BoolValue>(ApplyLinearScalingParameterName, "Whether or not to apply linear scaling to the estimated values"));
    7772      #endregion
    7873
     
    8479    protected SymbolicRegressionPhenotypicDiversityAnalyzer(bool deserializing)
    8580      : base(deserializing) {
    86     }
    87 
    88     [StorableHook(HookType.AfterDeserialization)]
    89     private void AfterDeserialization() {
    90       if (!Parameters.ContainsKey(ApplyLinearScalingParameterName))
    91         Parameters.Add(new LookupParameter<BoolValue>(ApplyLinearScalingParameterName, "Whether or not to apply linear scaling to the estimated values"));
    9281    }
    9382
     
    10998      }
    11099
    111       if (updateCounter.Value != updateInterval) return base.Apply();
    112 
    113       var scopes = ExecutionContext.Scope.SubScopes;
    114       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
    115 
    116       foreach (var scope in scopes.Where(x => !x.Variables.ContainsKey("EstimatedValues"))) {
    117         var tree = (ISymbolicExpressionTree)scope.Variables["SymbolicExpressionTree"].Value;
     100      if (updateCounter.Value == updateInterval) {
     101        var trees = SymbolicExpressionTreeParameter.ActualValue;
    118102        var interpreter = SymbolicDataAnalysisTreeInterpreterParameter.ActualValue;
    119103        var ds = ProblemDataParameter.ActualValue.Dataset;
    120104        var rows = ProblemDataParameter.ActualValue.TrainingIndices;
    121         var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(tree, ds, rows).ToArray();
    122105
    123         var estimationLimits = EstimationLimitsParameter.ActualValue;
    124 
    125         if (applyLinearScaling) {
    126           var linearScalingCalculator = new OnlineLinearScalingParameterCalculator();
    127           var targetValues = ds.GetDoubleValues(ProblemDataParameter.ActualValue.TargetVariable, rows);
    128           int i = 0;
    129           foreach (var target in targetValues) {
    130             var estimated = estimatedValues[i];
    131             if (!double.IsNaN(estimated) && !double.IsInfinity(estimated))
    132               linearScalingCalculator.Add(estimated, target);
    133             i++;
    134           }
    135           if (linearScalingCalculator.ErrorState == OnlineCalculatorError.None) {
    136             var alpha = linearScalingCalculator.Alpha;
    137             var beta = linearScalingCalculator.Beta;
    138             for (i = 0; i < estimatedValues.Length; ++i) {
    139               estimatedValues[i] = estimatedValues[i] * beta + alpha;
    140             }
    141           }
    142         }
    143         // add estimated values to escope
    144         scope.Variables.Add(new Core.Variable("EstimatedValues", new DoubleArray(estimatedValues.LimitToRange(estimationLimits.Lower, estimationLimits.Upper).ToArray())));
     106        var evaluatedValues = new ItemArray<DoubleArray>(trees.Select(t => new DoubleArray(interpreter.GetSymbolicExpressionTreeValues(t, ds, rows).ToArray())));
     107        EvaluatedValuesParameter.ActualValue = evaluatedValues;
    145108      }
    146109      return base.Apply();
  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeBottomUpSimilarityCalculator.cs

    r14353 r14354  
    6161    }
    6262
    63     public static double CalculateBottomUpSimilarity(ISymbolicExpressionTree t1, ISymbolicExpressionTree t2) {
    64       return new SymbolicExpressionTreeBottomUpSimilarityCalculator().CalculateSimilarity(t1, t2);
    65     }
    66 
    6763    public override double CalculateSolutionSimilarity(IScope leftSolution, IScope rightSolution) {
    6864      if (leftSolution == rightSolution)
     
    7773      var similarity = CalculateSimilarity(t1, t2);
    7874      if (similarity > 1.0)
    79         throw new Exception("Similarity value " + similarity + " cannot be greater than 1");
     75        throw new Exception("Similarity value cannot be greater than 1");
    8076
    8177      return similarity;
  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreePhenotypicSimilarityCalculator.cs

    r14353 r14354  
    9292
    9393      var r2 = error == OnlineCalculatorError.None ? r * r : 0;
     94
     95      if (r2 > 1.0)
     96        r2 = 1.0;
     97
    9498      return r2;
    9599    }
  • trunk/sources/HeuristicLab.Problems.GrammaticalEvolution/3.4/HeuristicLab.Problems.GrammaticalEvolution-3.4.csproj

    r14353 r14354  
    252252    </ProjectReference>
    253253  </ItemGroup>
    254   <ItemGroup>
    255     <Content Include="ArtificialAnt\GEArtificialAntEvaluator.cs" />
    256   </ItemGroup>
    257254  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
    258255  <PropertyGroup>
  • trunk/sources/HeuristicLab.Tests/HeuristicLab-3.3/ContentViewTests.cs

    r14353 r14354  
    2424using HeuristicLab.Common;
    2525using HeuristicLab.MainForm;
     26using HeuristicLab.MainForm.WindowsForms;
    2627using HeuristicLab.PluginInfrastructure;
    2728using Microsoft.VisualStudio.TestTools.UnitTesting;
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/NPointCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Data;
    2423using HeuristicLab.Tests;
     
    3231  [TestClass()]
    3332  public class NPointCrossoverTest {
    34     /// <summary>
    35     ///A test for Cross
    36     ///</summary>
    37     [TestMethod]
    38     [TestCategory("Encodings.BinaryVector")]
    39     [TestProperty("Time", "short")]
    40     public void NPointCrossoverCrossTest() {
    41       var privateObject = new PrivateObject(typeof(NPointCrossover));
    42       ItemArray<BinaryVector> parents;
    43       TestRandom random = new TestRandom();
    44       bool exceptionFired;
    45       // The following test checks if there is an exception when there are more than 2 parents
    46       random.Reset();
    47       parents = new ItemArray<BinaryVector>(new BinaryVector[] { new BinaryVector(5), new BinaryVector(6), new BinaryVector(4) });
    48       exceptionFired = false;
    49       try {
    50         var actual = (BinaryVector)privateObject.Invoke("Cross", random, parents);
    51       }
    52       catch (System.ArgumentException) {
    53         exceptionFired = true;
    54       }
    55       Assert.IsTrue(exceptionFired);
    56       // The following test checks if there is an exception when there are less than 2 parents
    57       random.Reset();
    58       parents = new ItemArray<BinaryVector>(new BinaryVector[] { new BinaryVector(4) });
    59       exceptionFired = false;
    60       try {
    61         var actual = (BinaryVector)privateObject.Invoke("Cross", random, parents);
    62       }
    63       catch (System.ArgumentException) {
    64         exceptionFired = true;
    65       }
    66       Assert.IsTrue(exceptionFired);
    67     }
    68 
    6933    /// <summary>
    7034    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/UniformCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class UniformCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod]
    37     [TestCategory("Encodings.BinaryVector")]
    38     [TestProperty("Time", "short")]
    39     public void SinglePointCrossoverCrossTest() {
    40       var target = new PrivateObject(typeof(UniformCrossover));
    41       ItemArray<BinaryVector> parents;
    42       TestRandom random = new TestRandom();
    43       bool exceptionFired;
    44       // The following test checks if there is an exception when there are more than 2 parents
    45       random.Reset();
    46       parents = new ItemArray<BinaryVector>(new BinaryVector[] { new BinaryVector(5), new BinaryVector(6), new BinaryVector(4) });
    47       exceptionFired = false;
    48       try {
    49         BinaryVector actual;
    50         actual = (BinaryVector)target.Invoke("Cross", random, parents);
    51       }
    52       catch (System.ArgumentException) {
    53         exceptionFired = true;
    54       }
    55       Assert.IsTrue(exceptionFired);
    56       // The following test checks if there is an exception when there are less than 2 parents
    57       random.Reset();
    58       parents = new ItemArray<BinaryVector>(new BinaryVector[] { new BinaryVector(4) });
    59       exceptionFired = false;
    60       try {
    61         BinaryVector actual;
    62         actual = (BinaryVector)target.Invoke("Cross", random, parents);
    63       }
    64       catch (System.ArgumentException) {
    65         exceptionFired = true;
    66       }
    67       Assert.IsTrue(exceptionFired);
    68     }
    69 
    7032    /// <summary>
    7133    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.IntegerVectorEncoding-3.3/DiscreteCrossoverTest.cs

    r14353 r14354  
    3131  [TestClass()]
    3232  public class DiscreteCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod]
    37     [TestCategory("Encodings.IntegerVector")]
    38     [TestProperty("Time", "short")]
    39     public void DiscreteCrossoverCrossTest() {
    40       var privateObject = new PrivateObject(typeof(DiscreteCrossover));
    41       ItemArray<IntegerVector> parents;
    42       TestRandom random = new TestRandom();
    43       bool exceptionFired;
    44       // The following test checks if there is an exception when there are less than 2 parents
    45       random.Reset();
    46       parents = new ItemArray<IntegerVector>(new IntegerVector[] { new IntegerVector(4) });
    47       exceptionFired = false;
    48       try {
    49         var actual = (IntegerVector)privateObject.Invoke("Cross", random, parents);
    50       }
    51       catch (System.ArgumentException) {
    52         exceptionFired = true;
    53       }
    54       Assert.IsTrue(exceptionFired);
    55     }
    56 
    5733    /// <summary>
    5834    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.IntegerVectorEncoding-3.3/SinglePointCrossoverTest.cs

    r14353 r14354  
    3838    [TestProperty("Time", "short")]
    3939    public void SinglePointCrossoverCrossTest() {
    40       var privateObject = new PrivateObject(typeof(SinglePointCrossover));
     40      var target = new PrivateObject(typeof(SinglePointCrossover));
    4141      ItemArray<IntegerVector> parents;
    4242      TestRandom random = new TestRandom();
     
    4747      exceptionFired = false;
    4848      try {
    49         var actual = (IntegerVector)privateObject.Invoke("Cross", random, parents);
     49        IntegerVector actual;
     50        actual = (IntegerVector)target.Invoke("Cross", random, parents);
    5051      }
    5152      catch (System.ArgumentException) {
     
    5859      exceptionFired = false;
    5960      try {
    60         var actual = (IntegerVector)privateObject.Invoke("Cross", random, parents);
     61        IntegerVector actual;
     62        actual = (IntegerVector)target.Invoke("Cross", random, parents);
    6163      }
    6264      catch (System.ArgumentException) {
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CosaCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class CosaCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod]
    37     [TestCategory("Encodings.Permutation")]
    38     [TestProperty("Time", "short")]
    39     public void CosaCrossoverCrossTest() {
    40       TestRandom random = new TestRandom();
    41       var privateObject = new PrivateObject(typeof(CosaCrossover));
    42       // perform a test with more than two parents
    43       random.Reset();
    44       bool exceptionFired = false;
    45       try {
    46         privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
    47           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    48       }
    49       catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CyclicCrossover2Test.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class CyclicCrossover2Test {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod]
    37     [TestCategory("Encodings.Permutation")]
    38     [TestProperty("Time", "short")]
    39     public void CyclicCrossover2CrossTest() {
    40       TestRandom random = new TestRandom();
    41       var privateObject = new PrivateObject(typeof(CyclicCrossover2));
    42       // perform a test with more than two parents
    43       random.Reset();
    44       bool exceptionFired = false;
    45       try {
    46         privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
    47           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    48       }
    49       catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CyclicCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class CyclicCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod]
    37     [TestCategory("Encodings.Permutation")]
    38     [TestProperty("Time", "short")]
    39     public void CyclicCrossoverCrossTest() {
    40       TestRandom random = new TestRandom();
    41       var privateObject = new PrivateObject(typeof(CyclicCrossover));
    42       // perform a test with more than two parents
    43       random.Reset();
    44       bool exceptionFired = false;
    45       try {
    46         privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
    47           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    48       }
    49       catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/EdgeRecombinationCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class EdgeRecombinationCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod]
    37     [TestCategory("Encodings.Permutation")]
    38     [TestProperty("Time", "short")]
    39     public void EdgeRecombinationCrossoverCrossoverCrossTest() {
    40       TestRandom random = new TestRandom();
    41       var privateObject = new PrivateObject(typeof(EdgeRecombinationCrossover));
    42       // perform a test with more than two parents
    43       random.Reset();
    44       bool exceptionFired = false;
    45       try {
    46         privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
    47           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    48       }
    49       catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/MaximalPreservativeCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class MaximalPreservativeCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod]
    37     [TestCategory("Encodings.Permutation")]
    38     [TestProperty("Time", "short")]
    39     public void MaximalPreservativeCrossoverCrossTest() {
    40       TestRandom random = new TestRandom();
    41       var privateObject = new PrivateObject(typeof(MaximalPreservativeCrossover));
    42       // perform a test with more than two parents
    43       random.Reset();
    44       bool exceptionFired = false;
    45       try {
    46         privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
    47           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    48       }
    49       catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderBasedCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class OrderBasedCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod]
    37     [TestCategory("Encodings.Permutation")]
    38     [TestProperty("Time", "short")]
    39     public void OrderBasedCrossoverCrossTest() {
    40       TestRandom random = new TestRandom();
    41       var privateObject = new PrivateObject(typeof(OrderBasedCrossover));
    42       // perform a test with more than two parents
    43       random.Reset();
    44       bool exceptionFired = false;
    45       try {
    46         privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
    47           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    48       }
    49       catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderCrossover2Test.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class OrderCrossover2Test {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod]
    37     [TestCategory("Encodings.Permutation")]
    38     [TestProperty("Time", "short")]
    39     public void OrderCrossover2CrossTest() {
    40       TestRandom random = new TestRandom();
    41       var privateObject = new PrivateObject(typeof(OrderCrossover2));
    42       random.Reset();
    43       bool exceptionFired = false;
    44       try {
    45         privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
    46           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    47       }
    48       catch (System.InvalidOperationException) {
    49         exceptionFired = true;
    50       }
    51       Assert.IsTrue(exceptionFired);
    52     }
    53 
    5432    /// <summary>
    5533    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class OrderCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod]
    37     [TestCategory("Encodings.Permutation")]
    38     [TestProperty("Time", "short")]
    39     public void OrderCrossoverCrossTest() {
    40       TestRandom random = new TestRandom();
    41       var privateObject = new PrivateObject(typeof(OrderCrossover));
    42       // perform a test with more than two parents
    43       random.Reset();
    44       bool exceptionFired = false;
    45       try {
    46         privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
    47           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    48       }
    49       catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/PartiallyMatchedCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class PartiallyMatchedCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod]
    37     [TestCategory("Encodings.Permutation")]
    38     [TestProperty("Time", "short")]
    39     public void PartiallyMatchedCrossTest() {
    40       TestRandom random = new TestRandom();
    41       var privateObject = new PrivateObject(typeof(PartiallyMatchedCrossover));
    42       // perform a test with more than two parents
    43       random.Reset();
    44       bool exceptionFired = false;
    45       try {
    46         privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
    47           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    48       }
    49       catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/PositionBasedCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class PositionBasedCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod]
    37     [TestCategory("Encodings.Permutation")]
    38     [TestProperty("Time", "short")]
    39     public void PositionBasedCrossoverCrossTest() {
    40       TestRandom random = new TestRandom();
    41       var privateObject = new PrivateObject(typeof(PositionBasedCrossover));
    42 
    43       // perform a test with more than two parents
    44       random.Reset();
    45       bool exceptionFired = false;
    46       try {
    47         privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
    48           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4) }));
    49       }
    50       catch (System.InvalidOperationException) {
    51         exceptionFired = true;
    52       }
    53       Assert.IsTrue(exceptionFired);
    54     }
    55 
    5632    /// <summary>
    5733    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/UniformLikeCrossoverTest.cs

    r14353 r14354  
    5454      Assert.IsTrue(Auxiliary.PermutationIsEqualByPosition(expected, actual));
    5555    }
    56 
    57     /// <summary>
    58     ///A test for Cross
    59     ///</summary>
    60     [TestMethod]
    61     [TestCategory("Encodings.Permutation")]
    62     [TestProperty("Time", "short")]
    63     public void UniformLikeCrossoverCrossTest() {
    64       var privateObject = new PrivateObject(typeof(UniformLikeCrossover));
    65       IRandom random = new TestRandom(new int[] { }, new double[] { 0.1, 0.2, 0.3, 0.4 });
    66       random.Reset();
    67       bool exceptionFired = false;
    68       try {
    69         privateObject.Invoke("Cross", random, new ItemArray<Permutation>(new Permutation[] {
    70 
    71           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    72       }
    73       catch (System.InvalidOperationException) {
    74         exceptionFired = true;
    75       }
    76       Assert.IsTrue(exceptionFired);
    77     }
    7856  }
    7957}
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/BlendAlphaBetaCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Data;
    2423using HeuristicLab.Tests;
     
    3231  [TestClass()]
    3332  public class BlendAlphaBetaCrossoverTest {
    34     /// <summary>
    35     ///A test for Cross
    36     ///</summary>
    37     [TestMethod()]
    38     [TestCategory("Encodings.RealVector")]
    39     [TestProperty("Time", "short")]
    40     public void BlendAlphaBetaCrossoverCrossTest() {
    41       var privateObject = new PrivateObject(typeof(BlendAlphaBetaCrossover));
    42       ItemArray<RealVector> parents;
    43       TestRandom random = new TestRandom();
    44       bool exceptionFired;
    45       // The following test checks if there is an exception when there are more than 2 parents
    46       random.Reset();
    47       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(5), new RealVector(6), new RealVector(4) });
    48       exceptionFired = false;
    49       try {
    50         var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    51       }
    52       catch (System.ArgumentException) {
    53         exceptionFired = true;
    54       }
    55       Assert.IsTrue(exceptionFired);
    56       // The following test checks if there is an exception when there are less than 2 parents
    57       random.Reset();
    58       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
    59       exceptionFired = false;
    60       try {
    61         var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    62       }
    63       catch (System.ArgumentException) {
    64         exceptionFired = true;
    65       }
    66       Assert.IsTrue(exceptionFired);
    67     }
    68 
    6933    /// <summary>
    7034    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/BlendAlphaCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Data;
    2423using HeuristicLab.Tests;
     
    3231  [TestClass()]
    3332  public class BlendAlphaCrossoverTest {
    34     /// <summary>
    35     ///A test for Cross
    36     ///</summary>
    37     [TestMethod()]
    38     [TestCategory("Encodings.RealVector")]
    39     [TestProperty("Time", "short")]
    40     public void BlendAlphaCrossoverCrossTest() {
    41       var privateObject = new PrivateObject(typeof(BlendAlphaCrossover));
    42       ItemArray<RealVector> parents;
    43       TestRandom random = new TestRandom();
    44       bool exceptionFired;
    45       // The following test checks if there is an exception when there are more than 2 parents
    46       random.Reset();
    47       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(5), new RealVector(6), new RealVector(4) });
    48       exceptionFired = false;
    49       try {
    50         var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    51       }
    52       catch (System.ArgumentException) {
    53         exceptionFired = true;
    54       }
    55       Assert.IsTrue(exceptionFired);
    56       // The following test checks if there is an exception when there are less than 2 parents
    57       random.Reset();
    58       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
    59       exceptionFired = false;
    60       try {
    61         var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    62       }
    63       catch (System.ArgumentException) {
    64         exceptionFired = true;
    65       }
    66       Assert.IsTrue(exceptionFired);
    67     }
    68 
    6933    /// <summary>
    7034    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/DiscreteCrossoverTest.cs

    r14353 r14354  
    3131  [TestClass()]
    3232  public class DiscreteCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod()]
    37     [TestCategory("Encodings.RealVector")]
    38     [TestProperty("Time", "short")]
    39     public void DiscreteCrossoverCrossTest() {
    40       var privateObject = new PrivateObject(typeof(DiscreteCrossover));
    41       ItemArray<RealVector> parents;
    42       TestRandom random = new TestRandom();
    43       bool exceptionFired;
    44       // The following test checks if there is an exception when there are less than 2 parents
    45       random.Reset();
    46       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
    47       exceptionFired = false;
    48       try {
    49         var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    50       }
    51       catch (System.ArgumentException) {
    52         exceptionFired = true;
    53       }
    54       Assert.IsTrue(exceptionFired);
    55     }
    56 
    5733    /// <summary>
    5834    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/HeuristicCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class HeuristicCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod()]
    37     [TestCategory("Encodings.RealVector")]
    38     [TestProperty("Time", "short")]
    39     public void HeuristicCrossoverCrossTest() {
    40       var privateObject = new PrivateObject(typeof(HeuristicCrossover));
    41       ItemArray<RealVector> parents;
    42       TestRandom random = new TestRandom();
    43       bool exceptionFired;
    44       // The following test checks if there is an exception when there are more than 2 parents
    45       random.Reset();
    46       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(5), new RealVector(6), new RealVector(4) });
    47       exceptionFired = false;
    48       try {
    49         var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    50       }
    51       catch (System.ArgumentException) {
    52         exceptionFired = true;
    53       }
    54       Assert.IsTrue(exceptionFired);
    55       // The following test checks if there is an exception when there are less than 2 parents
    56       random.Reset();
    57       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
    58       exceptionFired = false;
    59       try {
    60         var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    61       }
    62       catch (System.ArgumentException) {
    63         exceptionFired = true;
    64       }
    65       Assert.IsTrue(exceptionFired);
    66     }
    67 
    6832    /// <summary>
    6933    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/LocalCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class LocalCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod()]
    37     [TestCategory("Encodings.RealVector")]
    38     [TestProperty("Time", "short")]
    39     public void LocalCrossoverCrossTest() {
    40       var privateObject = new PrivateObject(typeof(LocalCrossover));
    41       ItemArray<RealVector> parents;
    42       TestRandom random = new TestRandom();
    43       bool exceptionFired;
    44       // The following test checks if there is an exception when there are more than 2 parents
    45       random.Reset();
    46       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(5), new RealVector(6), new RealVector(4) });
    47       exceptionFired = false;
    48       try {
    49         var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    50       }
    51       catch (System.ArgumentException) {
    52         exceptionFired = true;
    53       }
    54       Assert.IsTrue(exceptionFired);
    55       // The following test checks if there is an exception when there are less than 2 parents
    56       random.Reset();
    57       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
    58       exceptionFired = false;
    59       try {
    60         var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    61       }
    62       catch (System.ArgumentException) {
    63         exceptionFired = true;
    64       }
    65       Assert.IsTrue(exceptionFired);
    66     }
    67 
    6832    /// <summary>
    6933    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/RandomConvexCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class RandomConvexCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod()]
    37     [TestCategory("Encodings.RealVector")]
    38     [TestProperty("Time", "short")]
    39     public void RandomConvexCrossoverCrossTest() {
    40       var privateObject = new PrivateObject(typeof(RandomConvexCrossover));
    41       ItemArray<RealVector> parents;
    42       TestRandom random = new TestRandom();
    43       bool exceptionFired;
    44       // The following test checks if there is an exception when there are more than 2 parents
    45       random.Reset();
    46       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(5), new RealVector(6), new RealVector(4) });
    47       exceptionFired = false;
    48       try {
    49         var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    50       }
    51       catch (System.ArgumentException) {
    52         exceptionFired = true;
    53       }
    54       Assert.IsTrue(exceptionFired);
    55       // The following test checks if there is an exception when there are less than 2 parents
    56       random.Reset();
    57       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
    58       exceptionFired = false;
    59       try {
    60         var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    61       }
    62       catch (System.ArgumentException) {
    63         exceptionFired = true;
    64       }
    65       Assert.IsTrue(exceptionFired);
    66     }
    67 
    6832    /// <summary>
    6933    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/SimulatedBinaryCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Data;
    2423using HeuristicLab.Tests;
     
    3231  [TestClass()]
    3332  public class SimulatedBinaryCrossoverTest {
    34     /// <summary>
    35     ///A test for Cross
    36     ///</summary>
    37     [TestMethod()]
    38     [TestCategory("Encodings.RealVector")]
    39     [TestProperty("Time", "short")]
    40     public void SimulatedBinaryCrossoverCrossTest() {
    41       var privateObject = new PrivateObject(typeof(SimulatedBinaryCrossover));
    42       ItemArray<RealVector> parents;
    43       TestRandom random = new TestRandom();
    44       bool exceptionFired;
    45       // The following test checks if there is an exception when there are more than 2 parents
    46       random.Reset();
    47       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(5), new RealVector(6), new RealVector(4) });
    48       exceptionFired = false;
    49       try {
    50         RealVector actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    51       }
    52       catch (System.ArgumentException) {
    53         exceptionFired = true;
    54       }
    55       Assert.IsTrue(exceptionFired);
    56       // The following test checks if there is an exception when there are less than 2 parents
    57       random.Reset();
    58       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
    59       exceptionFired = false;
    60       try {
    61         RealVector actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    62       }
    63       catch (System.ArgumentException) {
    64         exceptionFired = true;
    65       }
    66       Assert.IsTrue(exceptionFired);
    67     }
    68 
    6933    /// <summary>
    7034    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/SinglePointCrossoverTest.cs

    r14353 r14354  
    2020#endregion
    2121
    22 using HeuristicLab.Core;
    2322using HeuristicLab.Tests;
    2423using Microsoft.VisualStudio.TestTools.UnitTesting;
     
    3130  [TestClass()]
    3231  public class SinglePointCrossoverTest {
    33     /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod()]
    37     [TestCategory("Encodings.RealVector")]
    38     [TestProperty("Time", "short")]
    39     public void SinglePointCrossoverCrossTest() {
    40       var privateObject = new PrivateObject(typeof(SinglePointCrossover));
    41       ItemArray<RealVector> parents;
    42       TestRandom random = new TestRandom();
    43       bool exceptionFired;
    44       // The following test checks if there is an exception when there are more than 2 parents
    45       random.Reset();
    46       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(5), new RealVector(6), new RealVector(4) });
    47       exceptionFired = false;
    48       try {
    49         var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    50       }
    51       catch (System.ArgumentException) {
    52         exceptionFired = true;
    53       }
    54       Assert.IsTrue(exceptionFired);
    55       // The following test checks if there is an exception when there are less than 2 parents
    56       random.Reset();
    57       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(4) });
    58       exceptionFired = false;
    59       try {
    60         var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    61       }
    62       catch (System.ArgumentException) {
    63         exceptionFired = true;
    64       }
    65       Assert.IsTrue(exceptionFired);
    66       // The following test checks if there is an exception when the vector has just one dimension
    67       random.Reset();
    68       parents = new ItemArray<RealVector>(new RealVector[] { new RealVector(1) });
    69       exceptionFired = false;
    70       try {
    71         var actual = (RealVector)privateObject.Invoke("Cross", random, parents);
    72       }
    73       catch (System.ArgumentException) {
    74         exceptionFired = true;
    75       }
    76       Assert.IsTrue(exceptionFired);
    77     }
    78 
    7932    /// <summary>
    8033    ///A test for Apply
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4/GrammarsTest.cs

    r14353 r14354  
    8686        Assert.AreEqual(3, grammar.GetMinimumExpressionLength(x));
    8787        Assert.AreEqual(2, grammar.GetMinimumExpressionLength(y));
    88       }
    89 
    90       {
    91         var grammar = CreateTestGrammar6();
    92         var prs = grammar.ProgramRootSymbol;
    93         var ss = grammar.StartSymbol;
    94         var x = grammar.Symbols.First(s => s.Name == "<x>");
    95         var s_ = grammar.Symbols.First(s => s.Name == "<s>");
    96         var a = grammar.Symbols.First(s => s.Name == "<a>");
    97         var b = grammar.Symbols.First(s => s.Name == "<b>");
    98         var c = grammar.Symbols.First(s => s.Name == "<c>");
    99         var d = grammar.Symbols.First(s => s.Name == "<d>");
    100         Assert.AreEqual(4, grammar.GetMinimumExpressionLength(prs));
    101         Assert.AreEqual(3, grammar.GetMinimumExpressionLength(ss));
    102         Assert.AreEqual(2, grammar.GetMinimumExpressionLength(x));
    103         Assert.AreEqual(5, grammar.GetMinimumExpressionLength(s_));
    104         Assert.AreEqual(4, grammar.GetMinimumExpressionLength(a));
    105         Assert.AreEqual(3, grammar.GetMinimumExpressionLength(b));
    106         Assert.AreEqual(4, grammar.GetMinimumExpressionLength(c));
    107         Assert.AreEqual(3, grammar.GetMinimumExpressionLength(d));
    10888      }
    10989    }
     
    190170        Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(y));
    191171      }
    192 
    193       {
    194         var grammar = CreateTestGrammar6();
    195         var prs = grammar.ProgramRootSymbol;
    196         var ss = grammar.StartSymbol;
    197         var x = grammar.Symbols.First(s => s.Name == "<x>");
    198         var s_ = grammar.Symbols.First(s => s.Name == "<s>");
    199         var a = grammar.Symbols.First(s => s.Name == "<a>");
    200         var b = grammar.Symbols.First(s => s.Name == "<b>");
    201         var c = grammar.Symbols.First(s => s.Name == "<c>");
    202         var d = grammar.Symbols.First(s => s.Name == "<d>");
    203         Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(prs));
    204         Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(ss));
    205         Assert.AreEqual(2, grammar.GetMinimumExpressionDepth(x));
    206         Assert.AreEqual(5, grammar.GetMinimumExpressionDepth(s_));
    207         Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(a));
    208         Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(b));
    209         Assert.AreEqual(4, grammar.GetMinimumExpressionDepth(c));
    210         Assert.AreEqual(3, grammar.GetMinimumExpressionDepth(d));
    211       }
    212172    }
    213173
     
    326286      return grammar;
    327287    }
    328 
    329     private static ISymbolicExpressionGrammar CreateTestGrammar6() {
    330       var grammar = new SimpleSymbolicExpressionGrammar();
    331       var x = new SimpleSymbol("<x>", 1);
    332       var s = new SimpleSymbol("<s>", 1);
    333       var a = new SimpleSymbol("<a>", 1);
    334       var b = new SimpleSymbol("<b>", 1);
    335       var c = new SimpleSymbol("<c>", 1);
    336       var d = new SimpleSymbol("<d>", 1);
    337       var e = new SimpleSymbol("<e>", 1);
    338 
    339       var _x = new SimpleSymbol("x", 0);
    340       var _y = new SimpleSymbol("y", 0);
    341 
    342       grammar.AddSymbol(x);
    343       grammar.AddSymbol(s);
    344       grammar.AddSymbol(a);
    345       grammar.AddSymbol(b);
    346       grammar.AddSymbol(c);
    347       grammar.AddSymbol(d);
    348       grammar.AddSymbol(e);
    349       grammar.AddSymbol(_x);
    350       grammar.AddSymbol(_y);
    351 
    352       grammar.AddAllowedChildSymbol(grammar.StartSymbol, x);
    353       grammar.AddAllowedChildSymbol(x, s);
    354       grammar.AddAllowedChildSymbol(x, _x);
    355       grammar.AddAllowedChildSymbol(s, a);
    356       grammar.AddAllowedChildSymbol(a, b);
    357       grammar.AddAllowedChildSymbol(a, c);
    358       grammar.AddAllowedChildSymbol(b, x);
    359       grammar.AddAllowedChildSymbol(c, d);
    360       grammar.AddAllowedChildSymbol(d, e);
    361       grammar.AddAllowedChildSymbol(e, _y);
    362 
    363       return grammar;
    364     }
    365288  }
    366289}
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionTreeInterpreterTest.cs

    r14353 r14354  
    3333  public class SymbolicDataAnalysisExpressionTreeInterpreterTest {
    3434    private const int N = 1000;
    35     private const int Rows = 5000;
     35    private const int Rows = 1000;
    3636    private const int Columns = 50;
    3737
     
    7373    [TestCategory("Problems.DataAnalysis.Symbolic")]
    7474    [TestProperty("Time", "long")]
     75    public void CompiledInterpreterTestTypeCoherentGrammarPerformance() {
     76      TestTypeCoherentGrammarPerformance(new SymbolicDataAnalysisExpressionCompiledTreeInterpreter(), 12.5e6);
     77    }
     78    [TestMethod]
     79    [TestCategory("Problems.DataAnalysis.Symbolic")]
     80    [TestProperty("Time", "long")]
     81    public void CompiledInterpreterTestFullGrammarPerformance() {
     82      TestFullGrammarPerformance(new SymbolicDataAnalysisExpressionCompiledTreeInterpreter(), 12.5e6);
     83    }
     84    [TestMethod]
     85    [TestCategory("Problems.DataAnalysis.Symbolic")]
     86    [TestProperty("Time", "long")]
     87    public void CompiledInterpreterTestArithmeticGrammarPerformance() {
     88      TestArithmeticGrammarPerformance(new SymbolicDataAnalysisExpressionCompiledTreeInterpreter(), 12.5e6);
     89    }
     90
     91    [TestMethod]
     92    [TestCategory("Problems.DataAnalysis.Symbolic")]
     93    [TestProperty("Time", "long")]
    7594    public void ILEmittingInterpreterTestTypeCoherentGrammarPerformance() {
    7695      TestTypeCoherentGrammarPerformance(new SymbolicDataAnalysisExpressionTreeILEmittingInterpreter(), 7.5e6);
     
    166185    [TestCategory("Problems.DataAnalysis.Symbolic")]
    167186    [TestProperty("Time", "short")]
     187    public void CompiledInterpreterTestEvaluation() {
     188      var interpreter = new SymbolicDataAnalysisExpressionCompiledTreeInterpreter();
     189      // ADFs are not supported by the compiled tree interpreter
     190      EvaluateTerminals(interpreter, ds);
     191      EvaluateOperations(interpreter, ds);
     192      EvaluateSpecialFunctions(interpreter, ds);
     193    }
     194
     195    [TestMethod]
     196    [TestCategory("Problems.DataAnalysis.Symbolic")]
     197    [TestProperty("Time", "short")]
    168198    public void LinearInterpreterTestEvaluation() {
    169199      var interpreter = new SymbolicDataAnalysisExpressionTreeLinearInterpreter();
     
    239269
    240270      var interpreters = new ISymbolicDataAnalysisExpressionTreeInterpreter[] {
     271        new SymbolicDataAnalysisExpressionCompiledTreeInterpreter(),
    241272        new SymbolicDataAnalysisExpressionTreeInterpreter(),
    242273        new SymbolicDataAnalysisExpressionTreeLinearInterpreter(),
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicExpressionTreeBottomUpSimilarityCalculatorTest.cs

    r14353 r14354  
    1515
    1616    public BottomUpSimilarityCalculatorTest() {
    17       busCalculator = new SymbolicExpressionTreeBottomUpSimilarityCalculator {
    18         //        MatchConstantValues = true,
    19         //        MatchVariableWeights = true
    20       };
     17      busCalculator = new SymbolicExpressionTreeBottomUpSimilarityCalculator();
    2118      importer = new SymbolicExpressionImporter();
    2219    }
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/AckleyEvaluatorTest.cs

    r14353 r14354  
    3737    [TestProperty("Time", "short")]
    3838    public void AckleyEvaluateFunctionTest() {
    39       var privateObject = new PrivateObject(typeof(AckleyEvaluator));
     39      AckleyEvaluator target = new AckleyEvaluator();
    4040      RealVector point = null;
    41       double expected = (double)privateObject.GetProperty("BestKnownQuality");
     41      double expected = target.BestKnownQuality;
    4242      double actual;
    43       int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
    44       int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
    45       for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
    46         point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
    47         actual = (double)privateObject.Invoke("Evaluate", point);
     43      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
     44        point = target.GetBestKnownSolution(dimension);
     45        actual = target.Evaluate(point);
    4846        Assert.AreEqual(expected, actual);
    4947      }
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/BealeEvaluatorTest.cs

    r14353 r14354  
    3737    [TestProperty("Time", "short")]
    3838    public void BealeEvaluateFunctionTest() {
    39       var privateObject = new PrivateObject(typeof(BealeEvaluator));
     39      BealeEvaluator target = new BealeEvaluator();
    4040      RealVector point = null;
    41       double expected = (double)privateObject.GetProperty("BestKnownQuality");
     41      double expected = target.BestKnownQuality;
    4242      double actual;
    43       int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
    44       int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
    45       for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
    46         point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
    47         actual = (double)privateObject.Invoke("Evaluate", point);
     43      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
     44        point = target.GetBestKnownSolution(dimension);
     45        actual = target.Evaluate(point);
    4846        Assert.AreEqual(expected, actual);
    4947      }
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/BoothEvaluatorTest.cs

    r14353 r14354  
    3737    [TestProperty("Time", "short")]
    3838    public void BoothEvaluateFunctionTest() {
    39       var privateObject = new PrivateObject(typeof(BoothEvaluator));
     39      BoothEvaluator target = new BoothEvaluator();
    4040      RealVector point = null;
    41       double expected = (double)privateObject.GetProperty("BestKnownQuality");
     41      double expected = target.BestKnownQuality;
    4242      double actual;
    43       int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
    44       int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
    45       for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
    46         point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
    47         actual = (double)privateObject.Invoke("Evaluate", point);
     43      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
     44        point = target.GetBestKnownSolution(dimension);
     45        actual = target.Evaluate(point);
    4846        Assert.AreEqual(expected, actual);
    4947      }
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/GriewankEvaluatorTest.cs

    r14353 r14354  
    3737    [TestProperty("Time", "short")]
    3838    public void GriewankEvaluateFunctionTest() {
    39       var privateObject = new PrivateObject(typeof(GriewankEvaluator));
     39      GriewankEvaluator target = new GriewankEvaluator();
    4040      RealVector point = null;
    41       double expected = (double)privateObject.GetProperty("BestKnownQuality");
     41      double expected = target.BestKnownQuality;
    4242      double actual;
    43       int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
    44       int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
    45       for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
    46         point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
    47         actual = (double)privateObject.Invoke("Evaluate", point);
     43      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
     44        point = target.GetBestKnownSolution(dimension);
     45        actual = target.Evaluate(point);
    4846        Assert.AreEqual(expected, actual);
    4947      }
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/LevyEvaluatorTest.cs

    r14353 r14354  
    3737    [TestProperty("Time", "short")]
    3838    public void LevyEvaluateFunctionTest() {
    39       var privateObject = new PrivateObject(typeof(LevyEvaluator));
     39      LevyEvaluator target = new LevyEvaluator();
    4040      RealVector point = null;
    41       double expected = (double)privateObject.GetProperty("BestKnownQuality");
     41      double expected = target.BestKnownQuality;
    4242      double actual;
    43       int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
    44       int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
    45       for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
    46         point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
    47         actual = (double)privateObject.Invoke("Evaluate", point);
     43      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
     44        point = target.GetBestKnownSolution(dimension);
     45        actual = target.Evaluate(point);
    4846        Assert.AreEqual(expected, actual);
    4947      }
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/MatyasEvaluatorTest.cs

    r14353 r14354  
    3737    [TestProperty("Time", "short")]
    3838    public void MatyasEvaluateFunctionTest() {
    39       var privateObject = new PrivateObject(typeof(MatyasEvaluator));
     39      MatyasEvaluator target = new MatyasEvaluator();
    4040      RealVector point = null;
    41       double expected = (double)privateObject.GetProperty("BestKnownQuality");
     41      double expected = target.BestKnownQuality;
    4242      double actual;
    43       int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
    44       int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
    45       for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
    46         point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
    47         actual = (double)privateObject.Invoke("Evaluate", point);
     43      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
     44        point = target.GetBestKnownSolution(dimension);
     45        actual = target.Evaluate(point);
    4846        Assert.AreEqual(expected, actual);
    4947      }
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/RastriginEvaluatorTest.cs

    r14353 r14354  
    3737    [TestProperty("Time", "short")]
    3838    public void RastriginEvaluateFunctionTest() {
    39       var privateObject = new PrivateObject(typeof(RastriginEvaluator));
     39      RastriginEvaluator target = new RastriginEvaluator();
    4040      RealVector point = null;
    41       double expected = (double)privateObject.GetProperty("BestKnownQuality");
     41      double expected = target.BestKnownQuality;
    4242      double actual;
    43       int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
    44       int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
    45       for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
    46         point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
    47         actual = (double)privateObject.Invoke("Evaluate", point);
     43      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
     44        point = target.GetBestKnownSolution(dimension);
     45        actual = target.Evaluate(point);
    4846        Assert.AreEqual(expected, actual);
    4947      }
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/RosenbrockEvaluatorTest.cs

    r14353 r14354  
    3737    [TestProperty("Time", "short")]
    3838    public void RosenbrockEvaluateFunctionTest() {
    39       var privateObject = new PrivateObject(typeof(RosenbrockEvaluator));
     39      RosenbrockEvaluator target = new RosenbrockEvaluator();
    4040      RealVector point = null;
    41       double expected = (double)privateObject.GetProperty("BestKnownQuality");
     41      double expected = target.BestKnownQuality;
    4242      double actual;
    43       int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
    44       int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
    45       for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
    46         point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
    47         actual = (double)privateObject.Invoke("Evaluate", point);
     43      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
     44        point = target.GetBestKnownSolution(dimension);
     45        actual = target.Evaluate(point);
    4846        Assert.AreEqual(expected, actual);
    4947      }
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/SphereEvaluatorTest.cs

    r14353 r14354  
    3737    [TestProperty("Time", "short")]
    3838    public void SphereEvaluateFunctionTest() {
    39       var privateObject = new PrivateObject(typeof(SphereEvaluator));
     39      SphereEvaluator target = new SphereEvaluator();
    4040      RealVector point = null;
    41       double expected = (double)privateObject.GetProperty("BestKnownQuality");
     41      double expected = target.BestKnownQuality;
    4242      double actual;
    43       int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
    44       int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
    45       for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
    46         point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
    47         actual = (double)privateObject.Invoke("Evaluate", point);
     43      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
     44        point = target.GetBestKnownSolution(dimension);
     45        actual = target.Evaluate(point);
    4846        Assert.AreEqual(expected, actual);
    4947      }
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/SumSquaresEvaluatorTest.cs

    r14353 r14354  
    3737    [TestProperty("Time", "short")]
    3838    public void SumSquaresEvaluateFunctionTest() {
    39       var privateObject = new PrivateObject(typeof(SumSquaresEvaluator));
     39      SumSquaresEvaluator target = new SumSquaresEvaluator();
    4040      RealVector point = null;
    41       double expected = (double)privateObject.GetProperty("BestKnownQuality");
     41      double expected = target.BestKnownQuality;
    4242      double actual;
    43       int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
    44       int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
    45       for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
    46         point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
    47         actual = (double)privateObject.Invoke("Evaluate", point);
     43      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
     44        point = target.GetBestKnownSolution(dimension);
     45        actual = target.Evaluate(point);
    4846        Assert.AreEqual(expected, actual);
    4947      }
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/ZakharovEvaluatorTest.cs

    r14353 r14354  
    3737    [TestProperty("Time", "short")]
    3838    public void ZakharovEvaluateFunctionTest() {
    39       var privateObject = new PrivateObject(typeof(ZakharovEvaluator));
     39      ZakharovEvaluator target = new ZakharovEvaluator();
    4040      RealVector point = null;
    41       double expected = (double)privateObject.GetProperty("BestKnownQuality");
     41      double expected = target.BestKnownQuality;
    4242      double actual;
    43       int minimumProblemSize = (int)privateObject.GetProperty("MinimumProblemSize");
    44       int maximumProblemSize = (int)privateObject.GetProperty("MaximumProblemSize");
    45       for (int dimension = minimumProblemSize; dimension <= System.Math.Min(10, maximumProblemSize); dimension++) {
    46         point = (RealVector)privateObject.Invoke("GetBestKnownSolution", dimension);
    47         actual = (double)privateObject.Invoke("Evaluate", point);
     43      for (int dimension = target.MinimumProblemSize; dimension <= System.Math.Min(10, target.MaximumProblemSize); dimension++) {
     44        point = target.GetBestKnownSolution(dimension);
     45        actual = target.Evaluate(point);
    4846        Assert.AreEqual(expected, actual);
    4947      }
  • trunk/sources/HeuristicLab.Tests/HeuristicLab.Tests.csproj

    r14353 r14354  
    500500    <Compile Include="HeuristicLab.Collections-3.3\BidirectionalLookupTest.cs" />
    501501    <Compile Include="HeuristicLab.Collections-3.3\ObservableKeyedListTest.cs" />
     502    <Compile Include="HeuristicLab.Common-3.3\EnumerableStatisticExtensions.cs" />
    502503    <Compile Include="HeuristicLab.Encodings.BinaryVectorEncoding-3.3\Auxiliary.cs" />
    503504    <Compile Include="HeuristicLab.Encodings.BinaryVectorEncoding-3.3\NPointCrossoverTest.cs" />
     
    573574    <Compile Include="HeuristicLab.Problems.DataAnalysis-3.4\OnlineCalculatorPerformanceTest.cs" />
    574575    <Compile Include="HeuristicLab.Problems.DataAnalysis-3.4\StatisticCalculatorsTest.cs" />
    575     <Compile Include="HeuristicLab.Problems.DataAnalysis.Symbolic-3.4\DoubleConverter.cs" />
     576    <Compile Include="HeuristicLab.Problems.DataAnalysis.Symbolic-3.4\InfixExpressionParserTest.cs" />
    576577    <Compile Include="HeuristicLab.Problems.DataAnalysis.Symbolic-3.4\SymbolicExpressionTreeBottomUpSimilarityCalculatorTest.cs" />
    577578    <Compile Include="HeuristicLab.Problems.DataAnalysis.Symbolic-3.4\SymbolicExpressionTreeMaxCommonSubtreeSimilarityCalculatorTest.cs" />
     
    684685    </EmbeddedResource>
    685686  </ItemGroup>
    686   <ItemGroup>
    687     <Folder Include="Test References\" />
    688   </ItemGroup>  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
     687  <ItemGroup />
     688  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
    689689  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
    690690       Other similar extension points exist, see Microsoft.Common.targets.
  • trunk/sources/HeuristicLab.Visualization.ChartControlsExtensions/3.3/ChartUtil.cs

    r14353 r14354  
    3737
    3838      // if one of the interval ends is a multiple of 5 or 10, change the other interval end to be a multiple as well
    39       if (Math.Abs(aMax) >= 5 && aMin.Mod(5).IsAlmost(0) && !(aMax.Mod(5).IsAlmost(0) || aMax.Mod(10).IsAlmost(0))) {
     39      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))) {
    4040        aMax = Math.Min(aMax + 5 - aMax.Mod(5), aMax + 10 - aMax.Mod(10));
    41       } else if (Math.Abs(aMin) >= 5 && aMax.Mod(5).IsAlmost(0) && !(aMin.Mod(5).IsAlmost(0) || aMin.Mod(10).IsAlmost(0))) {
     41      } 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))) {
    4242        aMin = Math.Max(aMin - aMin.Mod(5), aMin - aMin.Mod(10));
    4343      }
Note: See TracChangeset for help on using the changeset viewer.