Changeset 2936 for trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers

Timestamp:

03/05/10 13:14:26 (15 years ago)

Author:

svonolfe

Message:

Added heuristic, local, random convex crossover and added some initial unit tests for all RealVector operators (#890)

Location:

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

Files:

• DiscreteCrossover.cs (modified) (1 diff)
• HeuristicCrossover.cs (modified) (6 diffs)
• LocalCrossover.cs (modified) (5 diffs)
• RandomConvexCrossover.cs (modified) (5 diffs)
• SimulatedBinaryCrossover.cs (modified) (1 diff)
• SinglePointCrossover.cs (modified) (1 diff)

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

@@ -47 +47 @@
     public static DoubleArrayData Apply(IRandom random, ItemArray<DoubleArrayData> parents) {
       int length = parents[0].Length;
+      
+      for (int i = 0; i < parents.Length; i++) { 
+        if(parents[i].Length != length)
+          throw new ArgumentException("DiscreteCrossover: The parents' vectors are of different length.", "parents");
+      }
+      
       DoubleArrayData result = new DoubleArrayData(length);
-      try {
-        for (int i = 0; i < length; i++) {
-          result[i] = parents[random.Next(parents.Length)][i];
-        }
-      } catch (IndexOutOfRangeException) {
-        throw new ArgumentException("DiscreteCrossover: The parents' vectors are of different length.", "parents");
-      }
+      for (int i = 0; i < length; i++) {
+        result[i] = parents[random.Next(parents.Length)][i];
+      }        
+      
       return result;
     }

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

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -25 +25 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Evolutionary;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.RealVector {
@@ -32 +33 @@
   /// of the two parents times a randomly chosen factor.
   /// </summary>
-  public class HeuristicCrossover : RealVectorCrossoverBase {
+  /// <remarks>
+  /// It is implemented as described in Wright, A.H. (1994), Genetic algorithms for real parameter optimization, Foundations of Genetic Algorithms, G.J.E. Rawlins (Ed.), Morgan Kaufmann, San Mateo, CA, 205-218.
+  /// </remarks>
+  [Item("HeuristicCrossover", "Heuristic crossover for real vectors: Takes for each position the better parent and adds the difference. It is implemented as described in Wright, A.H. (1994), Genetic algorithms for real parameter optimization, Foundations of Genetic Algorithms, G.J.E. Rawlins (Ed.), Morgan Kaufmann, San Mateo, CA, 205-218.")]
+  [EmptyStorableClass]
+  public class HeuristicCrossover : RealVectorCrossover {
+    /// <summary>
+    /// Whether the problem is a maximization or minimization problem.
+    /// </summary>
+    public ValueLookupParameter<BoolData> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolData>)Parameters["Maximization"]; }
+    }
+    /// <summary>
+    /// The quality of the parents.
+    /// </summary>
+    public SubScopesLookupParameter<DoubleData> QualityParameter {
+      get { return (SubScopesLookupParameter<DoubleData>)Parameters["Quality"]; }
+    }
+
     /// <summary>
     /// Initializes a new instance of <see cref="HeuristicCrossover"/> with two variable infos
@@ -39 +58 @@
     public HeuristicCrossover()
       : base() {
-      AddVariableInfo(new VariableInfo("Maximization", "Maximization problem", typeof(BoolData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("Quality", "Quality value", typeof(DoubleData), VariableKind.In));
-    }
-
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return "Heuristic crossover for real vectors."; }
+      Parameters.Add(new ValueLookupParameter<BoolData>("Maximization", "Whether the problem is a maximization problem or not."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleData>("Quality", "The quality values of the parents."));
     }
 
@@ -51 +65 @@
     /// Perfomrs a heuristic crossover on the two given parents.
     /// </summary>
+    /// <exception cref="ArgumentException">Thrown when two parents are not of the same length.</exception>
     /// <param name="random">The random number generator.</param>
-    /// <param name="maximization">Boolean flag whether it is a maximization problem.</param>
-    /// <param name="parent1">The first parent for the crossover operation.</param>
-    /// <param name="quality1">The quality of the first parent.</param>
-    /// <param name="parent2">The second parent for the crossover operation.</param>
-    /// <param name="quality2">The quality of the second parent.</param>
+    /// <param name="betterParent">The first parent for the crossover operation.</param>
+    /// <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 double[] Apply(IRandom random, bool maximization, double[] parent1, double quality1, double[] parent2, double quality2) {
-      int length = parent1.Length;
+    public static DoubleArrayData Apply(IRandom random, DoubleArrayData betterParent, DoubleArrayData worseParent) {
+      if (betterParent.Length != worseParent.Length)
+        throw new ArgumentException("ERROR in HeuristicCrossover: the two parents are not of the same length");
+      
+      int length = betterParent.Length;
       double[] result = new double[length];
       double factor = random.NextDouble();
 
       for (int i = 0; i < length; i++) {
-        if ((maximization && (quality1 > quality2)) || ((!maximization) && (quality1 < quality2)))
-          result[i] = parent1[i] + factor * (parent1[i] - parent2[i]);
-        else
-          result[i] = parent2[i] + factor * (parent2[i] - parent1[i]);
+        result[i] = betterParent[i] + factor * (betterParent[i] - worseParent[i]);
       }
-      return result;
+      return new DoubleArrayData(result);
     }
 
@@ -75 +87 @@
     /// Performs a heuristic crossover operation for two given parent real vectors.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
-    /// <param name="scope">The current scope.</param>
+    /// <exception cref="ArgumentException">Thrown when the number of parents is not equal to 2.</exception>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when either:<br/>
+    /// <list type="bullet">
+    /// <item><description>Maximization parameter could not be found.</description></item>
+    /// <item><description>Quality parameter could not be found or the number of quality values is not equal to the number of parents.</description></item>
+    /// </list>
+    /// </exception>
     /// <param name="random">A random number generator.</param>
     /// <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 double[] Cross(IScope scope, IRandom random, double[][] parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("ERROR in HeuristicCrossover: The number of parents is not equal to 2");
-      bool maximization = GetVariableValue<BoolData>("Maximization", scope, true).Data;
-      double quality1 = scope.SubScopes[0].GetVariableValue<DoubleData>("Quality", false).Data;
-      double quality2 = scope.SubScopes[1].GetVariableValue<DoubleData>("Quality", false).Data;
+    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+      if (parents.Length != 2) throw new ArgumentException("ERROR in HeuristicCrossover: The number of parents is not equal to 2");
 
-      return Apply(random, maximization, parents[0], quality1, parents[1], quality2);
+      if (MaximizationParameter.ActualValue == null) throw new InvalidOperationException("HeuristicCrossover: Parameter " + MaximizationParameter.ActualName + " could not be found.");
+      if (QualityParameter.ActualValue == null || QualityParameter.ActualValue.Length != parents.Length) throw new InvalidOperationException("HeuristicCrossover: Parameter " + QualityParameter.ActualName + " could not be found, or not in the same quantity as there are parents.");
+
+      ItemArray<DoubleData> qualities = QualityParameter.ActualValue;
+      bool maximization = MaximizationParameter.ActualValue.Value;
+
+      if (maximization && qualities[0].Value >= qualities[1].Value || !maximization && qualities[0].Value <= qualities[1].Value)
+        return Apply(random, parents[0], parents[1]);
+      else
+        return Apply(random, parents[1], parents[0]);
     }
   }

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

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -25 +25 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Encodings.RealVector {
@@ -31 +32 @@
   /// always newly created randomly chosen factor and adds the allele of the second parent times (1 - the randomly chosen factor).
   /// </summary>
-  public class LocalCrossover : RealVectorCrossoverBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return "Local crossover for real vectors."; }
-    }
-
+  /// <remarks>
+  /// It is implemented as described in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL, p. 194.
+  /// </remarks>
+  [Item("LocalCrossover", "Local crossover for real vectors: Takes for each element the allele of the first parent times a always newly created randomly chosen factor and adds the allele of the second parent times (1 - the randomly chosen factor. " +
+    "It is implemented as described in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL., p. 194.")]
+  [EmptyStorableClass]
+  public class LocalCrossover : RealVectorCrossover {
     /// <summary>
     /// Performs a local crossover on the two given parent vectors.
     /// </summary>
+    /// <exception cref="ArgumentException">Thrown when two parents are not of the same length.</exception>
     /// <param name="random">The random number generator.</param>
     /// <param name="parent1">The first parent for the crossover operation.</param>
     /// <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 double[] Apply(IRandom random, double[] parent1, double[] parent2) {
+    public static DoubleArrayData Apply(IRandom random, DoubleArrayData parent1, DoubleArrayData parent2) {
+      if (parent1.Length != parent2.Length)
+        throw new ArgumentException("ERROR in LocalCrossover: the two parents are not of the same length");
+      
       double factor;
       int length = parent1.Length;
@@ -53 +59 @@
         result[i] = (factor * parent1[i]) + ((1 - factor) * parent2[i]);
       }
-      return result;
+      return new DoubleArrayData(result);
     }
 
