Changeset 8017

Timestamp:

06/17/12 13:38:17 (12 years ago)

Author:

abeham

Message:

#1775:

• Renamed some crossovers
• Ported some additional crossovers from the real-vector plugin
• Introduced BoundedIntegerVector* base classes

Location:

branches/IntegerVectorEncoding/HeuristicLab.Encodings.IntegerVectorEncoding/3.3

Files:

• BoundedIntegerVectorCrossover.cs (added)
• BoundedIntegerVectorManipulator.cs (added)
• Crossovers/AverageCrossover.cs (deleted)
• Crossovers/MultiIntegerVectorCrossover.cs (modified) (1 diff)
• Crossovers/RoundedAverageCrossover.cs (added)
• Crossovers/RoundedBlendAlphaBetaCrossover.cs (added)
• Crossovers/RoundedBlendAlphaCrossover.cs (added)
• Crossovers/RoundedHeuristicCrossover.cs (added)
• Crossovers/RoundedLocalCrossover.cs (added)
• Crossovers/RoundedUniformArithmeticCrossover.cs (added)
• Crossovers/UniformAllPositionsArithmeticCrossover.cs (deleted)
• Crossovers/UniformSomePositionsArithmeticCrossover.cs (deleted)
• HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj (modified) (1 diff)
• Interfaces/IBoundedIntegerVectorOperator.cs (modified) (1 diff)
• Manipulators/RoundedNormalAllPositionsManipulator.cs (modified) (5 diffs)
• Manipulators/SelfAdaptiveRoundedNormalAllPositionsManipulator.cs (modified) (6 diffs)
• Manipulators/UniformOnePositionManipulator.cs (modified) (4 diffs)
• Manipulators/UniformSomePositionsManipulator.cs (modified) (4 diffs)

branches/IntegerVectorEncoding/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/MultiIntegerVectorCrossover.cs

@@ -94 +94 @@
         crossover.RandomParameter.ActualName = RandomParameter.Name;
       }
+      foreach (IBoundedIntegerVectorOperator crossover in Operators.OfType<IBoundedIntegerVectorOperator>()) {
+        crossover.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
     }
 

branches/IntegerVectorEncoding/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj

@@ -150 +150 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="BoundedIntegerVectorCrossover.cs" />
+    <Compile Include="BoundedIntegerVectorManipulator.cs" />
     <Compile Include="Creators\UniformRandomIntegerVectorCreator.cs" />
-    <Compile Include="Crossovers\AverageCrossover.cs" />
+    <Compile Include="Crossovers\RoundedAverageCrossover.cs" />
     <Compile Include="Crossovers\DiscreteCrossover.cs">
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="Crossovers\MultiIntegerVectorCrossover.cs" />
+    <Compile Include="Crossovers\RoundedBlendAlphaBetaCrossover.cs" />
+    <Compile Include="Crossovers\RoundedBlendAlphaCrossover.cs" />
+    <Compile Include="Crossovers\RoundedHeuristicCrossover.cs" />
+    <Compile Include="Crossovers\RoundedLocalCrossover.cs" />
     <Compile Include="Crossovers\SinglePointCrossover.cs">
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="Crossovers\UniformAllPositionsArithmeticCrossover.cs" />
-    <Compile Include="Crossovers\UniformSomePositionsArithmeticCrossover.cs" />
+    <Compile Include="Crossovers\RoundedUniformArithmeticCrossover.cs" />
     <Compile Include="Interfaces\IBoundedIntegerVectorOperator.cs" />
     <Compile Include="Interfaces\IIntegerVectorCreator.cs" />

branches/IntegerVectorEncoding/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IBoundedIntegerVectorOperator.cs

