Changeset 3060 for trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers

Timestamp:

03/16/10 10:46:59 (15 years ago)

Author:

svonolfe

Message:

Updated the RealVector project to use the new solution encodings (#909)

Location:

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers

Files:

• AverageCrossover.cs (modified) (2 diffs)
• BlendAlphaBetaCrossover.cs (modified) (4 diffs)
• BlendAlphaCrossover.cs (modified) (3 diffs)
• DiscreteCrossover.cs (modified) (4 diffs)
• HeuristicCrossover.cs (modified) (3 diffs)
• LocalCrossover.cs (modified) (3 diffs)
• RandomConvexCrossover.cs (modified) (3 diffs)
• SimulatedBinaryCrossover.cs (modified) (3 diffs)
• SinglePointCrossover.cs (modified) (3 diffs)
• UniformAllPositionsArithmeticCrossover.cs (modified) (3 diffs)
• UniformSomePositionsArithmeticCrossover.cs (modified) (4 diffs)

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/AverageCrossover.cs

@@ -45 +45 @@
     /// <param name="parents">The list of parents.</param>
     /// <returns>The child vector (average) of the parents.</returns>
-    public static DoubleArray Apply(IRandom random, ItemArray<DoubleArray> parents) {
+    public static RealVector Apply(IRandom random, ItemArray<RealVector> parents) {
       int length = parents[0].Length, parentsCount = parents.Length;
       if (parents.Length < 2) throw new ArgumentException("AverageCrossover: The number of parents is less than 2.", "parents");
-      DoubleArray result = new DoubleArray(length);
+      RealVector result = new RealVector(length);
       try {
         double avg;
@@ -65 +65 @@
 
     /// <summary>
-    /// Forwards the call to <see cref="Apply(IRandom, ItemArray<DoubleArray>)"/>.
+    /// Forwards the call to <see cref="Apply(IRandom, ItemArray<RealVector>)"/>.
     /// </summary>
     /// <param name="random">The random number generator.</param>
     /// <param name="parents">The list of parents.</param>
     /// <returns>The child vector (average) of the parents.</returns>
-    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
+    protected override RealVector Cross(IRandom random, ItemArray<RealVector> parents) {
       return Apply(random, parents);
     }

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/BlendAlphaBetaCrossover.cs

@@ -94 +94 @@
     /// <param name="beta">The parameter beta.</param>
     /// <returns>The real vector that results from the crossover.</returns>
-    public static DoubleArray Apply(IRandom random, DoubleArray betterParent, DoubleArray worseParent, DoubleValue alpha, DoubleValue beta) {
+    public static RealVector Apply(IRandom random, RealVector betterParent, RealVector worseParent, DoubleValue alpha, DoubleValue beta) {
       if (betterParent.Length != worseParent.Length) throw new ArgumentException("BlendAlphaBetaCrossover: The parents' vectors are of different length.", "betterParent");
       if (alpha.Value < 0) throw new ArgumentException("BlendAlphaBetaCrossover: Parameter alpha must be greater or equal to 0.", "alpha");
@@ -100 +100 @@
       int length = betterParent.Length;
       double min, max, d;
-      DoubleArray result = new DoubleArray(length);
+      RealVector result = new RealVector(length);
 
       for (int i = 0; i < length; i++) {
@@ -117 +117 @@
 
     /// <summary>
-    /// Checks if the number of parents is equal to 2, if all parameters are available and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArray, DoubleValue, DoubleValue)"/>.
+    /// Checks if the number of parents is equal to 2, if all parameters are available and forwards the call to <see cref="Apply(IRandom, RealVector, RealVector, DoubleValue, DoubleValue)"/>.
     /// </summary>
     /// <exception cref="ArgumentException">Thrown when the number of parents is not equal to 2.</exception>
@@ -132 +132 @@
     /// <param name="parents">The collection of parents (must be of size 2).</param>
     /// <returns>The real vector that results from the crossover.</returns>
-    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
+    protected override RealVector Cross(IRandom random, ItemArray<RealVector> parents) {
       if (parents.Length != 2) throw new ArgumentException("BlendAlphaBetaCrossover: Number of parents is not equal to 2.", "parents");
       if (MaximizationParameter.ActualValue == null) throw new InvalidOperationException("BlendAlphaBetaCrossover: Parameter " + MaximizationParameter.ActualName + " could not be found.");

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/BlendAlphaCrossover.cs

@@ -70 +70 @@
     /// <param name="alpha">The alpha value for the crossover.</param>
     /// <returns>The newly created real vector resulting from the crossover operation.</returns>
-    public static DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2, DoubleValue alpha) {
+    public static RealVector Apply(IRandom random, RealVector parent1, RealVector parent2, DoubleValue alpha) {
       if (parent1.Length != parent2.Length) throw new ArgumentException("BlendAlphaCrossover: The parents' vectors are of different length.", "parent1");
       if (alpha.Value < 0) throw new ArgumentException("BlendAlphaCrossover: Paramter alpha must be greater or equal than 0.", "alpha");
       int length = parent1.Length;
-      DoubleArray result = new DoubleArray(length);
+      RealVector result = new RealVector(length);
       double max = 0, min = 0, d = 0, resMin = 0, resMax = 0;
 
@@ -90 +90 @@
 
     /// <summary>
-    /// Checks that the number of parents is equal to 2 and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArray, DoubleValue)"/>.
+    /// Checks that the number of parents is equal to 2 and forwards the call to <see cref="Apply(IRandom, RealVector, RealVector, DoubleValue)"/>.
     /// </summary>
     /// <exception cref="ArgumentException">Thrown when the number of parents is not equal to 2.</exception>
@@ -97 +97 @@
     /// <param name="parents">The collection of parents (must be of size 2).</param>
     /// <returns>The real vector resulting from the crossover operation.</returns>
-    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
+    protected override RealVector Cross(IRandom random, ItemArray<RealVector> parents) {
       if (parents.Length != 2) throw new ArgumentException("BlendAlphaCrossover: The number of parents is not equal to 2", "parents");
       if (AlphaParameter.ActualValue == null) throw new InvalidOperationException("BlendAlphaCrossover: Parameter " + AlphaParameter.ActualName + " could not be found.");

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/DiscreteCrossover.cs

@@ -45 +45 @@
     /// <param name="parents">An array containing the parents that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    public static DoubleArray Apply(IRandom random, ItemArray<DoubleArray> parents) {
+    public static RealVector Apply(IRandom random, ItemArray<RealVector> parents) {
       int length = parents[0].Length;
       
@@ -53 +53 @@
       }
       
-      DoubleArray result = new DoubleArray(length);
+      RealVector result = new RealVector(length);
       for (int i = 0; i < length; i++) {
         result[i] = parents[random.Next(parents.Length)][i];
@@ -62 +62 @@
 
     /// <summary>
-    /// Checks number of parents and forwards the call to <see cref="Apply(IRandom, ItemArray<DoubleArray>)"/>.
+    /// Checks number of parents and forwards the call to <see cref="Apply(IRandom, ItemArray<RealVector>)"/>.
     /// </summary>
     /// <exception cref="ArgumentException">Thrown when <paramref name="parents"/> contains less than 2 elements.</exception>
@@ -68 +68 @@
     /// <param name="parents">The collection of parents (must be of size 2 or greater).</param>
     /// <returns>The real vector resulting from the crossover.</returns>
-    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
+    protected override RealVector Cross(IRandom random, ItemArray<RealVector> parents) {
       if (parents.Length < 2) throw new ArgumentException("DiscreteCrossover: The number of parents is less than 2.", "parents");
       return Apply(random, parents);

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/HeuristicCrossover.cs

@@ -68 +68 @@
     /// <param name="worseParent">The second parent for the crossover operation.</param>
     /// <returns>The newly created real vector, resulting from the heuristic crossover.</returns>
-    public static DoubleArray Apply(IRandom random, DoubleArray betterParent, DoubleArray worseParent) {
+    public static RealVector Apply(IRandom random, RealVector betterParent, RealVector worseParent) {
       if (betterParent.Length != worseParent.Length)
         throw new ArgumentException("HeuristicCrossover: the two parents are not of the same length");
@@ -79 +79 @@
         result[i] = betterParent[i] + factor * (betterParent[i] - worseParent[i]);
       }
-      return new DoubleArray(result);
+      return new RealVector(result);
     }
 
@@ -96 +96 @@
     /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
+    protected override RealVector Cross(IRandom random, ItemArray<RealVector> parents) {
       if (parents.Length != 2) throw new ArgumentException("HeuristicCrossover: The number of parents is not equal to 2");
 

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/LocalCrossover.cs

@@ -43 +43 @@
     /// <param name="parent2">The second parent for the crossover operation.</param>
     /// <returns>The newly created real vector, resulting from the local crossover.</returns>
-    public static DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2) {
+    public static RealVector Apply(IRandom random, RealVector parent1, RealVector parent2) {
       if (parent1.Length != parent2.Length)
         throw new ArgumentException("LocalCrossover: the two parents are not of the same length");
@@ -55 +55 @@
         result[i] = (factor * parent1[i]) + ((1 - factor) * parent2[i]);
       }
-      return new DoubleArray(result);
+      return new RealVector(result);
     }
 
@@ -65 +65 @@
     /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
+    protected override RealVector Cross(IRandom random, ItemArray<RealVector> parents) {
       if (parents.Length != 2) throw new ArgumentException("LocalCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/RandomConvexCrossover.cs

@@ -43 +43 @@
     /// <param name="parent2">The second parent vector for the crossover.</param>
     /// <returns>The newly created real vector, resulting from the random convex crossover.</returns>
-    public static DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2) {
+    public static RealVector Apply(IRandom random, RealVector parent1, RealVector parent2) {
       if (parent1.Length != parent2.Length)
         throw new ArgumentException("ERROR in RandomConvexCrossover: the two parents are not of the same length");
@@ -53 +53 @@
       for (int i = 0; i < length; i++)
         result[i] = (factor * parent1[i]) + ((1 - factor) * parent2[i]);
-      return new DoubleArray(result);
+      return new RealVector(result);
     }
 
@@ -63 +63 @@
     /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
+    protected override RealVector Cross(IRandom random, ItemArray<RealVector> parents) {
       if (parents.Length != 2) throw new ArgumentException("ERROR in RandomConvexCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/SimulatedBinaryCrossover.cs

@@ -66 +66 @@
     /// <param name="contiguity">The contiguity value that specifies how close a child should be to its parents (larger value means closer). The value must be greater or equal than 0. Typical values are in the range [2;5].</param>
     /// <returns>The vector resulting from the crossover.</returns>
-    public static DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2, DoubleValue contiguity) {
+    public static RealVector Apply(IRandom random, RealVector parent1, RealVector parent2, DoubleValue contiguity) {
       if (parent1.Length != parent2.Length) throw new ArgumentException("SimulatedBinaryCrossover: Parents are of unequal length");
       if (contiguity.Value < 0) throw new ArgumentException("SimulatedBinaryCrossover: Contiguity value is smaller than 0", "contiguity");
       int length = parent1.Length;
-      DoubleArray result = new DoubleArray(length);
+      RealVector result = new RealVector(length);
       for (int i = 0; i < length; i++) {
         if (length == 1 || random.NextDouble() < 0.5) { // cross this variable
@@ -92 +92 @@
 
     /// <summary>
-    /// Checks number of parents, availability of the parameters and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArray, DoubleValue)"/>.
+    /// Checks number of parents, availability of the parameters and forwards the call to <see cref="Apply(IRandom, RealVector, RealVector, DoubleValue)"/>.
     /// </summary>
     /// <exception cref="ArgumentException">Thrown when there are not exactly 2 parents or when the contiguity parameter could not be found.</exception>
@@ -98 +98 @@
     /// <param name="parents">The collection of parents (must be of size 2).</param>
     /// <returns>The real vector resulting from the crossover.</returns>
-    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
+    protected override RealVector Cross(IRandom random, ItemArray<RealVector> parents) {
       if (parents.Length != 2) throw new ArgumentException("SimulatedBinaryCrossover: The number of parents is not equal to 2");
       if (ContiguityParameter.ActualValue == null) throw new InvalidOperationException("SimulatedBinaryCrossover: Parameter " + ContiguityParameter.ActualName + " could not be found.");

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs

@@ -46 +46 @@
     /// <param name="parent2">The second parent for crossover.</param>
     /// <returns>The newly created real vector, resulting from the single point crossover.</returns>
-    public static DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2) {
+    public static RealVector Apply(IRandom random, RealVector parent1, RealVector parent2) {
       if (parent1.Length != parent2.Length) throw new ArgumentException("SinglePointCrossover: Parents are of unequal length");
       int length = parent1.Length;
-      DoubleArray result = new DoubleArray(length);
+      RealVector result = new RealVector(length);
       int breakPoint = random.Next(1, length - 1);
 
@@ -61 +61 @@
 
     /// <summary>
-    /// Checks number of parents and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArray)"/>.
+    /// Checks number of parents and forwards the call to <see cref="Apply(IRandom, RealVector, RealVector)"/>.
     /// </summary> 
     /// <exception cref="ArgumentException">Thrown when the parents' vectors are of unequal length or when <paramref name="contiguity"/> is smaller than 0.</exception>
@@ -67 +67 @@
     /// <param name="parents">The list of parents.</param>
     /// <returns>A new real vector.</returns>
-    protected override HeuristicLab.Data.DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
+    protected override RealVector Cross(IRandom random, ItemArray<RealVector> parents) {
       if (parents.Length != 2) throw new ArgumentException("SinglePointCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/UniformAllPositionsArithmeticCrossover.cs

@@ -61 +61 @@
     /// <param name="alpha">The alpha parameter (<see cref="AlphaParameter"/>).</param>
     /// <returns>The vector resulting from the crossover.</returns>
-    public static DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2, DoubleValue alpha) {
+    public static RealVector Apply(IRandom random, RealVector parent1, RealVector parent2, DoubleValue alpha) {
       int length = parent1.Length;
       if (length != parent2.Length) throw new ArgumentException("UniformAllPositionsArithmeticCrossover: The parent vectors are of different length.", "parent1");
       if (alpha.Value < 0 || alpha.Value > 1) throw new ArgumentException("UniformAllPositionsArithmeticCrossover: Parameter alpha must be in the range [0;1]", "alpha");
-      DoubleArray result = new DoubleArray(length);
+      RealVector result = new RealVector(length);
       for (int i = 0; i < length; i++) {
         result[i] = alpha.Value * parent1[i] + (1 - alpha.Value) * parent2[i];
@@ -73 +73 @@
 
     /// <summary>
-    /// Checks that there are exactly 2 parents, that the alpha parameter is not null and fowards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArrrayData, DoubleValue)"/>.
+    /// Checks that there are exactly 2 parents, that the alpha parameter is not null and fowards the call to <see cref="Apply(IRandom, RealVector, DoubleArrrayData, DoubleValue)"/>.
     /// </summary>
     /// <exception cref="ArgumentException">Thrown when there are not exactly two parents.</exception>
@@ -80 +80 @@
     /// <param name="parents">The collection of parents (must be of size 2).</param>
     /// <returns>The vector resulting from the crossover.</returns>
-    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
+    protected override RealVector Cross(IRandom random, ItemArray<RealVector> parents) {
       if (parents.Length != 2) throw new ArgumentException("UniformAllPositionsArithmeticCrossover: There must be exactly two parents.", "parents");
       if (AlphaParameter.ActualValue == null) throw new InvalidOperationException("UniformAllPositionsArithmeticCrossover: Parameter " + AlphaParameter.ActualName + " could not be found.");

trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/UniformSomePositionsArithmeticCrossover.cs

@@ -68 +68 @@
     /// <param name="probability">The probability parameter (<see cref="ProbabilityParameter"/>).</param>
     /// <returns>The vector resulting from the crossover.</returns>
-    public static DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2, DoubleValue alpha, DoubleValue probability) {
+    public static RealVector Apply(IRandom random, RealVector parent1, RealVector parent2, DoubleValue alpha, DoubleValue probability) {
       int length = parent1.Length;
       if (length != parent2.Length) throw new ArgumentException("UniformSomePositionsArithmeticCrossover: The parent vectors are of different length.", "parent1");
@@ -74 +74 @@
       if (probability.Value < 0 || probability.Value > 1) throw new ArgumentException("UniformSomePositionsArithmeticCrossover: Parameter probability must be in the range [0;1]", "probability");
       
-      DoubleArray result = new DoubleArray(length);
+      RealVector result = new RealVector(length);
       for (int i = 0; i < length; i++) {
         if (random.NextDouble() < probability.Value)
@@ -84 +84 @@
 
     /// <summary>
-    /// Checks that there are exactly 2 parents, that the alpha and the probability parameter are not null and fowards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArrrayData, DoubleValue)"/>.
+    /// Checks that there are exactly 2 parents, that the alpha and the probability parameter are not null and fowards the call to <see cref="Apply(IRandom, RealVector, DoubleArrrayData, DoubleValue)"/>.
     /// </summary>
     /// <exception cref="ArgumentException">Thrown when there are not exactly two parents.</exception>
@@ -91 +91 @@
     /// <param name="parents">The collection of parents (must be of size 2).</param>
     /// <returns>The vector resulting from the crossover.</returns>
-    protected override DoubleArray  Cross(IRandom random, ItemArray<DoubleArray> parents) {
+    protected override RealVector  Cross(IRandom random, ItemArray<RealVector> parents) {
       if (parents.Length != 2) throw new ArgumentException("UniformSomePositionsArithmeticCrossover: There must be exactly two parents.", "parents");
       if (AlphaParameter.ActualValue == null) throw new InvalidOperationException("UniformSomePositionsArithmeticCrossover: Parameter " + AlphaParameter.ActualName + " could not be found.");