@@ -59 +65 @@
     /// Performs a local crossover operation for two given parent real vectors.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
-    /// <param name="scope">The current scope.</param>
+    /// <exception cref="ArgumentException">Thrown if there are not exactly two parents.</exception>
     /// <param name="random">A random number generator.</param>
     /// <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 double[] Cross(IScope scope, IRandom random, double[][] parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("ERROR in LocalCrossover: The number of parents is not equal to 2");
+    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
+      if (parents.Length != 2) throw new ArgumentException("ERROR in LocalCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
     }

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

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -25 +25 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Encodings.RealVector {
@@ -32 +33 @@
   /// (1 - the randomly chosen factor).
   /// </summary>
-  public class RandomConvexCrossover : RealVectorCrossoverBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return "Random convex crossover for real vectors."; }
-    }
-
+  /// <remarks>
+  /// It is implemented as described in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL, pp. 193 - 194.
+  /// </remarks>
+  [Item("RandomConvexCrossover", "Random convex crossover for real vectors: Takes for each element the allele of the first parent times a once created randomly chosen factor and adds the allele of the second parent times (1 - the randomly chosen factor). " +
+    "It is implementes as described in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL, pp. 193 - 194.")]
+  [EmptyStorableClass]
+  public class RandomConvexCrossover : RealVectorCrossover {
     /// <summary>
     /// Performs a random convex crossover on the two given parents.
     /// </summary>
+    /// <exception cref="ArgumentException">Thrown when two parents are not of the same length.</exception>
     /// <param name="random">The random number generator.</param>
     /// <param name="parent1">The first parent vector for the crossover.</param>
     /// <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 double[] Apply(IRandom random, double[] parent1, double[] parent2) {
+    public static DoubleArrayData Apply(IRandom random, DoubleArrayData parent1, DoubleArrayData parent2) {
+      if (parent1.Length != parent2.Length)
+        throw new ArgumentException("ERROR in RandomConvexCrossover: the two parents are not of the same length");
+      
       int length = parent1.Length;
       double[] result = new double[length];
@@ -52 +58 @@
       for (int i = 0; i < length; i++)
         result[i] = (factor * parent1[i]) + ((1 - factor) * parent2[i]);
-      return result;
+      return new DoubleArrayData(result);
     }
 
@@ -58 +64 @@
     /// Performs a random convex crossover operation for two given parent real vectors.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
-    /// <param name="scope">The current scope.</param>
+    /// <exception cref="ArgumentException">Thrown if there are not exactly two parents.</exception>
     /// <param name="random">A random number generator.</param>
     /// <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 double[] Cross(IScope scope, IRandom random, double[][] parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("ERROR in RandomConvexCrossover: The number of parents is not equal to 2");
+    protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> 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.RealVector/3.3/Crossovers/SimulatedBinaryCrossover.cs

@@ -94 +94 @@
     /// Checks number of parents, availability of the parameters and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleArrayData, DoubleData)"/>.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown when there are not exactly 2 parents or when the contiguity parameter could not be found.</exception>
+    /// <exception cref="ArgumentException">Thrown when there are not exactly 2 parents or when the contiguity parameter could not be found.</exception>
     /// <param name="random">The random number generator.</param>
     /// <param name="parents">The collection of parents (must be of size 2).</param>
     /// <returns>The real vector resulting from the crossover.</returns>
     protected override DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("SimulatedBinaryCrossover: The number of parents is not equal to 2");
+      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.");
       return Apply(random, parents[0], parents[1], ContiguityParameter.ActualValue);

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

@@ -62 +62 @@
     /// <summary>
     /// Checks number of parents and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleArrayData)"/>.
-    /// </summary>
+    /// </summary> 
+    /// <exception cref="ArgumentException">Thrown when the parents' vectors are of unequal length or when <paramref name="contiguity"/> is smaller than 0.</exception>
     /// <param name="random">The pseudo random number generator to use.</param>
     /// <param name="parents">The list of parents.</param>
     /// <returns>A new real vector.</returns>
     protected override HeuristicLab.Data.DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("SinglePointCrossover: The number of parents is not equal to 2");
+      if (parents.Length != 2) throw new ArgumentException("SinglePointCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
     }