Changeset 2913

Timestamp:

03/02/10 16:48:24 (15 years ago)

Author:

abeham

Message:

checked and corrected (where necessary) BLX-a, BLX-a-b, as well the SinglePointCrossover
checked the UniformOnePositionManipulator
fixed a copy-paste oversight in RealVectorManipulator
#890

Location:

trunk/sources/HeuristicLab.Encodings.RealVector/3.3

Files:

• Crossovers/BlendAlphaBetaCrossover.cs (modified) (3 diffs)
• Crossovers/BlendAlphaCrossover.cs (modified) (4 diffs)
• Crossovers/SinglePointCrossover.cs (modified) (3 diffs)
• HeuristicLab.Encodings.RealVector-3.3.csproj (modified) (1 diff)
• Manipulators/UniformOnePositionManipulator.cs (modified) (3 diffs)
• RealVectorManipulator.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/BlendAlphaBetaCrossover.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.
@@ -23 +23 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Encodings.RealVector {
   /// <summary>
-  /// Blend alpha-beta crossover for real vectors. Creates a new offspring by selecting a 
+  /// Blend alpha-beta crossover for real vectors (BLX-a-b). Creates a new offspring by selecting a 
   /// random value from the interval between the two alleles of the parent solutions. 
   /// The interval is increased in both directions as follows: Into the direction of the 'better' 
   /// solution by the factor alpha, into the direction of the 'worse' solution by the factor beta.
   /// </summary>
-  [Item("BlendAlphaBetaCrossover", "FIXME: CHECK WITH LITERATURE AND VALIDATE IT.")]
+  /// <remarks>
+  /// It is implemented as described in Takahashi, M. and Kita, H. 2001. A crossover operator using independent component analysis for real-coded genetic algorithms Proceedings of the 2001 Congress on Evolutionary Computation, pp. 643-649.<br/>
+  /// The default value for alpha is 0.75, the default value for beta is 0.25.
+  /// </remarks>
+  [Item("BlendAlphaBetaCrossover", "The blend alpha beta crossover (BLX-a-b) for real vectors is similar to the blend alpha crossover (BLX-a), but distinguishes between the better and worse of the parents. The interval from which to choose the new offspring can be extended more around the better parent by specifying a higher alpha value. It is implemented as described in Takahashi, M. and Kita, H. 2001. A crossover operator using independent component analysis for real-coded genetic algorithms Proceedings of the 2001 Congress on Evolutionary Computation, pp. 643-649.")]
   [EmptyStorableClass]
   public class BlendAlphaBetaCrossover : RealVectorCrossover {
@@ -60 +64 @@
     }
 
+    /// <summary>
+    /// Performs the blend alpha beta crossover (BLX-a-b) on two parent vectors.
+    /// </summary>
+    /// <exception cref="ArgumentException">
+    /// Thrown when either:<br/>
+    /// <list type="bullet">
+    /// <item><description>The length of <paramref name="betterParent"/> and <paramref name="worseParent"/> is not equal.</description></item>
+    /// <item><description>The parameter <paramref name="alpha"/> is smaller than 0.</description></item>
+    /// <item><description>The parameter <paramref name="beta"/> is smaller than 0.</description></item>
+    /// </list>
+    /// </exception>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="betterParent">The better of the two parents with regard to their fitness.</param>
+    /// <param name="worseParent">The worse of the two parents with regard to their fitness.</param>
+    /// <param name="alpha">The parameter alpha.</param>
+    /// <param name="beta">The parameter beta.</param>
+    /// <returns>The real vector that results from the crossover.</returns>
     public static DoubleArrayData Apply(IRandom random, DoubleArrayData betterParent, DoubleArrayData worseParent, DoubleData alpha, DoubleData 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");
+      if (beta.Value < 0) throw new ArgumentException("BlendAlphaBetaCrossover: Parameter beta must be greater or equal to 0.", "beta");
       int length = betterParent.Length;
+      double min, max, d;
       DoubleArrayData result = new DoubleArrayData(length);
 
       for (int i = 0; i < length; i++) {
-        double interval = Math.Abs(betterParent[i] - worseParent[i]);
-        result[i] = SelectFromInterval(random, interval, betterParent[i], worseParent[i], alpha.Value, beta.Value);
+        d = Math.Abs(betterParent[i] - worseParent[i]);
+        if (betterParent[i] <= worseParent[i]) {
+          min = betterParent[i] - d * alpha.Value;
+          max = worseParent[i] + d * beta.Value;
+        } else {
+          min = worseParent[i] - d * beta.Value;
+          max = betterParent[i] + d * alpha.Value;
+        }
+        result[i] = min + random.NextDouble() * (max - min);
       }
       return result;
     }
 
-    private static double SelectFromInterval(IRandom random, double interval, double val1, double val2, double alpha, double beta) {
-      double resMin = 0;
-      double resMax = 0;
-
-      if (val1 <= val2) {
-        resMin = val1 - interval * alpha;
-        resMax = val2 + interval * beta;
-      } else {
-        resMin = val2 - interval * beta;
-        resMax = val1 + interval * alpha;
-      }
-
-      return SelectRandomFromInterval(random, resMin, resMax);
-    }
-
-    private static double SelectRandomFromInterval(IRandom random, double resMin, double resMax) {
-      return resMin + random.NextDouble() * Math.Abs(resMax - resMin);
-    }
-
+    /// <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, DoubleArrayData, DoubleArrayData, DoubleData, DoubleData)"/>.
+    /// </summary>
+    /// <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>
+    /// <item><description>Alpha parameter could not be found.</description></item>
+    /// <item><description>Beta parameter could not be found.</description></item>
+    /// </list>
+    /// </exception>
+    /// <param name="random">The random number generator to use.</param>
+    /// <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 DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("BlendAlphaBetaCrossover: Number of parents is not equal to 2.");
+      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.");
       if (QualityParameter.ActualValue == null || QualityParameter.ActualValue.Length != parents.Length) throw new InvalidOperationException("BlendAlphaBetaCrossover: Parameter " + QualityParameter.ActualName + " could not be found, or not in the same quantity as there are parents.");

trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/BlendAlphaCrossover.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.
@@ -21 +21 @@
 
 using System;
-using System.Collections.Generic;
-using System.Text;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Encodings.RealVector {
   /// <summary>
-  /// Blend alpha crossover for real vectors. Creates a new offspring by selecting a random value 
+  /// Blend alpha crossover for real vectors (BLX-a). Creates a new offspring by selecting a random value 
   /// from the interval between the two alleles of the parent solutions. The interval is increased 
   /// in both directions by the factor alpha.
   /// </summary>
-  public class BlendAlphaCrossover : RealVectorCrossoverBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return
-@"Blend alpha crossover for real vectors. Creates a new offspring by selecting a random value from the interval between the two alleles of the parent solutions. The interval is increased in both directions by the factor alpha.
-Please use the operator BoundsChecker if necessary.";
-      }
+  /// <remarks>
+  /// It is implemented as described in Takahashi, M. and Kita, H. 2001. A crossover operator using independent component analysis for real-coded genetic algorithms Proceedings of the 2001 Congress on Evolutionary Computation, pp. 643-649.<br/>
+  /// The default value for alpha is 0.5.
+  /// </remarks>
+  [Item("BlendAlphaCrossover", "The blend alpha crossover (BLX-a) for real vectors creates new offspring by sampling a new value in the range [min_i - d * alpha, max_i + d * alpha) at each position i. Here min_i and max_i are the smaller and larger value of the two parents at position i and d is max_i - min_i. It is implemented as described in Takahashi, M. and Kita, H. 2001. A crossover operator using independent component analysis for real-coded genetic algorithms Proceedings of the 2001 Congress on Evolutionary Computation, pp. 643-649.")]
+  [EmptyStorableClass]
+  public class BlendAlphaCrossover : RealVectorCrossover {
+    public ValueLookupParameter<DoubleData> AlphaParameter {
+      get { return (ValueLookupParameter<DoubleData>)Parameters["Alpha"]; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="BlendAlphaCrossover"/> with one parameter (<c>Alpha</c>).
+    /// </summary>
+    public BlendAlphaCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleData>("Alpha", "Value for alpha", new DoubleData(0.5)));
     }
 
     /// <summary>
-    /// Initializes a new instance of <see cref="BlendAlphaCrossover"/> with one variable info (<c>Alpha</c>).
+    /// Performs the blend alpha crossover (BLX-a) of two real vectors.<br/>
+    /// It creates new offspring by sampling a new value in the range [min_i - d * alpha, max_i + d * alpha) at each position i.
+    /// Here min_i and max_i are the smaller and larger value of the two parents at position i and d is max_i - min_i.
     /// </summary>
-    public BlendAlphaCrossover()
-      : base() {
-      VariableInfo alphaVarInfo = new VariableInfo("Alpha", "Value for alpha", typeof(DoubleData), VariableKind.In);
-      alphaVarInfo.Local = true;
-      AddVariableInfo(alphaVarInfo);
-      AddVariable(new Variable("Alpha", new DoubleData(0.5)));
-    }
-
-    /// <summary>
-    /// Performs a blend alpha crossover of two real vectors.
-    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when <paramref name="parent1"/> and <paramref name="parent2"/> are of different length.</exception>
     /// <param name="random">The random number generator.</param>
     /// <param name="parent1">The first parent for the crossover operation.</param>
@@ -60 +61 @@
     /// <param name="alpha">The alpha value for the crossover.</param>
     /// <returns>The newly created real vector resulting from the crossover operation.</returns>
-    public static double[] Apply(IRandom random, double[] parent1, double[] parent2, double alpha) {
+    public static DoubleArrayData Apply(IRandom random, DoubleArrayData parent1, DoubleArrayData parent2, DoubleData alpha) {
+      if (parent1.Length != parent2.Length) throw new ArgumentException("BlendAlphaCrossover: The parents' vectors are of different length.", "parent1");
       int length = parent1.Length;
-      double[] result = new double[length];
-      double cMax = 0, cMin = 0, interval = 0, resMin = 0, resMax = 0;
+      DoubleArrayData result = new DoubleArrayData(length);
+      double max = 0, min = 0, d = 0, resMin = 0, resMax = 0;
 
       for (int i = 0; i < length; i++) {
-        cMax = Math.Max(parent1[i], parent2[i]);
-        cMin = Math.Min(parent1[i], parent2[i]);
-        interval = Math.Abs(cMax - cMin);
-        resMin = cMin - interval * alpha;
-        resMax = cMax + interval * alpha;
+        max = Math.Max(parent1[i], parent2[i]);
+        min = Math.Min(parent1[i], parent2[i]);
+        d = Math.Abs(max - min);
+        resMin = min - d * alpha.Value;
+        resMax = max + d * alpha.Value;
 
         result[i] = resMin + random.NextDouble() * Math.Abs(resMax - resMin);
@@ -78 +80 @@
 
     /// <summary>
-    /// Performs a blend alpha crossover operation for two given parent real vectors.
+    /// Checks that the number of parents is equal to 2 and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleArrayData, DoubleData)"/>.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
-    /// <param name="scope">The current scope.</param>
-    /// <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 BlendAlphaCrossover: The number of parents is not equal to 2");
-      double alpha = GetVariableValue<DoubleData>("Alpha", scope, true).Data;
-      return Apply(random, parents[0], parents[1], alpha);
+    /// <exception cref="ArgumentException">Thrown when the number of parents is not equal to 2.</exception>
+    /// <exception cref="InvalidOperationException">Thrown when the parameter alpha could not be found.</exception>
+    /// <param name="random">The random number generator to use.</param>
+    /// <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 DoubleArrayData Cross(IRandom random, ItemArray<DoubleArrayData> 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.");
+      return Apply(random, parents[0], parents[1], AlphaParameter.ActualValue);
     }
   }

trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Crossovers/SinglePointCrossover.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.
@@ -21 +21 @@
 
 using System;
-using System.Collections.Generic;
-using System.Text;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Encodings.RealVector {
   /// <summary>
-  /// Single point crossover for real vectors.
+  /// Single point crossover for real vectors. The implementation is similar to the single point crossover for binary vectors.
+  /// After a breakpoint is randomly chosen in the interval [1,N-1) with N = length of the vector, the first part is copied from parent1 the other part copied from parent2.
+  /// The interval is chosen such that at least one position is taken from a different parent.
   /// </summary>
-  public class SinglePointCrossover : RealVectorCrossoverBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return "Single point crossover for real vectors."; }
-    }
-
+  /// <remarks>
+  /// 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("SinglePointCrossover", "Breaks both parent chromosomes at a randomly chosen point and assembles a child by taking one part of the first parent and the other part of the second pard. It is implemented as described in Michalewicz, Z. 1999. Genetic Algorithms + Data Structures = Evolution Programs. Third, Revised and Extended Edition, Spring-Verlag Berlin Heidelberg.")]
+  [EmptyStorableClass]
+  public class SinglePointCrossover : RealVectorCrossover {
     /// <summary>
-    /// Performs a single point crossover at a randomly chosen position of the two 
-    /// given parent real vectors.
+    /// Performs the single point crossover for real vectors. The implementation is similar to the single point crossover for binary vectors.
+    /// After a breakpoint is randomly chosen in the interval [1,N-1) with N = length of the vector, the first part is copied from parent1 the other part copied from parent2.
     /// </summary>
+    /// <exception cref="ArgumentException">Thrown when the length of the vector is not the same in both parents.</exception>
     /// <param name="random">A random number generator.</param>
     /// <param name="parent1">The first parent for crossover.</param>
     /// <param name="parent2">The second parent for crossover.</param>
     /// <returns>The newly created real vector, resulting from the single point 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("SinglePointCrossover: Parents are of unequal length");
       int length = parent1.Length;
-      double[] result = new double[length];
-      int breakPoint = random.Next(1, length);
+      DoubleArrayData result = new DoubleArrayData(length);
+      int breakPoint = random.Next(1, length - 1);
 
       for (int i = 0; i < breakPoint; i++)
@@ -57 +61 @@
 
     /// <summary>
-    /// Performs a single point crossover operation for two given parent real vectors.
+    /// Checks number of parents and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleArrayData)"/>.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
-    /// <param name="scope">The current scope.</param>
-    /// <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 SinglePointCrossover: The number of parents is not equal to 2");
+    /// <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");
       return Apply(random, parents[0], parents[1]);
     }

trunk/sources/HeuristicLab.Encodings.RealVector/3.3/HeuristicLab.Encodings.RealVector-3.3.csproj

@@ -91 +91 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Crossovers\BlendAlphaCrossover.cs" />
+    <Compile Include="Crossovers\SinglePointCrossover.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="HeuristicLabEncodingsRealVectorPlugin.cs" />
     <None Include="HeuristicLab.snk" />

trunk/sources/HeuristicLab.Encodings.RealVector/3.3/Manipulators/UniformOnePositionManipulator.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.
@@ -21 +21 @@
 
 using System;
-using System.Collections.Generic;
-using System.Text;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Encodings.RealVector {
   /// <summary>
-  /// Uniformly distributed change of a single position of a real vector.
+  /// Uniformly distributed change of a single position in a real vector.
   /// </summary>
-  public class UniformOnePositionManipulator : RealVectorManipulatorBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get { return "Uniformly distributed change of a single position of a real vector."; }
+  /// <remarks>
+  /// 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("UniformOnePositionManipulator", "Changes a single position in the vector by sampling uniformly from the interval [Minimum, Maximum). It is implemented as described in Michalewicz, Z. 1999. Genetic Algorithms + Data Structures = Evolution Programs. Third, Revised and Extended Edition, Spring-Verlag Berlin Heidelberg.")]
+  [EmptyStorableClass]
+  public class UniformOnePositionManipulator : RealVectorManipulator {
+    public ValueLookupParameter<DoubleData> MinimumParameter {
+      get { return (ValueLookupParameter<DoubleData>)Parameters["Minimum"]; }
+    }
+
+    public ValueLookupParameter<DoubleData> MaximumParameter {
+      get { return (ValueLookupParameter<DoubleData>)Parameters["Maximum"]; }
     }
 
     /// <summary>
-    /// Initializes a new instance of <see cref="UniformOnePositionManipulator"/> with two variable infos
+    /// Initializes a new instance of <see cref="UniformOnePositionManipulator"/> with two parameters
     /// (<c>Minimum</c> and <c>Maximum</c>).
     /// </summary>
     public UniformOnePositionManipulator() {
-      AddVariableInfo(new VariableInfo("Minimum", "Minimum of the sampling range for the vector element (included)", typeof(DoubleData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("Maximum", "Maximum of the sampling range for the vector element (excluded)", typeof(DoubleData), VariableKind.In));
+      Parameters.Add(new ValueLookupParameter<DoubleData>("Minimum", "Minimum of the sampling range for the vector element (included)"));
+      Parameters.Add(new ValueLookupParameter<DoubleData>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
     }
 
@@ -54 +62 @@
     /// <param name="max">The maximum value of the sampling range for
     /// the vector element to change (exclusive).</param>
-    /// <returns>The new real vector that has been manipulated.</returns>
-    public static double[] Apply(IRandom random, double[] vector, double min, double max) {
-      double[] result = (double[])vector.Clone();
-      int index = random.Next(result.Length);
-      result[index] = min + random.NextDouble() * (max - min);
-      return result;
+    public static void Apply(IRandom random, DoubleArrayData vector, DoubleData min, DoubleData max) {
+      int index = random.Next(vector.Length);
+      vector[index] = min.Value + random.NextDouble() * (max.Value - min.Value);
     }
 
     /// <summary>
-    /// Changes randomly a single position in the given real <paramref name="vector"/>.
+    /// Checks if the minimum and maximum parameters are available and forwards the call to <see cref="Apply(IRandom, DoubleArrayData, DoubleData, DoubleData)"/>.
     /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">A random number generator.</param>
-    /// <param name="vector">The real vector to manipulate.</param>
-    /// <returns>The new real vector that has been manipulated.</returns>
-    protected override double[] Manipulate(IScope scope, IRandom random, double[] vector) {
-      double min = GetVariableValue<DoubleData>("Minimum", scope, true).Data;
-      double max = GetVariableValue<DoubleData>("Maximum", scope, true).Data;
-      return Apply(random, vector, min, max);
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="realVector">The real vector to manipulate.</param>
+    protected override void Manipulate(IRandom random, DoubleArrayData realVector) {
+      if (MinimumParameter.ActualValue == null) throw new InvalidOperationException("UniformOnePositionManipulator: Parameter " + MinimumParameter.ActualName + " could not be found.");
+      if (MaximumParameter.ActualValue == null) throw new InvalidOperationException("UniformOnePositionManipulator: Parameter " + MaximumParameter.ActualName + " could not be found.");
+      Apply(random, realVector, MinimumParameter.ActualValue, MaximumParameter.ActualValue);
     }
   }

trunk/sources/HeuristicLab.Encodings.RealVector/3.3/RealVectorManipulator.cs

@@ -52 +52 @@
     }
 
-    protected abstract void Manipulate(IRandom random, DoubleArrayData permutation);
+    protected abstract void Manipulate(IRandom random, DoubleArrayData realVector);
   }
 }