@@ -25 +25 @@
 namespace HeuristicLab.Encodings.IntegerVectorEncoding {
   public interface IBoundedIntegerVectorOperator : IIntegerVectorOperator {
+    /// <summary>
+    /// The bounds parameter must contain at least one row and at least two columns. The first two columns specify min and max values, the last column specifies the step size, but is optional (1 is assumed if omitted).
+    /// </summary>
     IValueLookupParameter<IntMatrix> BoundsParameter { get; }
   }

branches/IntegerVectorEncoding/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/RoundedNormalAllPositionsManipulator.cs

@@ -35 +35 @@
   [Item("RoundedNormalAllPositionsManipulator", "This manipulation operator adds a value sigma_i * N_i(0,1) to the current value in each position i given the values for sigma_i in the parameter. The result is rounded to the next feasible value. If there are less elements in Sigma than positions, then Sigma is cycled.")]
   [StorableClass]
-  public class RoundedNormalAllPositionsManipulator : IntegerVectorManipulator {
-
-    public IValueLookupParameter<IntMatrix> BoundsParameter {
-      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
-    }
+  public class RoundedNormalAllPositionsManipulator : BoundedIntegerVectorManipulator {
 
     public IValueParameter<DoubleArray> SigmaParameter {
@@ -54 +50 @@
     public RoundedNormalAllPositionsManipulator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
       Parameters.Add(new ValueParameter<DoubleArray>("Sigma", "The vector containing the standard deviations used for manipulating each dimension. If it is only of length one the same sigma will be used for every dimension.", new DoubleArray(new double[] { 1 })));
     }
@@ -69 +64 @@
     /// <param name="sigma">The sigma vector determining the strength of the mutation.</param>
     /// <param name="random">A random number generator.</param>
-    /// <param name="vector">The integer vector to manipulate.</param>
+    /// <param name="vector">The integer vector to manipulate.</param>#
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
     /// <returns>The manipulated integer vector.</returns>
     public static void Apply(IRandom random, IntegerVector vector, IntMatrix bounds, DoubleArray sigma) {
-      if (sigma == null || sigma.Length == 0) throw new ArgumentException("ERROR: Vector containing the standard deviations is not defined.", "sigma");
+      if (sigma == null || sigma.Length == 0) throw new ArgumentException("RoundedNormalAllPositionsManipulator: Vector containing the standard deviations is not defined.", "sigma");
       if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("RoundedNormalAllPositionsManipulator: Invalid bounds specified.", "bounds");
       var N = new NormalDistributedRandom(random, 0.0, 1.0);
@@ -80 +76 @@
 
         int value = (vector[i] + (int)Math.Round((N.NextDouble() * sigma[i % sigma.Length])) - min) / step;
-        vector[i] = Math.Max(min, Math.Min(max, value * step + min));
+        vector[i] = RoundFeasible(min, max, step, value);
       }
     }
@@ -89 +85 @@
     /// <param name="random">The random number generator.</param>
     /// <param name="vector">The vector of integer values that is manipulated.</param>
-    protected override void Manipulate(IRandom random, IntegerVector vector) {
-      Apply(random, vector, BoundsParameter.ActualValue, SigmaParameter.Value);
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    protected override void ManipulateBounded(IRandom random, IntegerVector vector, IntMatrix bounds) {
+      Apply(random, vector, bounds, SigmaParameter.Value);
     }
   }

branches/IntegerVectorEncoding/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/SelfAdaptiveRoundedNormalAllPositionsManipulator.cs

@@ -36 +36 @@
   [Item("SelfAdaptiveRoundedNormalAllPositionsManipulator", "This manipulation operator adds a value sigma_i * N(0,1) to the current value in each position i. The resulting value is rounded to the next feasible value. The values for sigma_i are looked up dynamically. If there are less elements in the strategy vector than positions, then the strategy vector is cycled.")]
   [StorableClass]
-  public class SelfAdaptiveRoundedNormalAllPositionsManipulator : IntegerVectorManipulator, ISelfAdaptiveManipulator {
+  public class SelfAdaptiveRoundedNormalAllPositionsManipulator : BoundedIntegerVectorManipulator, ISelfAdaptiveManipulator {
     public Type StrategyParameterType {
       get { return typeof(IIntegerVectorStdDevStrategyParameterOperator); }
@@ -51 +51 @@
     }
 
-    public IValueLookupParameter<IntMatrix> BoundsParameter {
-      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
-    }
-
     [StorableConstructor]
     protected SelfAdaptiveRoundedNormalAllPositionsManipulator(bool deserializing) : base(deserializing) { }
@@ -64 +60 @@
       : base() {
       Parameters.Add(new LookupParameter<DoubleArray>("StrategyParameter", "The vector containing the endogenous strategy parameters."));
-      Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
     }
 
@@ -80 +75 @@
     /// <param name="random">A random number generator.</param>
     /// <param name="vector">The integer vector to manipulate.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
     public static void Apply(IRandom random, IntegerVector vector, IntMatrix bounds, DoubleArray strategyParameters) {
-      if (strategyParameters == null || strategyParameters.Length == 0) throw new ArgumentException("ERROR: Vector containing the standard deviations is not defined.", "sigma");
-      if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("RoundedNormalAllPositionsManipulator: Invalid bounds specified.", "bounds");
+      if (strategyParameters == null || strategyParameters.Length == 0) throw new ArgumentException("SelfAdaptiveRoundedNormalAllPositionsManipulator: Vector containing the standard deviations is not defined.", "sigma");
+      if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("SelfAdaptiveRoundedNormalAllPositionsManipulator: Invalid bounds specified.", "bounds");
       var N = new NormalDistributedRandom(random, 0.0, 1.0);
       if (strategyParameters != null) {
@@ -90 +86 @@
 
           int value = (vector[i] + (int)Math.Round((N.NextDouble() * strategyParameters[i % strategyParameters.Length])) - min) / step;
-          vector[i] = Math.Max(min, Math.Min(max, value * step + min));
+          vector[i] = RoundFeasible(min, max, step, value);
         }
       }
@@ -100 +96 @@
     /// <param name="random">The random number generator.</param>
     /// <param name="vector">The vector of integer values that is manipulated.</param>
-    protected override void Manipulate(IRandom random, IntegerVector vector) {
-      Apply(random, vector, BoundsParameter.ActualValue, StrategyParameterParameter.ActualValue);
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    protected override void ManipulateBounded(IRandom random, IntegerVector vector, IntMatrix bounds) {
+      Apply(random, vector, bounds, StrategyParameterParameter.ActualValue);
     }
   }

branches/IntegerVectorEncoding/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformOnePositionManipulator.cs

@@ -36 +36 @@
   [Item("UniformOnePositionManipulator", " Uniformly distributed change of a single position of an integer vector. It is implemented as described in Michalewicz, Z. 1999. Genetic Algorithms + Data Structures = Evolution Programs. Third, Revised and Extended Edition, Spring-Verlag Berlin Heidelberg.")]
   [StorableClass]
-  public class UniformOnePositionManipulator : IntegerVectorManipulator, IBoundedIntegerVectorOperator {
-    /// <summary>
-    /// A matrix that specifies the bounds for each dimension in a separate row. The first column denotes the minimum, the second the maximum value, and the third column denotes the step size.
-    /// </summary>
-    public IValueLookupParameter<IntMatrix> BoundsParameter {
-      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
-    }
+  public class UniformOnePositionManipulator : BoundedIntegerVectorManipulator {
 
     [StorableConstructor]
@@ -51 +45 @@
     /// (<c>Minimum</c> and <c>Maximum</c>).
     /// </summary>
-    public UniformOnePositionManipulator()
-      : base() {
-      Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
-    }
+    public UniformOnePositionManipulator() : base() { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -86 +77 @@
     /// <param name="max">The maximum value of the sampling range for
     /// the vector element to change (exclusive).</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
     public static void Apply(IRandom random, IntegerVector vector, IntMatrix bounds) {
+      Manipulate(random, vector, bounds, random.Next(vector.Length));
+    }
+
+    public static void Manipulate(IRandom random, IntegerVector vector, IntMatrix bounds, int index) {
       if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("UniformOnePositionManipulator: Invalid bounds specified", "bounds");
-      int index = random.Next(vector.Length);
       int min = bounds[index % bounds.Rows, 0], max = bounds[index % bounds.Rows, 1], step = 1;
       if (bounds.Columns > 2) step = bounds[index % bounds.Rows, 2];
-      int value = (max - min) / step;
-      vector[index] = random.Next(value) * step + min;
+      vector[index] = RoundFeasible(min, max, step, random.Next(min, max + 1));
     }
 
@@ -101 +95 @@
     /// <param name="random">A random number generator.</param>
     /// <param name="vector">The integer vector to manipulate.</param>
-    protected override void Manipulate(IRandom random, IntegerVector vector) {
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    protected override void ManipulateBounded(IRandom random, IntegerVector vector, IntMatrix bounds) {
       if (BoundsParameter.ActualValue == null) throw new InvalidOperationException("UniformOnePositionManipulator: Parameter " + BoundsParameter.ActualName + " could not be found.");
-      Apply(random, vector, BoundsParameter.ActualValue);
+      Apply(random, vector, bounds);
     }
   }

branches/IntegerVectorEncoding/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformSomePositionsManipulator.cs

@@ -34 +34 @@
   /// It is implemented as described in Michalewicz, Z. 1999. Genetic Algorithms + Data Structures = Evolution Programs. Third, Revised and Extended Edition, Spring-Verlag Berlin Heidelberg.
   /// </remarks>
-  [Item("UniformSomePositionsManipulator", " Uniformly distributed change of several, but at least one, positions of an integer vector. It is implemented as described in Michalewicz, Z. 1999. Genetic Algorithms + Data Structures = Evolution Programs. Third, Revised and Extended Edition, Spring-Verlag Berlin Heidelberg.")]
+  [Item("UniformSomePositionsManipulator", "Uniformly distributed change of several, but at least one, positions of an integer vector. It is implemented as described in Michalewicz, Z. 1999. Genetic Algorithms + Data Structures = Evolution Programs. Third, Revised and Extended Edition, Spring-Verlag Berlin Heidelberg.")]
   [StorableClass]
-  public class UniformSomePositionsManipulator : IntegerVectorManipulator, IBoundedIntegerVectorOperator {
-    /// <summary>
-    /// A matrix that specifies the bounds for each dimension in a separate row. The first column denotes the minimum, the second the maximum value, and the third column denotes the step size.
-    /// </summary>
-    public IValueLookupParameter<IntMatrix> BoundsParameter {
-      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
-    }
+  public class UniformSomePositionsManipulator : BoundedIntegerVectorManipulator {
 
     public IValueLookupParameter<DoubleValue> ProbabilityParameter {
@@ -51 +45 @@
     protected UniformSomePositionsManipulator(bool deserializing) : base(deserializing) { }
     protected UniformSomePositionsManipulator(UniformSomePositionsManipulator original, Cloner cloner) : base(original, cloner) { }
-    /// <summary>
-    /// Initializes a new instance of <see cref="UniformSomePositionsManipulator"/> with two parameters
-    /// (<c>Minimum</c> and <c>Maximum</c>).
-    /// </summary>
     public UniformSomePositionsManipulator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>("Probability", "The probability for each dimension to be manipulated.", new DoubleValue(0.5)));
     }
@@ -79 +68 @@
         if (random.NextDouble() < probability) {
           atLeastOneManipulated = true;
-          Manipulate(random, vector, bounds, index);
+          UniformOnePositionManipulator.Manipulate(random, vector, bounds, index);
         }
       }
 
       if (!atLeastOneManipulated) {
-        Manipulate(random, vector, bounds, random.Next(vector.Length));
+        UniformOnePositionManipulator.Manipulate(random, vector, bounds, random.Next(vector.Length));
       }
-    }
-
-    private static void Manipulate(IRandom random, IntegerVector vector, IntMatrix bounds, int index) {
-      int min = bounds[index % bounds.Rows, 0], max = bounds[index % bounds.Rows, 1], step = 1;
-      if (bounds.Columns > 2) step = bounds[index % bounds.Rows, 2];
-      int value = (max - min) / step;
-      vector[index] = random.Next(value) * step + min;
     }
 
@@ -101 +83 @@
     /// <param name="random">A random number generator.</param>
     /// <param name="vector">The integer vector to manipulate.</param>
-    protected override void Manipulate(IRandom random, IntegerVector vector) {
-      if (BoundsParameter.ActualValue == null) throw new InvalidOperationException("UniformSomePositionsManipulator: Parameter " + BoundsParameter.ActualName + " could not be found.");
-      Apply(random, vector, BoundsParameter.ActualValue, ProbabilityParameter.ActualValue.Value);
+    protected override void ManipulateBounded(IRandom random, IntegerVector vector, IntMatrix bounds) {
+      Apply(random, vector, bounds, ProbabilityParameter.ActualValue.Value);
     }
   }