Changeset 13246


Ignore:
Timestamp:
11/18/15 13:01:38 (3 years ago)
Author:
ascheibe
Message:

#2510 merged r13227, r13235, r13236 into stable

Location:
stable
Files:
3 deleted
41 edited
1 copied

Legend:

Unmodified
Added
Removed
  • stable

  • stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding

  • stable/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs

    r12706 r13246  
    7474    }
    7575
     76    public static ISymbolicExpressionTree CreateExpressionTree(IRandom random, ISymbolicExpressionGrammar grammar, int targetLength,
     77      int maxTreeDepth) {
     78      SymbolicExpressionTree tree = new SymbolicExpressionTree();
     79      var rootNode = (SymbolicExpressionTreeTopLevelNode)grammar.ProgramRootSymbol.CreateTreeNode();
     80      if (rootNode.HasLocalParameters) rootNode.ResetLocalParameters(random);
     81      rootNode.SetGrammar(grammar.CreateExpressionTreeGrammar());
     82
     83      var startNode = (SymbolicExpressionTreeTopLevelNode)grammar.StartSymbol.CreateTreeNode();
     84      if (startNode.HasLocalParameters) startNode.ResetLocalParameters(random);
     85      startNode.SetGrammar(grammar.CreateExpressionTreeGrammar());
     86
     87      rootNode.AddSubtree(startNode);
     88      bool success = TryCreateFullTreeFromSeed(random, startNode, targetLength - 2, maxTreeDepth - 1);
     89      if (!success) throw new InvalidOperationException(string.Format("Could not create a tree with target length {0} and max depth {1}", targetLength, maxTreeDepth));
     90
     91      tree.Root = rootNode;
     92      return tree;
     93
     94    }
     95
    7696    private class TreeExtensionPoint {
    7797      public ISymbolicExpressionTreeNode Parent { get; set; }
     
    107127        } else {
    108128          // clean seedNode
    109           while (seedNode.Subtrees.Count() > 0) seedNode.RemoveSubtree(0);
     129          while (seedNode.Subtrees.Any()) seedNode.RemoveSubtree(0);
    110130        }
    111131        // try a different length MAX_TRIES times
  • stable/HeuristicLab.Tests

  • stable/HeuristicLab.Tests/HeuristicLab-3.3/ContentViewTests.cs

    r12009 r13246  
    4545        //check if view can handle null as content by calling OnContentChanged
    4646        IContentView view = (IContentView)Activator.CreateInstance(viewType);
    47         ContentView_Accessor accessor = new ContentView_Accessor(new PrivateObject(view));
     47        var accessor = new PrivateObject(view);
    4848        try {
    49           accessor.OnContentChanged();
     49          accessor.Invoke("OnContentChanged");
    5050        }
    5151        catch (Exception ex) {
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/NPointCrossoverTest.cs

    r12009 r13246  
    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       NPointCrossover_Accessor target = new NPointCrossover_Accessor(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         BinaryVector actual;
    51         actual = target.Cross(random, parents);
    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 = target.Cross(random, parents);
    63       } catch (System.ArgumentException) {
    64         exceptionFired = true;
    65       }
    66       Assert.IsTrue(exceptionFired);
    67     }
    68 
    6933    /// <summary>
    7034    ///A test for Apply
     
    11680      try {
    11781        actual = NPointCrossover.Apply(random, parent1, parent2, n);
    118       } catch (System.ArgumentException) {
     82      }
     83      catch (System.ArgumentException) {
    11984        exceptionFired = true;
    12085      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.BinaryVectorEncoding-3.3/UniformCrossoverTest.cs

    r12009 r13246  
    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       UniformCrossover_Accessor target = new UniformCrossover_Accessor(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 = target.Cross(random, parents);
    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<BinaryVector>(new BinaryVector[] { new BinaryVector(4) });
    58       exceptionFired = false;
    59       try {
    60         BinaryVector actual;
    61         actual = target.Cross(random, parents);
    62       } catch (System.ArgumentException) {
    63         exceptionFired = true;
    64       }
    65       Assert.IsTrue(exceptionFired);
    66     }
    67 
    6832    /// <summary>
    6933    ///A test for Apply
     
    10266      try {
    10367        actual = UniformCrossover.Apply(random, parent1, parent2);
    104       } catch (System.ArgumentException) {
     68      }
     69      catch (System.ArgumentException) {
    10570        exceptionFired = true;
    10671      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.IntegerVectorEncoding-3.3/DiscreteCrossoverTest.cs

    r12009 r13246  
    3232  public class DiscreteCrossoverTest {
    3333    /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod]
    37     [TestCategory("Encodings.IntegerVector")]
    38     [TestProperty("Time", "short")]
    39     public void DiscreteCrossoverCrossTest() {
    40       DiscreteCrossover_Accessor target = new DiscreteCrossover_Accessor(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         IntegerVector actual;
    50         actual = target.Cross(random, parents);
    51       } catch (System.ArgumentException) {
    52         exceptionFired = true;
    53       }
    54       Assert.IsTrue(exceptionFired);
    55     }
    56 
    57     /// <summary>
    5834    ///A test for Apply
    5935    ///</summary>
     
    8258      try {
    8359        actual = DiscreteCrossover.Apply(random, new ItemArray<IntegerVector>(new IntegerVector[] { parent1, parent2 }));
    84       } catch (System.ArgumentException) {
     60      }
     61      catch (System.ArgumentException) {
    8562        exceptionFired = true;
    8663      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.IntegerVectorEncoding-3.3/SinglePointCrossoverTest.cs

    r12009 r13246  
    3838    [TestProperty("Time", "short")]
    3939    public void SinglePointCrossoverCrossTest() {
    40       SinglePointCrossover_Accessor target = new SinglePointCrossover_Accessor(new PrivateObject(typeof(SinglePointCrossover)));
     40      var target = new PrivateObject(typeof(SinglePointCrossover));
    4141      ItemArray<IntegerVector> parents;
    4242      TestRandom random = new TestRandom();
     
    4848      try {
    4949        IntegerVector actual;
    50         actual = target.Cross(random, parents);
    51       } catch (System.ArgumentException) {
     50        actual = (IntegerVector)target.Invoke("Cross", random, parents);
     51      }
     52      catch (System.ArgumentException) {
    5253        exceptionFired = true;
    5354      }
     
    5960      try {
    6061        IntegerVector actual;
    61         actual = target.Cross(random, parents);
    62       } catch (System.ArgumentException) {
     62        actual = (IntegerVector)target.Invoke("Cross", random, parents);
     63      }
     64      catch (System.ArgumentException) {
    6365        exceptionFired = true;
    6466      }
     
    9294      try {
    9395        actual = SinglePointCrossover.Apply(random, parent1, parent2);
    94       } catch (System.ArgumentException) {
     96      }
     97      catch (System.ArgumentException) {
    9598        exceptionFired = true;
    9699      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CosaCrossoverTest.cs

    r12009 r13246  
    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       CosaCrossover_Accessor target =
    42         new CosaCrossover_Accessor(new PrivateObject(typeof(CosaCrossover)));
    43       // perform a test with more than two parents
    44       random.Reset();
    45       bool exceptionFired = false;
    46       try {
    47         target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    48           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    49       } catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
     
    10481      try {
    10582        CosaCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    106       } catch (System.ArgumentException) {
     83      }
     84      catch (System.ArgumentException) {
    10785        exceptionFired = true;
    10886      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CyclicCrossover2Test.cs

    r12009 r13246  
    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       CyclicCrossover2_Accessor target = new CyclicCrossover2_Accessor(new PrivateObject(typeof(CyclicCrossover2)));
    42       // perform a test with more than two parents
    43       random.Reset();
    44       bool exceptionFired = false;
    45       try {
    46         target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    47           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    48       } catch (System.InvalidOperationException) {
    49         exceptionFired = true;
    50       }
    51       Assert.IsTrue(exceptionFired);
    52     }
    53 
    5432    /// <summary>
    5533    ///A test for Apply
     
    7957      try {
    8058        CyclicCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    81       } catch (System.ArgumentException) {
     59      }
     60      catch (System.ArgumentException) {
    8261        exceptionFired = true;
    8362      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/CyclicCrossoverTest.cs

    r12009 r13246  
    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       CyclicCrossover_Accessor target =
    42         new CyclicCrossover_Accessor(new PrivateObject(typeof(CyclicCrossover)));
    43       // perform a test with more than two parents
    44       random.Reset();
    45       bool exceptionFired = false;
    46       try {
    47         target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    48           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    49       } catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
     
    8057      try {
    8158        CyclicCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    82       } catch (System.ArgumentException) {
     59      }
     60      catch (System.ArgumentException) {
    8361        exceptionFired = true;
    8462      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/EdgeRecombinationCrossoverTest.cs

    r12009 r13246  
    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       EdgeRecombinationCrossover_Accessor target =
    42         new EdgeRecombinationCrossover_Accessor(new PrivateObject(typeof(EdgeRecombinationCrossover)));
    43       // perform a test with more than two parents
    44       random.Reset();
    45       bool exceptionFired = false;
    46       try {
    47         target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    48           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    49       } catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
     
    8158      try {
    8259        EdgeRecombinationCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    83       } catch (System.ArgumentException) {
     60      }
     61      catch (System.ArgumentException) {
    8462        exceptionFired = true;
    8563      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/MaximalPreservativeCrossoverTest.cs

    r12009 r13246  
    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       MaximalPreservativeCrossover_Accessor target =
    42         new MaximalPreservativeCrossover_Accessor(new PrivateObject(typeof(MaximalPreservativeCrossover)));
    43       // perform a test with more than two parents
    44       random.Reset();
    45       bool exceptionFired = false;
    46       try {
    47         target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    48           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    49       } catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
     
    8057      try {
    8158        MaximalPreservativeCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    82       } catch (System.ArgumentException) {
     59      }
     60      catch (System.ArgumentException) {
    8361        exceptionFired = true;
    8462      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderBasedCrossoverTest.cs

    r12009 r13246  
    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       OrderBasedCrossover_Accessor target =
    42         new OrderBasedCrossover_Accessor(new PrivateObject(typeof(OrderBasedCrossover)));
    43       // perform a test with more than two parents
    44       random.Reset();
    45       bool exceptionFired = false;
    46       try {
    47         target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    48           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    49       } catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
     
    7855      try {
    7956        OrderBasedCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    80       } catch (System.ArgumentException) {
     57      }
     58      catch (System.ArgumentException) {
    8159        exceptionFired = true;
    8260      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderCrossover2Test.cs

    r12009 r13246  
    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       OrderCrossover2_Accessor target = new OrderCrossover2_Accessor(new PrivateObject(typeof(OrderCrossover2)));
    42       random.Reset();
    43       bool exceptionFired = false;
    44       try {
    45         target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    46           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    47       } catch (System.InvalidOperationException) {
    48         exceptionFired = true;
    49       }
    50       Assert.IsTrue(exceptionFired);
    51     }
    52 
    5332    /// <summary>
    5433    ///A test for Apply
     
    7857      try {
    7958        OrderCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    80       } catch (System.ArgumentException) {
     59      }
     60      catch (System.ArgumentException) {
    8161        exceptionFired = true;
    8262      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/OrderCrossoverTest.cs

    r12009 r13246  
    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       OrderCrossover_Accessor target =
    42         new OrderCrossover_Accessor(new PrivateObject(typeof(OrderCrossover)));
    43       // perform a test with more than two parents
    44       random.Reset();
    45       bool exceptionFired = false;
    46       try {
    47         target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    48           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    49       } catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
     
    131108      try {
    132109        OrderCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    133       } catch (System.ArgumentException) {
     110      }
     111      catch (System.ArgumentException) {
    134112        exceptionFired = true;
    135113      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/PartiallyMatchedCrossoverTest.cs

    r12009 r13246  
    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       PartiallyMatchedCrossover_Accessor target =
    42         new PartiallyMatchedCrossover_Accessor(new PrivateObject(typeof(PartiallyMatchedCrossover)));
    43       // perform a test with more than two parents
    44       random.Reset();
    45       bool exceptionFired = false;
    46       try {
    47         target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    48           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    49       } catch (System.InvalidOperationException) {
    50         exceptionFired = true;
    51       }
    52       Assert.IsTrue(exceptionFired);
    53     }
    54 
    5532    /// <summary>
    5633    ///A test for Apply
     
    9269      try {
    9370        PartiallyMatchedCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    94       } catch (System.ArgumentException) {
     71      }
     72      catch (System.ArgumentException) {
    9573        exceptionFired = true;
    9674      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/PositionBasedCrossoverTest.cs

    r12009 r13246  
    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       PositionBasedCrossover_Accessor target = new PositionBasedCrossover_Accessor(
    42         new PrivateObject(typeof(PositionBasedCrossover)));
    43 
    44       // perform a test with more than two parents
    45       random.Reset();
    46       bool exceptionFired = false;
    47       try {
    48         target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    49           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4) }));
    50       } catch (System.InvalidOperationException) {
    51         exceptionFired = true;
    52       }
    53       Assert.IsTrue(exceptionFired);
    54     }
    55 
    5632    /// <summary>
    5733    ///A test for Apply
     
    8359      try {
    8460        PositionBasedCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
    85       } catch (System.ArgumentException) {
     61      }
     62      catch (System.ArgumentException) {
    8663        exceptionFired = true;
    8764      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.PermutationEncoding-3.3/UniformLikeCrossoverTest.cs

    r12009 r13246  
    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       UniformLikeCrossover_Accessor target = new UniformLikeCrossover_Accessor();
    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         target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
    70           new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
    71       } catch (System.InvalidOperationException) {
    72         exceptionFired = true;
    73       }
    74       Assert.IsTrue(exceptionFired);
    75     }
    7656  }
    7757}
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/BlendAlphaBetaCrossoverTest.cs

    r12009 r13246  
    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       BlendAlphaBetaCrossover_Accessor target = new BlendAlphaBetaCrossover_Accessor(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         RealVector actual;
    51         actual = target.Cross(random, parents);
    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;
    62         actual = target.Cross(random, parents);
    63       } catch (System.ArgumentException) {
    64         exceptionFired = true;
    65       }
    66       Assert.IsTrue(exceptionFired);
    67     }
    68 
    6933    /// <summary>
    7034    ///A test for Apply
     
    9862      try {
    9963        actual = BlendAlphaBetaCrossover.Apply(random, parent1, parent2, alpha, beta);
    100       } catch (System.ArgumentException) {
     64      }
     65      catch (System.ArgumentException) {
    10166        exceptionFired = true;
    10267      }
     
    11176      try {
    11277        actual = BlendAlphaBetaCrossover.Apply(random, parent1, parent2, alpha, beta);
    113       } catch (System.ArgumentException) {
     78      }
     79      catch (System.ArgumentException) {
    11480        exceptionFired = true;
    11581      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/BlendAlphaCrossoverTest.cs

    r12009 r13246  
    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       BlendAlphaCrossover_Accessor target = new BlendAlphaCrossover_Accessor(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         RealVector actual;
    51         actual = target.Cross(random, parents);
    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;
    62         actual = target.Cross(random, parents);
    63       } catch (System.ArgumentException) {
    64         exceptionFired = true;
    65       }
    66       Assert.IsTrue(exceptionFired);
    67     }
    68 
    6933    /// <summary>
    7034    ///A test for Apply
     
    10670      try {
    10771        actual = BlendAlphaCrossover.Apply(random, parent1, parent2, alpha);
    108       } catch (System.ArgumentException) {
     72      }
     73      catch (System.ArgumentException) {
    10974        exceptionFired = true;
    11075      }
     
    12085      try {
    12186        actual = BlendAlphaCrossover.Apply(random, parent1, parent2, alpha);
    122       } catch (System.ArgumentException) {
     87      }
     88      catch (System.ArgumentException) {
    12389        exceptionFired = true;
    12490      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/DiscreteCrossoverTest.cs

    r12009 r13246  
    3232  public class DiscreteCrossoverTest {
    3333    /// <summary>
    34     ///A test for Cross
    35     ///</summary>
    36     [TestMethod()]
    37     [TestCategory("Encodings.RealVector")]
    38     [TestProperty("Time", "short")]
    39     public void DiscreteCrossoverCrossTest() {
    40       DiscreteCrossover_Accessor target = new DiscreteCrossover_Accessor(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         RealVector actual;
    50         actual = target.Cross(random, parents);
    51       } catch (System.ArgumentException) {
    52         exceptionFired = true;
    53       }
    54       Assert.IsTrue(exceptionFired);
    55     }
    56 
    57     /// <summary>
    5834    ///A test for Apply
    5935    ///</summary>
     
    8460      try {
    8561        actual = DiscreteCrossover.Apply(random, parents);
    86       } catch (System.ArgumentException) {
     62      }
     63      catch (System.ArgumentException) {
    8764        exceptionFired = true;
    8865      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/HeuristicCrossoverTest.cs

    r12009 r13246  
    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       HeuristicCrossover_Accessor target = new HeuristicCrossover_Accessor(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         RealVector actual;
    50         actual = target.Cross(random, parents);
    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         RealVector actual;
    61         actual = target.Cross(random, parents);
    62       } catch (System.ArgumentException) {
    63         exceptionFired = true;
    64       }
    65       Assert.IsTrue(exceptionFired);
    66     }
    67 
    6832    /// <summary>
    6933    ///A test for Apply
     
    9256      try {
    9357        actual = HeuristicCrossover.Apply(random, parent1, parent2);
    94       } catch (System.ArgumentException) {
     58      }
     59      catch (System.ArgumentException) {
    9560        exceptionFired = true;
    9661      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/LocalCrossoverTest.cs

    r12009 r13246  
    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       LocalCrossover_Accessor target = new LocalCrossover_Accessor(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         RealVector actual;
    50         actual = target.Cross(random, parents);
    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         RealVector actual;
    61         actual = target.Cross(random, parents);
    62       } catch (System.ArgumentException) {
    63         exceptionFired = true;
    64       }
    65       Assert.IsTrue(exceptionFired);
    66     }
    67 
    6832    /// <summary>
    6933    ///A test for Apply
     
    9256      try {
    9357        actual = LocalCrossover.Apply(random, parent1, parent2);
    94       } catch (System.ArgumentException) {
     58      }
     59      catch (System.ArgumentException) {
    9560        exceptionFired = true;
    9661      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/RandomConvexCrossoverTest.cs

    r12009 r13246  
    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       RandomConvexCrossover_Accessor target = new RandomConvexCrossover_Accessor(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         RealVector actual;
    50         actual = target.Cross(random, parents);
    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         RealVector actual;
    61         actual = target.Cross(random, parents);
    62       } catch (System.ArgumentException) {
    63         exceptionFired = true;
    64       }
    65       Assert.IsTrue(exceptionFired);
    66     }
    67 
    6832    /// <summary>
    6933    ///A test for Apply
     
    9256      try {
    9357        actual = RandomConvexCrossover.Apply(random, parent1, parent2);
    94       } catch (System.ArgumentException) {
     58      }
     59      catch (System.ArgumentException) {
    9560        exceptionFired = true;
    9661      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/SimulatedBinaryCrossoverTest.cs

    r12009 r13246  
    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       SimulatedBinaryCrossover_Accessor target = new SimulatedBinaryCrossover_Accessor(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;
    51         actual = target.Cross(random, parents);
    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;
    62         actual = target.Cross(random, parents);
    63       } catch (System.ArgumentException) {
    64         exceptionFired = true;
    65       }
    66       Assert.IsTrue(exceptionFired);
    67     }
    68 
    6933    /// <summary>
    7034    ///A test for Apply
     
    9660      try {
    9761        actual = SimulatedBinaryCrossover.Apply(random, parent1, parent2, contiguity);
    98       } catch (System.ArgumentException) {
     62      }
     63      catch (System.ArgumentException) {
    9964        exceptionFired = true;
    10065      }
     
    10974      try {
    11075        actual = SimulatedBinaryCrossover.Apply(random, parent1, parent2, contiguity);
    111       } catch (System.ArgumentException) {
     76      }
     77      catch (System.ArgumentException) {
    11278        exceptionFired = true;
    11379      }
  • stable/HeuristicLab.Tests/HeuristicLab.Encodings.RealVectorEncoding-3.3/SinglePointCrossoverTest.cs

    r12009 r13246  
    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       SinglePointCrossover_Accessor target = new SinglePointCrossover_Accessor(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         RealVector actual;
    50         actual = target.Cross(random, parents);
    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         RealVector actual;
    61         actual = target.Cross(random, parents);
    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         RealVector actual;
    72         actual = target.Cross(random, parents);
    73       } catch (System.ArgumentException) {
    74         exceptionFired = true;
    75       }
    76       Assert.IsTrue(exceptionFired);
    77     }
    78 
    7932    /// <summary>
    8033    ///A test for Apply
     
    10356      try {
    10457        actual = SinglePointCrossover.Apply(random, parent1, parent2);
    105       } catch (System.ArgumentException) {
     58      }
     59      catch (System.ArgumentException) {
    10660        exceptionFired = true;
    10761      }
  • stable/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis-3.4/OnlineCalculatorPerformanceTest.cs

    r12009 r13246  
    7979    [TestProperty("Time", "medium")]
    8080    public void OnlinePearsonsRSquaredCalculatorPerformanceTest() {
    81       TestCalculatorPerfomance(OnlinePearsonsRSquaredCalculator.Calculate);
     81      TestCalculatorPerfomance(OnlinePearsonsRCalculator.Calculate);
    8282    }
    8383
  • stable/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/AckleyEvaluatorTest.cs

    r12009 r13246  
    3737    [TestProperty("Time", "short")]
    3838    public void AckleyEvaluateFunctionTest() {
    39       AckleyEvaluator_Accessor target = new AckleyEvaluator_Accessor();
     39      AckleyEvaluator target = new AckleyEvaluator();
    4040      RealVector point = null;
    4141      double expected = target.BestKnownQuality;
  • stable/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/BealeEvaluatorTest.cs

    r12009 r13246  
    3737    [TestProperty("Time", "short")]
    3838    public void BealeEvaluateFunctionTest() {
    39       BealeEvaluator_Accessor target = new BealeEvaluator_Accessor();
     39      BealeEvaluator target = new BealeEvaluator();
    4040      RealVector point = null;
    4141      double expected = target.BestKnownQuality;
  • stable/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/BoothEvaluatorTest.cs

    r12009 r13246  
    3737    [TestProperty("Time", "short")]
    3838    public void BoothEvaluateFunctionTest() {
    39       BoothEvaluator_Accessor target = new BoothEvaluator_Accessor();
     39      BoothEvaluator target = new BoothEvaluator();
    4040      RealVector point = null;
    4141      double expected = target.BestKnownQuality;
  • stable/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/GriewankEvaluatorTest.cs

    r12009 r13246  
    3737    [TestProperty("Time", "short")]
    3838    public void GriewankEvaluateFunctionTest() {
    39       GriewankEvaluator_Accessor target = new GriewankEvaluator_Accessor();
     39      GriewankEvaluator target = new GriewankEvaluator();
    4040      RealVector point = null;
    4141      double expected = target.BestKnownQuality;
  • stable/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/LevyEvaluatorTest.cs

    r12009 r13246  
    3737    [TestProperty("Time", "short")]
    3838    public void LevyEvaluateFunctionTest() {
    39       LevyEvaluator_Accessor target = new LevyEvaluator_Accessor();
     39      LevyEvaluator target = new LevyEvaluator();
    4040      RealVector point = null;
    4141      double expected = target.BestKnownQuality;
  • stable/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/MatyasEvaluatorTest.cs

    r12009 r13246  
    3737    [TestProperty("Time", "short")]
    3838    public void MatyasEvaluateFunctionTest() {
    39       MatyasEvaluator_Accessor target = new MatyasEvaluator_Accessor();
     39      MatyasEvaluator target = new MatyasEvaluator();
    4040      RealVector point = null;
    4141      double expected = target.BestKnownQuality;
  • stable/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/RastriginEvaluatorTest.cs

    r12009 r13246  
    3737    [TestProperty("Time", "short")]
    3838    public void RastriginEvaluateFunctionTest() {
    39       RastriginEvaluator_Accessor target = new RastriginEvaluator_Accessor();
     39      RastriginEvaluator target = new RastriginEvaluator();
    4040      RealVector point = null;
    4141      double expected = target.BestKnownQuality;
  • stable/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/RosenbrockEvaluatorTest.cs

    r12009 r13246  
    3737    [TestProperty("Time", "short")]
    3838    public void RosenbrockEvaluateFunctionTest() {
    39       RosenbrockEvaluator_Accessor target = new RosenbrockEvaluator_Accessor();
     39      RosenbrockEvaluator target = new RosenbrockEvaluator();
    4040      RealVector point = null;
    4141      double expected = target.BestKnownQuality;
  • stable/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/SphereEvaluatorTest.cs

    r12009 r13246  
    3737    [TestProperty("Time", "short")]
    3838    public void SphereEvaluateFunctionTest() {
    39       SphereEvaluator_Accessor target = new SphereEvaluator_Accessor();
     39      SphereEvaluator target = new SphereEvaluator();
    4040      RealVector point = null;
    4141      double expected = target.BestKnownQuality;
  • stable/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/SumSquaresEvaluatorTest.cs

    r12009 r13246  
    3737    [TestProperty("Time", "short")]
    3838    public void SumSquaresEvaluateFunctionTest() {
    39       SumSquaresEvaluator_Accessor target = new SumSquaresEvaluator_Accessor();
     39      SumSquaresEvaluator target = new SumSquaresEvaluator();
    4040      RealVector point = null;
    4141      double expected = target.BestKnownQuality;
  • stable/HeuristicLab.Tests/HeuristicLab.Problems.TestFunctions-3.3/ZakharovEvaluatorTest.cs

    r12009 r13246  
    3737    [TestProperty("Time", "short")]
    3838    public void ZakharovEvaluateFunctionTest() {
    39       ZakharovEvaluator_Accessor target = new ZakharovEvaluator_Accessor();
     39      ZakharovEvaluator target = new ZakharovEvaluator();
    4040      RealVector point = null;
    4141      double expected = target.BestKnownQuality;
  • stable/HeuristicLab.Tests/HeuristicLab.Tests.csproj

    r13148 r13246  
    471471    <Compile Include="HeuristicLab.Encodings.BinaryVectorEncoding-3.3\Auxiliary.cs" />
    472472    <Compile Include="HeuristicLab.Encodings.BinaryVectorEncoding-3.3\NPointCrossoverTest.cs" />
    473     <Compile Include="HeuristicLab.Encodings.BinaryVectorEncoding-3.3\SinglePointCrossoverTest.cs" />
    474473    <Compile Include="HeuristicLab.Encodings.BinaryVectorEncoding-3.3\SinglePositionBitflipManipulatorTest.cs" />
    475474    <Compile Include="HeuristicLab.Encodings.BinaryVectorEncoding-3.3\SomePositionsBitflipManipulatorTest.cs" />
     
    528527    <Compile Include="HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4\Grammars.cs" />
    529528    <Compile Include="HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4\GrowTreeCreatorTest.cs" />
    530     <Compile Include="HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4\ProbabilisticTreeCreaterTest.cs" />
     529    <Compile Include="HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4\ProbabilisticTreeCreatorTest.cs" />
    531530    <Compile Include="HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4\ReplaceBranchManipulationTest.cs" />
    532531    <Compile Include="HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4\SubroutineCreaterTest.cs" />
     
    617616    </None>
    618617    <None Include="HeuristicLab.snk" />
    619     <None Include="Test References\HeuristicLab.PluginInfrastructure-3.3.accessor" />
    620618    <None Include="Test Resources\GA_SymbReg.hl">
    621619      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     
    630628      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    631629    </None>
    632     <Shadow Include="Test References\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.accessor" />
    633     <Shadow Include="Test References\HeuristicLab.MainForm.WindowsForms-3.3.accessor" />
    634     <Shadow Include="Test References\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.accessor" />
    635     <Shadow Include="Test References\HeuristicLab.Encodings.RealVectorEncoding-3.3.accessor" />
    636     <Shadow Include="Test References\HeuristicLab.Encodings.BinaryVectorEncoding-3.3.accessor" />
    637     <Shadow Include="Test References\HeuristicLab.Encodings.PermutationEncoding-3.3.accessor" />
    638     <Shadow Include="Test References\HeuristicLab.Problems.TestFunctions-3.3.accessor" />
    639630  </ItemGroup>
    640631  <ItemGroup>
Note: See TracChangeset for help on using the changeset viewer.