Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/BoundsChecker.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/BoundsChecker.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/BoundsChecker.cs	(revision 3051)
@@ -0,0 +1,88 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using System;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// Checks if all elements of a real vector are inside a given minimum and maximum value. 
+  /// If not, the elements are corrected.
+  /// </summary>
+  [Item("BoundsChecker", "Checks if all elements of a real vector are inside a given minimum and maximum value. If not, elements are corrected.")]
+  [StorableClass]
+  public class BoundsChecker : SingleSuccessorOperator {
+    public LookupParameter<DoubleArray> RealVectorParameter {
+      get { return (LookupParameter<DoubleArray>)Parameters["RealVector"]; }
+    }
+    public ValueLookupParameter<DoubleValue> MinimumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Minimum"]; }
+    }
+    public ValueLookupParameter<DoubleValue> MaximumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Maximum"]; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="BoundsChecker"/> with three parameters
+    /// (<c>RealVector</c>, <c>Minimum</c> and <c>Maximum</c>).
+    /// </summary>
+    public BoundsChecker()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleArray>("RealVector", "The real-valued vector for which the bounds should be checked."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Minimum", "The lower bound for each element in the vector."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Maximum", "The upper bound for each element in the vector."));
+    }
+
+    /// <summary>
+    /// Checks if all elements of the given <paramref name="vector"/> are inside the given minimum 
+    /// and maximum value and if not they are corrected.
+    /// </summary>
+    /// <param name="min">The minimum value of the range (inclusive).</param>
+    /// <param name="max">The maximum value of the range (inclusive).</param>
+    /// <param name="vector">The vector to check.</param>
+    /// <returns>The corrected real vector.</returns>
+    public static void Apply(DoubleArray vector, DoubleValue min, DoubleValue max) {
+      for (int i = 0; i < vector.Length; i++) {
+        if (vector[i] < min.Value) vector[i] = min.Value;
+        if (vector[i] > max.Value) vector[i] = max.Value;
+      }
+    }
+
+    /// <summary>
+    /// Checks if all elements of the given <paramref name="vector"/> are inside the given minimum 
+    /// and maximum value and if not they are corrected.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown when one of the three parameters (vector, minimum, or maximum) could not be found.</exception>
+    /// <remarks>Calls <see cref="Apply(double, double, double[])"/>.</remarks>
+    /// <inheritdoc select="returns" />
+    public override IOperation Apply() {
+      if (RealVectorParameter.ActualValue == null) throw new InvalidOperationException("BoundsChecker: Parameter " + RealVectorParameter.ActualName + " could not be found.");
+      if (MinimumParameter.ActualValue == null) throw new InvalidOperationException("BoundsChecker: Parameter " + MinimumParameter.ActualName + " could not be found.");
+      if (MaximumParameter.ActualValue == null) throw new InvalidOperationException("BoundsChecker: Parameter " + MaximumParameter.ActualName + " could not be found.");
+      Apply(RealVectorParameter.ActualValue, MinimumParameter.ActualValue, MaximumParameter.ActualValue);
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Creators/UniformRandomRealVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Creators/UniformRandomRealVectorCreator.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Creators/UniformRandomRealVectorCreator.cs	(revision 3051)
@@ -0,0 +1,74 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// An operator which creates a new random real vector with each element uniformly distributed in a specified range.
+  /// </summary>
+  [Item("UniformRandomRealVectorCreator", "An operator which creates a new random real vector with each element uniformly distributed in a specified range.")]
+  [StorableClass]
+  [Creatable("Test")]
+  public class UniformRandomRealVectorCreator : RealVectorCreator {
+    /// <summary>
+    /// Generates a new random real vector with the given <paramref name="length"/> and in the interval [min,max).
+    /// </summary>
+    /// <exception cref="ArgumentException">
+    /// Thrown when <paramref name="length"/> is smaller or equal to 0.<br />
+    /// Thrown when <paramref name="min"/> is greater than <paramref name="max"/>.
+    /// </exception>
+    /// <remarks>
+    /// Note that if <paramref name="min"/> is equal to <paramref name="max"/>, all elements of the vector will be equal to <paramref name="min"/>.
+    /// </remarks>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="length">The length of the real vector.</param>
+    /// <param name="min">The minimum value of the sampling range for each vector element (inclusive).</param>
+    /// <param name="max">The maximum value of the sampling range for each vector element (exclusive).</param>
+    /// <returns>The newly created real vector.</returns>
+    public static DoubleArray Apply(IRandom random, int length, double min, double max) {
+      if (length <= 0) throw new ArgumentException("UniformRandomRealVectorCreator: Length is smaller or equal to 0.", "length");
+      if (min > max) throw new ArgumentException("UniformRandomRealVectorCreator: Minimum is greater than Maximum.", "min");
+      DoubleArray result = new DoubleArray(length);
+      for (int i = 0; i < length; i++)
+        result[i] = min + random.NextDouble() * (max - min);
+      return result;
+    }
+
+    /// <summary>
+    /// Forwards the call to <see cref="Apply(IRandom, int, double, double)"/>.
+    /// </summary>
+    /// <param name="random">The pseudo random number generator to use.</param>
+    /// <param name="length">The length of the real vector.</param>
+    /// <param name="minimum">The minimum value of the sampling range for each vector element (inclusive).</param>
+    /// <param name="maximum">The maximum value of the sampling range for each vector element (exclusive).</param>
+    /// <returns>The newly created real vector.</returns>
+    protected override DoubleArray Create(IRandom random, IntValue length, DoubleValue minimum, DoubleValue maximum) {
+      return Apply(random, length.Value, minimum.Value, maximum.Value);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/AverageCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/AverageCrossover.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/AverageCrossover.cs	(revision 3051)
@@ -0,0 +1,76 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// The average crossover (intermediate recombination) calculates the average or centroid of a number of parent vectors.
+  /// </summary>
+  /// <remarks>
+  /// It is implemented as described by Beyer, H.-G. and Schwefel, H.-P. 2002. Evolution Strategies - A Comprehensive Introduction Natural Computing, 1, pp. 3-52.
+  /// </remarks>
+  [Item("AverageCrossover", "The average crossover (intermediate recombination) produces a new offspring by calculating in each position the average of a number of parents. It is implemented as described by Beyer, H.-G. and Schwefel, H.-P. 2002. Evolution Strategies - A Comprehensive Introduction Natural Computing, 1, pp. 3-52.")]
+  [StorableClass]
+  public class AverageCrossover : RealVectorCrossover {
+    /// <summary>
+    /// Performs the average crossover (intermediate recombination) on a list of parents.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when there is just one parent or when the parent vectors are of different length.</exception>
+    /// <remarks>
+    /// There can be more than two parents.
+    /// </remarks>
+    /// <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>
+    public static DoubleArray Apply(IRandom random, ItemArray<DoubleArray> 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);
+      try {
+        double avg;
+        for (int i = 0; i < length; i++) {
+          avg = 0;
+          for (int j = 0; j < parentsCount; j++)
+            avg += parents[j][i];
+          result[i] = avg / (double)parentsCount;
+        }
+      } catch (IndexOutOfRangeException) {
+        throw new ArgumentException("AverageCrossover: The parents' vectors are of different length.", "parents");
+      }
+
+      return result;
+    }
+
+    /// <summary>
+    /// Forwards the call to <see cref="Apply(IRandom, ItemArray<DoubleArray>)"/>.
+    /// </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) {
+      return Apply(random, parents);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/BlendAlphaBetaCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/BlendAlphaBetaCrossover.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/BlendAlphaBetaCrossover.cs	(revision 3051)
@@ -0,0 +1,150 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// 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>
+  /// <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.")]
+  [StorableClass]
+  public class BlendAlphaBetaCrossover : RealVectorCrossover {
+    /// <summary>
+    /// Whether the problem is a maximization or minimization problem.
+    /// </summary>
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    /// <summary>
+    /// The quality of the parents.
+    /// </summary>
+    public SubScopesLookupParameter<DoubleValue> QualityParameter {
+      get { return (SubScopesLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    /// <summary>
+    /// The alpha parameter specifies how much the interval between the parents should be extended in direction of the better parent.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> AlphaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Alpha"]; }
+    }
+    /// <summary>
+    /// The beta parameter specifies how much the interval between the parents should be extended in direction of the worse parent.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> BetaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Beta"]; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="BlendAlphaBetaCrossover"/> with four additional parameters
+    /// (<c>Maximization</c>, <c>Quality</c>, <c>Alpha</c> and <c>Beta</c>).
+    /// </summary>
+    public BlendAlphaBetaCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "Whether the problem is a maximization problem or not."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>("Quality", "The quality values of the parents."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "The value for alpha.", new DoubleValue(0.75)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Beta", "The value for beta.", new DoubleValue(0.25)));
+    }
+
+    /// <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 DoubleArray Apply(IRandom random, DoubleArray betterParent, DoubleArray 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");
+      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;
+      DoubleArray result = new DoubleArray(length);
+
+      for (int i = 0; i < length; i++) {
+        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;
+    }
+
+    /// <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)"/>.
+    /// </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 DoubleArray Cross(IRandom random, ItemArray<DoubleArray> 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.");
+      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.");
+      if (AlphaParameter.ActualValue == null || BetaParameter.ActualValue == null) throw new InvalidOperationException("BlendAlphaBetaCrossover: Parameter " + AlphaParameter.ActualName + " or paramter " + BetaParameter.ActualName + " could not be found.");
+      
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
+      bool maximization = MaximizationParameter.ActualValue.Value;
+      // the better parent 
+      if (maximization && qualities[0].Value >= qualities[1].Value || !maximization && qualities[0].Value <= qualities[1].Value)
+        return Apply(random, parents[0], parents[1], AlphaParameter.ActualValue, BetaParameter.ActualValue);
+      else {
+        return Apply(random, parents[1], parents[0], AlphaParameter.ActualValue, BetaParameter.ActualValue);
+      }
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/BlendAlphaCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/BlendAlphaCrossover.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/BlendAlphaCrossover.cs	(revision 3051)
@@ -0,0 +1,105 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+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 (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>
+  /// <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.")]
+  [StorableClass]
+  public class BlendAlphaCrossover : RealVectorCrossover {
+    /// <summary>
+    /// The alpha parameter specifies how much the interval between the parents should be extended to the left and right.
+    /// The value of this parameter also determines the name of the operator: BLX-0.0 for example means alpha is set to 0.
+    /// When Alpha is 0, then the offspring will only be chosen in between the parents, the bigger alpha is the more it will be possible to choose
+    /// values left and right of the min and max value for each gene.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> AlphaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)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<DoubleValue>("Alpha", "Value for alpha", new DoubleValue(0.5)));
+    }
+
+    /// <summary>
+    /// 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>
+    /// <exception cref="ArgumentException">
+    /// Thrown when <paramref name="parent1"/> and <paramref name="parent2"/> are of different length or<br/>
+    /// when <paramref name="alpha"/> is less than 0.
+    /// </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>
+    /// <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) {
+      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);
+      double max = 0, min = 0, d = 0, resMin = 0, resMax = 0;
+
+      for (int i = 0; i < length; i++) {
+        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);
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Checks that the number of parents is equal to 2 and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArray, DoubleValue)"/>.
+    /// </summary>
+    /// <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 DoubleArray Cross(IRandom random, ItemArray<DoubleArray> 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);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/DiscreteCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/DiscreteCrossover.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/DiscreteCrossover.cs	(revision 3051)
@@ -0,0 +1,75 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// Discrete crossover for real vectors: For each position in the new vector an allele
+  /// of one of the parents is randomly selected.
+  /// </summary>
+  /// <remarks>
+  /// This operator is also called dominant recombination and unlike other crossovers works on more than two parents also.<br />
+  /// It is implemented as described in Beyer, H.-G. and Schwefel, H.-P. 2002. Evolution Strategies - A Comprehensive Introduction Natural Computing, 1, pp. 3-52.
+  /// </remarks>
+  [Item("DiscreteCrossover", "Discrete crossover for real vectors: Creates a new offspring by combining the alleles in the parents such that each allele is randomly selected from one parent. It is implemented as described in Beyer, H.-G. and Schwefel, H.-P. 2002. Evolution Strategies - A Comprehensive Introduction Natural Computing, 1, pp. 3-52.")]
+  [StorableClass]
+  public class DiscreteCrossover : RealVectorCrossover {
+    /// <summary>
+    /// Performs a discrete crossover operation on multiple parents.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when the vectors of the parents are of different length.</exception>
+    /// <param name="random">A random number generator.</param>
+    /// <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) {
+      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");
+      }
+      
+      DoubleArray result = new DoubleArray(length);
+      for (int i = 0; i < length; i++) {
+        result[i] = parents[random.Next(parents.Length)][i];
+      }        
+      
+      return result;
+    }
+
+    /// <summary>
+    /// Checks number of parents and forwards the call to <see cref="Apply(IRandom, ItemArray<DoubleArray>)"/>.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when <paramref name="parents"/> contains less than 2 elements.</exception>
+    /// <param name="random">The random number generator.</param>
+    /// <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) {
+      if (parents.Length < 2) throw new ArgumentException("DiscreteCrossover: The number of parents is less than 2.", "parents");
+      return Apply(random, parents);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/HeuristicCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/HeuristicCrossover.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/HeuristicCrossover.cs	(revision 3051)
@@ -0,0 +1,113 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// Heuristic crossover for real vectors: Calculates the vector from the worse to the better parent and adds that to the better parent weighted with a factor in the interval [0;1).
+  /// The idea is that going further in direction from the worse to the better leads to even better solutions (naturally this depends on the fitness landscape).
+  /// </summary>
+  /// <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", "The heuristic crossover produces offspring that extend the better parent in direction from the worse to the better parent. 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.")]
+  [StorableClass]
+  public class HeuristicCrossover : RealVectorCrossover {
+    /// <summary>
+    /// Whether the problem is a maximization or minimization problem.
+    /// </summary>
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    /// <summary>
+    /// The quality of the parents.
+    /// </summary>
+    public SubScopesLookupParameter<DoubleValue> QualityParameter {
+      get { return (SubScopesLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="HeuristicCrossover"/> with two variable infos
+    /// (<c>Maximization</c> and <c>Quality</c>).
+    /// </summary>
+    public HeuristicCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "Whether the problem is a maximization problem or not."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>("Quality", "The quality values of the parents."));
+    }
+
+    /// <summary>
+    /// 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="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 DoubleArray Apply(IRandom random, DoubleArray betterParent, DoubleArray worseParent) {
+      if (betterParent.Length != worseParent.Length)
+        throw new ArgumentException("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++) {
+        result[i] = betterParent[i] + factor * (betterParent[i] - worseParent[i]);
+      }
+      return new DoubleArray(result);
+    }
+
+    /// <summary>
+    /// Performs a heuristic crossover operation for two given parent real vectors.
+    /// </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>
+    /// </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 DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents) {
+      if (parents.Length != 2) throw new ArgumentException("HeuristicCrossover: The number of parents is not equal to 2");
+
+      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<DoubleValue> 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]);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/LocalCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/LocalCrossover.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/LocalCrossover.cs	(revision 3051)
@@ -0,0 +1,72 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// The local crossover for real vectors is similar to the <see cref="UniformAllPositionsArithmeticCrossover"/>, but where the factor alpha is chosen randomly in the interval [0;1) for each position.
+  /// </summary>
+  /// <remarks>
+  /// It is implemented as described in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL, p. 194.
+  /// </remarks>
+  [Item("LocalCrossover", @"The local crossover is similar to the arithmetic all positions crossover, but uses a random alpha for each position x = alpha * p1 + (1-alpha) * p2. It is implemented as described in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL., p. 194.")]
+  [StorableClass]
+  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 DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2) {
+      if (parent1.Length != parent2.Length)
+        throw new ArgumentException("LocalCrossover: the two parents are not of the same length");
+      
+      double factor;
+      int length = parent1.Length;
+      double[] result = new double[length];
+
+      for (int i = 0; i < length; i++) {
+        factor = random.NextDouble();
+        result[i] = (factor * parent1[i]) + ((1 - factor) * parent2[i]);
+      }
+      return new DoubleArray(result);
+    }
+
+    /// <summary>
+    /// Performs a local crossover operation for two given parent real vectors.
+    /// </summary>
+    /// <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 DoubleArray Cross(IRandom random, ItemArray<DoubleArray> 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]);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/RandomConvexCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/RandomConvexCrossover.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/RandomConvexCrossover.cs	(revision 3051)
@@ -0,0 +1,70 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// The random convex crossover is similar to the <see cref="LocalCrossover"/>, but chooses just one random alpha for all positions.
+  /// </summary>
+  /// <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", "The random convex crossover acts like the local crossover, but with just one randomly chosen alpha for all crossed positions. It is implementes as described in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL, pp. 193 - 194.")]
+  [StorableClass]
+  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 DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray 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];
+      double factor = random.NextDouble();
+
+      for (int i = 0; i < length; i++)
+        result[i] = (factor * parent1[i]) + ((1 - factor) * parent2[i]);
+      return new DoubleArray(result);
+    }
+
+    /// <summary>
+    /// Performs a random convex crossover operation for two given parent real vectors.
+    /// </summary>
+    /// <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 DoubleArray Cross(IRandom random, ItemArray<DoubleArray> 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]);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/SimulatedBinaryCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/SimulatedBinaryCrossover.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/SimulatedBinaryCrossover.cs	(revision 3051)
@@ -0,0 +1,106 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// Performs the simulated binary crossover (SBX) on a vector of real values such that each position is either crossed contracted or expanded with a certain probability.
+  /// The probability distribution is designed such that the children will lie closer to their parents as is the case with the single point binary crossover.
+  /// </summary>
+  /// <remarks>
+  /// It is implemented as described in Deb, K. and Agrawal, R. B. 1995. Simulated binary crossover for continuous search space. Complex Systems, 9, pp. 115-148.
+  /// </remarks>
+  [Item("SimulatedBinaryCrossover", "The simulated binary crossover (SBX) is implemented as described in Deb, K. and Agrawal, R. B. 1995. Simulated binary crossover for continuous search space. Complex Systems, 9, pp. 115-148.")]
+  [StorableClass]
+  public class SimulatedBinaryCrossover : RealVectorCrossover {
+    /// <summary>
+    /// The parameter must be greater or equal than 0. Common values are in the range [0;5] and more often just [2;5].
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> ContiguityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Contiguity"]; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="SimulatedBinaryCrossover"/> with one 
+    /// parameter (<c>Contiguity</c>).
+    /// </summary>
+    public SimulatedBinaryCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Contiguity", "Specifies whether the crossover should produce very different (small value) or very similar (large value) children. Valid values must be greater or equal to 0.", new DoubleValue(2)));
+    }
+
+    /// <summary>
+    /// Performs the simulated binary crossover on a real vector. Each position is crossed with a probability of 50% and if crossed either a contracting crossover or an expanding crossover is performed, again with equal probability.
+    /// For more details refer to the paper by Deb and Agrawal.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when the parents' vectors are of unequal length or when <paramref name="contiguity"/> is smaller than 0.</exception>
+    /// <remarks>
+    /// The manipulated value is not restricted by the (possibly) specified lower and upper bounds. Use the <see cref="BoundsChecker"/> to correct the values after performing the crossover.
+    /// </remarks>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="parent1">The first parent vector.</param>
+    /// <param name="parent2">The second parent vector.</param>
+    /// <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) {
+      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);
+      for (int i = 0; i < length; i++) {
+        if (length == 1 || random.NextDouble() < 0.5) { // cross this variable
+          double u = random.NextDouble();
+          double beta = 0;
+          if (u < 0.5) { // if u is smaller than 0.5 perform a contracting crossover
+            beta = Math.Pow(2 * u, 1.0 / (contiguity.Value + 1));
+          } else if (u > 0.5) { // otherwise perform an expanding crossover
+            beta = Math.Pow(1.0 / (2 - 2 * u), (contiguity.Value + 1));
+          } else if (u == 0.5)
+            beta = 1;
+
+          if (random.NextDouble() < 0.5)
+            result[i] = ((parent1[i] + parent2[i]) / 2.0) - beta * 0.5 * Math.Abs(parent1[i] - parent2[i]);
+          else
+            result[i] = ((parent1[i] + parent2[i]) / 2.0) + beta * 0.5 * Math.Abs(parent1[i] - parent2[i]);
+        } else result[i] = parent1[i];
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Checks number of parents, availability of the parameters and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArray, DoubleValue)"/>.
+    /// </summary>
+    /// <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 DoubleArray Cross(IRandom random, ItemArray<DoubleArray> 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.");
+      return Apply(random, parents[0], parents[1], ContiguityParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs	(revision 3051)
@@ -0,0 +1,74 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// 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>
+  /// <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.")]
+  [StorableClass]
+  public class SinglePointCrossover : RealVectorCrossover {
+    /// <summary>
+    /// 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 DoubleArray Apply(IRandom random, DoubleArray parent1, DoubleArray parent2) {
+      if (parent1.Length != parent2.Length) throw new ArgumentException("SinglePointCrossover: Parents are of unequal length");
+      int length = parent1.Length;
+      DoubleArray result = new DoubleArray(length);
+      int breakPoint = random.Next(1, length - 1);
+
+      for (int i = 0; i < breakPoint; i++)
+        result[i] = parent1[i];
+      for (int i = breakPoint; i < length; i++)
+        result[i] = parent2[i];
+
+      return result;
+    }
+
+    /// <summary>
+    /// Checks number of parents and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArray)"/>.
+    /// </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.DoubleArray Cross(IRandom random, ItemArray<DoubleArray> 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]);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/UniformAllPositionsArithmeticCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/UniformAllPositionsArithmeticCrossover.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/UniformAllPositionsArithmeticCrossover.cs	(revision 3051)
@@ -0,0 +1,88 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// The uniform all positions arithmetic crossover constructs an offspring by calculating x = alpha * p1 + (1-alpha) * p2 for every position x in the vector.
+  /// </summary>
+  /// <remarks>
+  /// By setting alpha = 0.5 it is the same as the <see cref="AverageCrossover"/>, but only on two parents.
+  /// 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("UniformAllPositionsArithmeticCrossover", "The uniform all positions arithmetic crossover constructs an offspring by calculating x = alpha * p1 + (1-alpha) * p2 for every position x in the vector. Note that for alpha = 0.5 it is the same as the AverageCrossover. 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 UniformAllPositionsArithmeticCrossover : RealVectorCrossover {
+    /// <summary>
+    /// The alpha parameter needs to be in the interval [0;1] and specifies how close the resulting offspring should be either to parent1 (alpha -> 0) or parent2 (alpha -> 1).
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> AlphaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Alpha"]; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance with one parameter (<c>Alpha</c>).
+    /// </summary>
+    public UniformAllPositionsArithmeticCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "The alpha value in the range [0;1]", new DoubleValue(0.33)));
+    }
+
+    /// <summary>
+    /// Performs the arithmetic crossover on all positions by calculating x = alpha * p1 + (1 - alpha) * p2.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when the parent vectors are of different length or alpha is outside the range [0;1].</exception>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="parent1">The first parent vector.</param>
+    /// <param name="parent2">The second parent vector.</param>
+    /// <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) {
+      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);
+      for (int i = 0; i < length; i++) {
+        result[i] = alpha.Value * parent1[i] + (1 - alpha.Value) * parent2[i];
+      }
+      return result;
+    }
+
+    /// <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)"/>.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when there are not exactly two parents.</exception>
+    /// <exception cref="InvalidOperationException">Thrown when the alpha parmeter 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 vector resulting from the crossover.</returns>
+    protected override DoubleArray Cross(IRandom random, ItemArray<DoubleArray> 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.");
+      return Apply(random, parents[0], parents[1], AlphaParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/UniformSomePositionsArithmeticCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/UniformSomePositionsArithmeticCrossover.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Crossovers/UniformSomePositionsArithmeticCrossover.cs	(revision 3051)
@@ -0,0 +1,100 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// The uniform all positions arithmetic crossover (continuous recombination) constructs an offspring by calculating x = alpha * p1 + (1-alpha) * p2 for a position x in the vector with a given probability (otherwise p1 is taken at this position).
+  /// </summary>
+  /// <remarks>
+  /// It is implemented as described in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL, p. 191.<br />
+  /// Note that the implementation is a bit more general than the operator described by Dumitrescu et al. There the alpha parameter was defined to be fixed at 0.5 and thus calculating the average at some positions.
+  /// </remarks>
+  [Item("UniformSomePositionsArithmeticCrossover", "The uniform some positions arithmetic crossover (continuous recombination) constructs an offspring by calculating x = alpha * p1 + (1-alpha) * p2 for a position x in the vector with a given probability (otherwise p1 is taken at this position). It is implemented as described in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL, p. 191. Note that Dumitrescu et al. specify the alpha to be 0.5.")]
+  [StorableClass]
+  public class UniformSomePositionsArithmeticCrossover : RealVectorCrossover {
+    /// <summary>
+    /// The alpha parameter needs to be in the interval [0;1] and specifies how close the resulting offspring should be either to parent1 (alpha -> 0) or parent2 (alpha -> 1).
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> AlphaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Alpha"]; }
+    }
+    /// <summary>
+    /// The probability in the range [0;1] for each position in the vector to be crossed.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> ProbabilityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Probability"]; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance with two parameters (<c>Alpha</c> and <c>Probability</c>).
+    /// </summary>
+    public UniformSomePositionsArithmeticCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "The alpha value in the range [0;1]", new DoubleValue(0.5)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Probability", "The probability for crossing a position in the range [0;1]", new DoubleValue(0.5)));
+    }
+
+    /// <summary>
+    /// Performs the arithmetic crossover on some positions by taking either x = alpha * p1 + (1 - alpha) * p2 or x = p1 depending on the probability for a gene to be crossed.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="parent1">The first parent vector.</param>
+    /// <param name="parent2">The second parent vector.</param>
+    /// <param name="alpha">The alpha parameter (<see cref="AlphaParameter"/>).</param>
+    /// <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) {
+      int length = parent1.Length;
+      if (length != parent2.Length) throw new ArgumentException("UniformSomePositionsArithmeticCrossover: The parent vectors are of different length.", "parent1");
+      if (alpha.Value < 0 || alpha.Value > 1) throw new ArgumentException("UniformSomePositionsArithmeticCrossover: Parameter alpha must be in the range [0;1]", "alpha");
+      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);
+      for (int i = 0; i < length; i++) {
+        if (random.NextDouble() < probability.Value)
+          result[i] = alpha.Value * parent1[i] + (1 - alpha.Value) * parent2[i];
+        else result[i] = parent1[i];
+      }
+      return result;
+    }
+
+    /// <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)"/>.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when there are not exactly two parents.</exception>
+    /// <exception cref="InvalidOperationException">Thrown when either the alpha parmeter or the probability 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 vector resulting from the crossover.</returns>
+    protected override DoubleArray  Cross(IRandom random, ItemArray<DoubleArray> 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.");
+      if (ProbabilityParameter.ActualValue == null) throw new InvalidOperationException("UniformSomePositionsArithmeticCrossover: Parameter " + ProbabilityParameter.ActualName + " could not be found.");
+      return Apply(random, parents[0], parents[1], AlphaParameter.ActualValue, ProbabilityParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVector-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVector-3.3.csproj	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVector-3.3.csproj	(revision 3051)
@@ -0,0 +1,177 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{2D4E4565-3ED9-4BEB-AE75-39D871843D24}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Encodings.RealVector</RootNamespace>
+    <AssemblyName>HeuristicLab.Encodings.RealVector-3.3</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <DocumentationFile>bin\Release\HeuristicLab.Encodings.RealVector-3.3.xml</DocumentationFile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile>bin\x86\Release\HeuristicLab.Encodings.RealVector-3.3.XML</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile>bin\x64\Release\HeuristicLab.Encodings.RealVector-3.3.XML</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLabEncodingsRealVectorPlugin.cs.frame" />
+    <Compile Include="Crossovers\BlendAlphaBetaCrossover.cs" />
+    <Compile Include="Interfaces\IRealVectorManipulator.cs" />
+    <Compile Include="Interfaces\IRealVectorOperator.cs" />
+    <Compile Include="Interfaces\IRealVectorCrossover.cs" />
+    <Compile Include="Interfaces\IRealVectorCreator.cs" />
+    <Compile Include="BoundsChecker.cs" />
+    <Compile Include="Creators\UniformRandomRealVectorCreator.cs" />
+    <Compile Include="RealVectorCreator.cs" />
+    <Compile Include="RealVectorCrossover.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RealVectorManipulator.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Crossovers\AverageCrossover.cs" />
+    <Compile Include="Crossovers\BlendAlphaCrossover.cs" />
+    <Compile Include="Crossovers\DiscreteCrossover.cs" />
+    <Compile Include="Crossovers\HeuristicCrossover.cs" />
+    <Compile Include="Crossovers\LocalCrossover.cs" />
+    <Compile Include="Crossovers\RandomConvexCrossover.cs" />
+    <Compile Include="Crossovers\SimulatedBinaryCrossover.cs" />
+    <Compile Include="Crossovers\SinglePointCrossover.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Crossovers\UniformAllPositionsArithmeticCrossover.cs" />
+    <Compile Include="Crossovers\UniformSomePositionsArithmeticCrossover.cs" />
+    <Compile Include="HeuristicLabEncodingsRealVectorPlugin.cs" />
+    <Compile Include="Manipulators\BreederGeneticAlgorithmManipulator.cs" />
+    <Compile Include="Manipulators\PolynomialAllPositionManipulator.cs" />
+    <Compile Include="Manipulators\MichalewiczNonUniformAllPositionsManipulator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Manipulators\MichalewiczNonUniformOnePositionManipulator.cs" />
+    <Compile Include="Manipulators\PolynomialOnePositionManipulator.cs" />
+    <Compile Include="Manipulators\SelfAdaptiveNormalAllPositionsManipulator.cs" />
+    <Compile Include="Manipulators\UniformOnePositionManipulator.cs" />
+    <None Include="HeuristicLab.snk" />
+    <None Include="Properties\AssemblyInfo.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common\3.2\HeuristicLab.Common-3.2.csproj">
+      <Project>{1FC004FC-59AF-4249-B1B6-FF25873A20E4}</Project>
+      <Name>HeuristicLab.Common-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{F43B59AB-2B8C-4570-BC1E-15592086517C}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
+      <Project>{F473D9AF-3F09-4296-9F28-3C65118DAFFA}</Project>
+      <Name>HeuristicLab.Data-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Operators\3.3\HeuristicLab.Operators-3.3.csproj">
+      <Project>{23DA7FF4-D5B8-41B6-AA96-F0561D24F3EE}</Project>
+      <Name>HeuristicLab.Operators-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
+      <Project>{14AB8D24-25BC-400C-A846-4627AA945192}</Project>
+      <Name>HeuristicLab.Optimization-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">
+      <Project>{56F9106A-079F-4C61-92F6-86A84C2D84B7}</Project>
+      <Name>HeuristicLab.Parameters-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
+      <Project>{102BC7D3-0EF9-439C-8F6D-96FF0FDB8E1B}</Project>
+      <Name>HeuristicLab.Persistence-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\HeuristicLab.PluginInfrastructure.csproj">
+      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
+      <Name>HeuristicLab.PluginInfrastructure</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Random\3.3\HeuristicLab.Random-3.3.csproj">
+      <Project>{F4539FB6-4708-40C9-BE64-0A1390AEA197}</Project>
+      <Name>HeuristicLab.Random-3.3</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+SubWCRev "%25ProjectDir%25\" "%25ProjectDir%25\HeuristicLabEncodingsRealVectorPlugin.cs.frame" "%25ProjectDir%25\HeuristicLabEncodingsRealVectorPlugin.cs"</PreBuildEvent>
+  </PropertyGroup>
+</Project>
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLabEncodingsRealVectorPlugin.cs.frame
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLabEncodingsRealVectorPlugin.cs.frame	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLabEncodingsRealVectorPlugin.cs.frame	(revision 3051)
@@ -0,0 +1,40 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Encodings.RealVector plugin.
+  /// </summary>
+  [Plugin("HeuristicLab.Encodings.RealVector", "3.3.0.$WCREV$")]
+  [PluginFile("HeuristicLab.Encodings.RealVector-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.2")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  public class HeuristicLabEncodingsRealVectorPlugin : PluginBase {
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorCreator.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorCreator.cs	(revision 3051)
@@ -0,0 +1,36 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// An interface which represents an operator for creating vectors of real-valued data.
+  /// </summary>
+  public interface IRealVectorCreator : IRealVectorOperator, ISolutionCreator {
+    IValueLookupParameter<IntValue> LengthParameter { get; }
+    IValueLookupParameter<DoubleValue> MinimumParameter { get; }
+    IValueLookupParameter<DoubleValue> MaximumParameter { get; }
+    ILookupParameter<DoubleArray> RealVectorParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorCrossover.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorCrossover.cs	(revision 3051)
@@ -0,0 +1,34 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// An interface which represents an operator for crossing vectors of real-valued data.
+  /// </summary>
+  public interface IRealVectorCrossover : IRealVectorOperator, ICrossover {
+    ILookupParameter<ItemArray<DoubleArray>> ParentsParameter { get; }
+    ILookupParameter<DoubleArray> ChildParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorManipulator.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorManipulator.cs	(revision 3051)
@@ -0,0 +1,33 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// An interface which represents an operator for manipulating vectors of real-valued data.
+  /// </summary>
+  public interface IRealVectorManipulator : IRealVectorOperator, IManipulator {
+    ILookupParameter<DoubleArray> RealVectorParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorOperator.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorOperator.cs	(revision 3051)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// An interface which represents an operator dealing with vectors of real-valued data.
+  /// </summary>
+  public interface IRealVectorOperator : IOperator { }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/BreederGeneticAlgorithmManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/BreederGeneticAlgorithmManipulator.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/BreederGeneticAlgorithmManipulator.cs	(revision 3051)
@@ -0,0 +1,127 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// Changes one position of a real vector by adding/substracting a value of the interval [(2^-15)*range;~2*range], where range is SearchIntervalFactor * (max - min).
+  /// Note that the interval is not uniformly sampled, but smaller values are sampled more often.
+  /// </summary>
+  /// <remarks>
+  /// It is implemented as described by Mühlenbein, H. and Schlierkamp-Voosen, D. 1993. Predictive Models for the Breeder Genetic Algorithm - I. Continuous Parameter Optimization. Evolutionary Computation, 1(1), pp. 25-49.<br/>
+  /// </remarks>
+  [Item("BreederGeneticAlgorithmManipulator", "It is implemented as described by Mühlenbein, H. and Schlierkamp-Voosen, D. 1993. Predictive Models for the Breeder Genetic Algorithm - I. Continuous Parameter Optimization. Evolutionary Computation, 1(1), pp. 25-49.")]
+  [StorableClass]
+  public class BreederGeneticAlgorithmManipulator : RealVectorManipulator {
+    private static readonly double[] powerOfTwo = new double[] { 1, 0.5, 0.25, 0.125, 0.0625, 0.03125, 0.015625, 0.0078125, 0.00390625, 0.001953125, 0.0009765625, 0.00048828125, 0.000244140625, 0.0001220703125, 0.00006103515625, 0.000030517578125 };
+    public ValueLookupParameter<DoubleValue> MinimumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Minimum"]; }
+    }
+    public ValueLookupParameter<DoubleValue> MaximumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Maximum"]; }
+    }
+    public ValueLookupParameter<DoubleValue> SearchIntervalFactorParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["SearchIntervalFactor"]; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="BreederGeneticAlgorithmManipulator"/> with three variable
+    /// infos (<c>Minimum</c>, <c>Maximum</c> and <c>SearchIntervalFactor</c>).
+    /// </summary>
+    public BreederGeneticAlgorithmManipulator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Minimum", "The lower bound for each element in the vector."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Maximum", "The upper bound for each element in the vector."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("SearchIntervalFactor", "The factor determining the size of the search interval, that will be added/removed to/from the allele selected for manipulation.", new DoubleValue(0.1)));
+    }
+
+    /// <summary>
+    /// Performs a breeder genetic algorithm manipulation on the given <paramref name="vector"/>.
+    /// </summary>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="vector">The real vector to manipulate.</param>
+    /// <param name="min">The minimum number of the sampling range for the vector element (inclusive).</param>
+    /// <param name="max">The maximum number of the sampling range for the vector element (exclusive).</param>
+    /// <param name="searchIntervalFactor">The factor determining the size of the search interval.</param>
+    public static void Apply(IRandom random, DoubleArray vector, DoubleValue min, DoubleValue max, DoubleValue searchIntervalFactor) {
+      int length = vector.Length;
+      double prob, value;
+      do {
+        value = Sigma(random);
+      } while (value == 0);
+      value *= searchIntervalFactor.Value * (max.Value - min.Value);
+
+      prob = 1.0 / (double)length;
+      bool wasMutated = false;
+
+      for (int i = 0; i < length; i++) {
+        if (random.NextDouble() < prob) {
+          if (random.NextDouble() < 0.5) {
+            vector[i] = vector[i] + value;
+          } else {
+            vector[i] = vector[i] - value;
+          }
+          wasMutated = true;
+        }
+      }
+
+      // make sure at least one gene was mutated
+      if (!wasMutated) {
+        int pos = random.Next(length);
+        if (random.NextDouble() < 0.5) {
+          vector[pos] = vector[pos] + value;
+        } else {
+          vector[pos] = vector[pos] - value;
+        }
+      }
+    }
+
+    private static double Sigma(IRandom random) {
+      double sigma = 0;
+      int limit = 16;
+
+      for (int i = 0; i < limit; i++) {
+        if (random.Next(limit) == 15) {
+          // execute this statement with a probability of 1/16
+          sigma += powerOfTwo[i];
+        }
+      }
+
+      return sigma;
+    }
+
+    /// <summary>
+    /// Checks the parameters Minimum, Maximum, and SearchIntervalFactor and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleValue, DoubleValue, DoubleValue)"/>.
+    /// </summary>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="realVector">The real vector to manipulate.</param>
+    protected override void Manipulate(IRandom random, DoubleArray realVector) {
+      if (MinimumParameter.ActualValue == null) throw new InvalidOperationException("BreederGeneticAlgorithmManipulator: Parameter " + MinimumParameter.ActualName + " could not be found.");
+      if (MaximumParameter.ActualValue == null) throw new InvalidOperationException("BreederGeneticAlgorithmManipulator: Paraemter " + MaximumParameter.ActualName + " could not be found.");
+      if (SearchIntervalFactorParameter.ActualValue == null) throw new InvalidOperationException("BreederGeneticAlgorithmManipulator: Paraemter " + SearchIntervalFactorParameter.ActualName + " could not be found.");
+      Apply(random, realVector, MinimumParameter.ActualValue, MaximumParameter.ActualValue, SearchIntervalFactorParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/MichalewiczNonUniformAllPositionsManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/MichalewiczNonUniformAllPositionsManipulator.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/MichalewiczNonUniformAllPositionsManipulator.cs	(revision 3051)
@@ -0,0 +1,126 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// The solution is manipulated with diminishing strength over time. In addition the mutated values are not sampled over the entire domain, but additive.<br/>
+  /// Initially, the space will be searched uniformly and very locally at later stages. This increases the probability of generating the new numbers closer to the current value.
+  /// </summary>
+  /// <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("MichalewiczNonUniformOnePositionManipulator", "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 MichalewiczNonUniformAllPositionsManipulator : RealVectorManipulator {
+    /// <summary>
+    /// The lower bound of the values in the real vector.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> MinimumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Minimum"]; }
+    }
+    /// <summary>
+    /// The upper bound of the values in the real vector.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> MaximumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Maximum"]; }
+    }
+    /// <summary>
+    /// The current generation.
+    /// </summary>
+    public LookupParameter<IntValue> GenerationParameter {
+      get { return (LookupParameter<IntValue>)Parameters["Generation"]; }
+    }
+    /// <summary>
+    /// The maximum generation.
+    /// </summary>
+    public LookupParameter<IntValue> MaximumGenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters["MaximumGenerations"]; }
+    }
+    /// <summary>
+    /// The parameter describing how much the mutation should depend on the progress towards the maximum generation.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> GenerationDependencyParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["GenerationDependency"]; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="MichalewiczNonUniformAllPositionsManipulator"/> with
+    /// five parameters (<c>Minimum</c>, <c>Maximum</c>, <c>CurrentGeneration</c>, 
+    /// <c>MaximumGenerations</c> and <c>GenerationDependency</c>).
+    /// </summary>
+    public MichalewiczNonUniformAllPositionsManipulator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Minimum", "Minimum of the sampling range for the vector element (included)"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
+      Parameters.Add(new LookupParameter<IntValue>("Generation", "Current generation of the algorithm"));
+      Parameters.Add(new LookupParameter<IntValue>("MaximumGenerations", "Maximum number of generations"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("GenerationDependency", "Specifies the degree of dependency on the number of generations", new DoubleValue(5)));
+    }
+
+    /// <summary>
+    /// Performs a non uniformly distributed all position manipulation on the given 
+    /// real <paramref name="vector"/>. The probability of stronger mutations reduces the more <see cref="currentGeneration"/> approaches <see cref="maximumGenerations"/>.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when <paramref name="currentGeneration"/> is greater than <paramref name="maximumGenerations"/>.</exception>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="vector">The real vector to manipulate.</param>
+    /// <param name="min">The minimum value of the sampling range for the vector element (inclusive).</param>
+    /// <param name="max">The maximum value of the sampling range for the vector element (exclusive).</param>
+    /// <param name="currentGeneration">The current generation of the algorithm.</param>
+    /// <param name="maximumGenerations">Maximum number of generations.</param>
+    /// <param name="generationsDependency">Specifies the degree of dependency on the number of generations.</param>
+    /// <returns>The manipulated real vector.</returns>
+    public static void Apply(IRandom random, DoubleArray vector, DoubleValue min, DoubleValue max, IntValue currentGeneration, IntValue maximumGenerations, DoubleValue generationsDependency) {
+      if (currentGeneration.Value > maximumGenerations.Value) throw new ArgumentException("MichalewiczNonUniformAllPositionManipulator: CurrentGeneration must be smaller or equal than MaximumGeneration", "currentGeneration");
+      int length = vector.Length;
+
+      double prob = Math.Pow(1 - currentGeneration.Value / maximumGenerations.Value, generationsDependency.Value);
+
+      for (int i = 0; i < length; i++) {
+        if (random.NextDouble() < 0.5) {
+          vector[i] = vector[i] + (max.Value - vector[i]) * (1 - Math.Pow(random.NextDouble(), prob));
+        } else {
+          vector[i] = vector[i] - (vector[i] - min.Value) * (1 - Math.Pow(random.NextDouble(), prob));
+        }
+      }
+    }
+
+    /// <summary>
+    /// Checks if all parameters are available and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleValue, DoubleValue, IntValue, IntValue, DoubleValue)"/>.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="realVector">The real vector that should be manipulated.</param>
+    protected override void Manipulate(IRandom random, DoubleArray realVector) {
+      if (MinimumParameter.ActualValue == null) throw new InvalidOperationException("MichalewiczNonUniformAllPositionManipulator: Parameter " + MinimumParameter.ActualName + " could not be found.");
+      if (MaximumParameter.ActualValue == null) throw new InvalidOperationException("MichalewiczNonUniformAllPositionManipulator: Parameter " + MaximumParameter.ActualName + " could not be found.");
+      if (GenerationParameter.ActualValue == null) throw new InvalidOperationException("MichalewiczNonUniformAllPositionManipulator: Parameter " + GenerationParameter.ActualName + " could not be found.");
+      if (MaximumGenerationsParameter.ActualValue == null) throw new InvalidOperationException("MichalewiczNonUniformAllPositionManipulator: Parameter " + MaximumGenerationsParameter.ActualName + " could not be found.");
+      if (GenerationDependencyParameter.ActualValue == null) throw new InvalidOperationException("MichalewiczNonUniformAllPositionManipulator: Parameter " + GenerationDependencyParameter.ActualName + " could not be found.");
+      Apply(random, realVector, MinimumParameter.ActualValue, MaximumParameter.ActualValue, GenerationParameter.ActualValue, MaximumGenerationsParameter.ActualValue, GenerationDependencyParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/MichalewiczNonUniformOnePositionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/MichalewiczNonUniformOnePositionManipulator.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/MichalewiczNonUniformOnePositionManipulator.cs	(revision 3051)
@@ -0,0 +1,125 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// The solution is manipulated with diminishing strength over time. In addition the mutated value is not sampled over the entire domain, but additive at the selected position.<br/>
+  /// Initially, the space will be searched uniformly and very locally at later stages. This increases the probability of generating the new number closer to the current value.
+  /// </summary>
+  /// <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("MichalewiczNonUniformOnePositionManipulator", "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 MichalewiczNonUniformOnePositionManipulator : RealVectorManipulator {
+    /// <summary>
+    /// The lower bound of the values in the real vector.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> MinimumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Minimum"]; }
+    }
+    /// <summary>
+    /// The upper bound of the values in the real vector.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> MaximumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Maximum"]; }
+    }
+    /// <summary>
+    /// The current generation.
+    /// </summary>
+    public LookupParameter<IntValue> GenerationParameter {
+      get { return (LookupParameter<IntValue>)Parameters["Generation"]; }
+    }
+    /// <summary>
+    /// The maximum generation.
+    /// </summary>
+    public LookupParameter<IntValue> MaximumGenerationsParameter {
+      get { return (LookupParameter<IntValue>)Parameters["MaximumGenerations"]; }
+    }
+    /// <summary>
+    /// The parameter describing how much the mutation should depend on the progress towards the maximum generation.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> GenerationDependencyParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["GenerationDependency"]; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="MichalewiczNonUniformOnePositionManipulator"/> with five 
+    /// parameters (<c>Minimum</c>, <c>Maximum</c>, <c>CurrentGeneration</c>, <c>MaximumGenerations</c>
+    /// and <c>GenerationDependency</c>).
+    /// </summary>
+    public MichalewiczNonUniformOnePositionManipulator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Minimum", "Minimum of the sampling range for the vector element (included)"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
+      Parameters.Add(new LookupParameter<IntValue>("Generation", "Current generation of the algorithm"));
+      Parameters.Add(new LookupParameter<IntValue>("MaximumGenerations", "Maximum number of generations"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("GenerationDependency", "Specifies the degree of dependency on the number of generations", new DoubleValue(5)));
+    }
+
+    /// <summary>
+    /// Performs a non uniformly distributed one position manipulation on the given 
+    /// real <paramref name="vector"/>. The probability of stronger mutations reduces the more <see cref="currentGeneration"/> approaches <see cref="maximumGenerations"/>.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when <paramref name="currentGeneration"/> is greater than <paramref name="maximumGenerations"/>.</exception>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="vector">The real vector to manipulate.</param>
+    /// <param name="min">The minimum value of the sampling range for the vector element (inclusive).</param>
+    /// <param name="max">The maximum value of the sampling range for the vector element (exclusive).</param>
+    /// <param name="currentGeneration">The current generation of the algorithm.</param>
+    /// <param name="maximumGenerations">Maximum number of generations.</param>
+    /// <param name="generationsDependency">Specifies the degree of dependency on the number of generations.</param>
+    /// <returns>The manipulated real vector.</returns>
+    public static void Apply(IRandom random, DoubleArray vector, DoubleValue min, DoubleValue max, IntValue currentGeneration, IntValue maximumGenerations, DoubleValue generationsDependency) {
+      if (currentGeneration.Value > maximumGenerations.Value) throw new ArgumentException("MichalewiczNonUniformOnePositionManipulator: CurrentGeneration must be smaller or equal than MaximumGeneration", "currentGeneration");
+      int length = vector.Length;
+      int index = random.Next(length);
+
+      double prob = (1 - Math.Pow(random.NextDouble(), Math.Pow(1 - currentGeneration.Value / maximumGenerations.Value, generationsDependency.Value)));
+
+      if (random.NextDouble() < 0.5) {
+        vector[index] = vector[index] + (max.Value - vector[index]) * prob;
+      } else {
+        vector[index] = vector[index] - (vector[index] - min.Value) * prob;
+      }
+    }
+
+    /// <summary>
+    /// Checks if all parameters are available and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleValue, DoubleValue, IntValue, IntValue, DoubleValue)"/>.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="realVector">The real vector that should be manipulated.</param>
+    protected override void Manipulate(IRandom random, DoubleArray realVector) {
+      if (MinimumParameter.ActualValue == null) throw new InvalidOperationException("MichalewiczNonUniformOnePositionManipulator: Parameter " + MinimumParameter.ActualName + " could not be found.");
+      if (MaximumParameter.ActualValue == null) throw new InvalidOperationException("MichalewiczNonUniformOnePositionManipulator: Parameter " + MaximumParameter.ActualName + " could not be found.");
+      if (GenerationParameter.ActualValue == null) throw new InvalidOperationException("MichalewiczNonUniformOnePositionManipulator: Parameter " + GenerationParameter.ActualName + " could not be found.");
+      if (MaximumGenerationsParameter.ActualValue == null) throw new InvalidOperationException("MichalewiczNonUniformOnePositionManipulator: Parameter " + MaximumGenerationsParameter.ActualName + " could not be found.");
+      if (GenerationDependencyParameter.ActualValue == null) throw new InvalidOperationException("MichalewiczNonUniformOnePositionManipulator: Parameter " + GenerationDependencyParameter.ActualName + " could not be found.");
+      Apply(random, realVector, MinimumParameter.ActualValue, MaximumParameter.ActualValue, GenerationParameter.ActualValue, MaximumGenerationsParameter.ActualValue, GenerationDependencyParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/PolynomialAllPositionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/PolynomialAllPositionManipulator.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/PolynomialAllPositionManipulator.cs	(revision 3051)
@@ -0,0 +1,100 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// Performs the polynomial manipulation on all positions in the real vector.
+  /// </summary>
+  /// <remarks>
+  /// The polynomial manipulation is implemented as described in Deb, K. & Goyal, M. A. 1996. Combined Genetic Adaptive Search (GeneAS) for Engineering Design Computer Science and Informatics, 26, pp. 30-45.
+  /// It is performed on all positions of a real vector.
+  /// </remarks>
+  [Item("PolynomialAllPositionManipulator", "The polynomial manipulation is implemented as described in Deb, K. & Goyal, M. A. 1996. Combined Genetic Adaptive Search (GeneAS) for Engineering Design Computer Science and Informatics, 26, pp. 30-45. In this operator it is performed on all positions of the real vector.")]
+  [StorableClass]
+  public class PolynomialAllPositionManipulator : RealVectorManipulator {
+    /// <summary>
+    /// The contiguity parameter specifies the shape of the probability density function that controls the mutation. Setting it to 0 is similar to a uniform distribution over the entire manipulation range (specified by <see cref="MaximumManipulationParameter"/>.
+    /// A higher value will shape the density function such that values closer to 0 (little manipulation) are more likely than values closer to 1 or -1 (maximum manipulation).
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> ContiguityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Contiguity"]; }
+    }
+    /// <summary>
+    /// The maximum manipulation parameter specifies the range of the manipulation. The value specified here is the highest value the mutation will ever add to the current value.
+    /// </summary>
+    /// <remarks>
+    /// The manipulated value is not restricted by the (possibly) specified lower and upper bounds. Use the <see cref="BoundsChecker"/> to correct the values after performing the mutation.
+    /// </remarks>
+    public ValueLookupParameter<DoubleValue> MaximumManipulationParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["MaximumManipulation"]; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="PolynomialAllPositionManipulator"/> with two parameters
+    /// (<c>Contiguity</c> and <c>MaximumManipulation</c>).
+    /// </summary>
+    public PolynomialAllPositionManipulator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Contiguity", "Specifies whether the manipulation should produce far stretching (small value) or close (large value) manipulations with higher probability. Valid values must be greater or equal to 0.", new DoubleValue(2)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumManipulation", "Specifies the maximum value that should be added or subtracted by the manipulation. If this value is set to 0 no mutation will be performed.", new DoubleValue(1)));
+    }
+
+    /// <summary>
+    /// Performs the polynomial mutation on a single position in the real vector.
+    /// </summary>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="vector">The vector that should be manipulated.</param>
+    /// <param name="contiguity">A parameter describing the shape of the probability density function which influences the strength of the manipulation.</param>
+    /// <param name="maxManipulation">The maximum strength of the manipulation.</param>
+    public static void Apply(IRandom random, DoubleArray vector, DoubleValue contiguity, DoubleValue maxManipulation) {
+      if (contiguity.Value < 0) throw new ArgumentException("PolynomialAllPositionManipulator: Contiguity value is smaller than 0", "contiguity");
+      double u, delta = 0;
+
+      for (int index = 0; index < vector.Length; index++) {
+        u = random.NextDouble();
+        if (u < 0.5) {
+          delta = Math.Pow(2 * u, 1.0 / (contiguity.Value + 1)) - 1.0;
+        } else if (u > 0.5) {
+          delta = 1.0 - Math.Pow(2.0 - 2.0 * u, 1.0 / contiguity.Value + 1);
+        } else if (u == 0.5) delta = 0;
+
+        vector[index] += delta * maxManipulation.Value;
+      }
+    }
+
+    /// <summary>
+    /// Checks the availability of the parameters and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleValue, DoubleValue)"/>.
+    /// </summary>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="realVector">The vector of real values to manipulate.</param>
+    protected override void Manipulate(IRandom random, DoubleArray realVector) {
+      if (ContiguityParameter.ActualValue == null) throw new InvalidOperationException("PolynomialAllPositionManipulator: Parameter " + ContiguityParameter.ActualName + " could not be found.");
+      if (MaximumManipulationParameter.ActualValue == null) throw new InvalidOperationException("PolynomialAllPositionManipulator: Parameter " + MaximumManipulationParameter.ActualName + " could not be found.");
+      Apply(random, realVector, ContiguityParameter.ActualValue, MaximumManipulationParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/PolynomialOnePositionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/PolynomialOnePositionManipulator.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/PolynomialOnePositionManipulator.cs	(revision 3051)
@@ -0,0 +1,97 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// Performs the polynomial manipulation on a randomly chosen single position in the real vector.
+  /// </summary>
+  /// <remarks>
+  /// It is implemented as described in Deb, K. & Goyal, M. A. 1996. Combined Genetic Adaptive Search (GeneAS) for Engineering Design Computer Science and Informatics, 26, pp. 30-45.
+  /// </remarks>
+  [Item("PolynomialOnePositionManipulator", "The polynomial manipulation is implemented as described in Deb, K. & Goyal, M. A. 1996. Combined Genetic Adaptive Search (GeneAS) for Engineering Design Computer Science and Informatics, 26, pp. 30-45. In this operator it is performed on a single randomly chosen position of the real vector.")]
+  [StorableClass]
+  public class PolynomialOnePositionManipulator : RealVectorManipulator {
+    /// <summary>
+    /// The contiguity parameter specifies the shape of the probability density function that controls the mutation. Setting it to 0 is similar to a uniform distribution over the entire manipulation range (specified by <see cref="MaximumManipulationParameter"/>.
+    /// A higher value will shape the density function such that values closer to 0 (little manipulation) are more likely than values closer to 1 or -1 (maximum manipulation).
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> ContiguityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Contiguity"]; }
+    }
+    /// <summary>
+    /// The maximum manipulation parameter specifies the range of the manipulation. The value specified here is the highest value the mutation will ever add to the current value.
+    /// </summary>
+    /// <remarks>
+    /// The manipulated value is not restricted by the (possibly) specified lower and upper bounds. Use the <see cref="BoundsChecker"/> to correct the values after performing the mutation.
+    /// </remarks>
+    public ValueLookupParameter<DoubleValue> MaximumManipulationParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["MaximumManipulation"]; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="PolynomialOnePositionManipulator"/> with two parameters
+    /// (<c>Contiguity</c> and <c>MaximumManipulation</c>).
+    /// </summary>
+    public PolynomialOnePositionManipulator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Contiguity", "Specifies whether the manipulation should produce far stretching (small value) or close (large value) manipulations with higher probability. Valid values must be greater or equal to 0.", new DoubleValue(2)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumManipulation", "Specifies the maximum value that should be added or subtracted by the manipulation. If this value is set to 0 no mutation will be performed.", new DoubleValue(1)));
+    }
+
+    /// <summary>
+    /// Performs the polynomial mutation on a single position in the real vector.
+    /// </summary>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="vector">The vector that should be manipulated.</param>
+    /// <param name="contiguity">A parameter describing the shape of the probability density function which influences the strength of the manipulation.</param>
+    /// <param name="maxManipulation">The maximum strength of the manipulation.</param>
+    public static void Apply(IRandom random, DoubleArray vector, DoubleValue contiguity, DoubleValue maxManipulation) {
+      if (contiguity.Value < 0) throw new ArgumentException("PolynomialOnePositionManipulator: Contiguity value is smaller than 0", "contiguity");
+      int index = random.Next(vector.Length);
+      double u = random.NextDouble(), delta = 0;
+
+      if (u < 0.5) {
+        delta = Math.Pow(2 * u, 1.0 / (contiguity.Value + 1)) - 1.0;
+      } else if (u > 0.5) {
+        delta = 1.0 - Math.Pow(2.0 - 2.0 * u, 1.0 / contiguity.Value + 1);
+      } else if (u == 0.5) delta = 0;
+
+      vector[index] += delta * maxManipulation.Value;
+    }
+
+    /// <summary>
+    /// Checks the availability of the parameters and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleValue, DoubleValue)"/>.
+    /// </summary>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="realVector">The vector of real values to manipulate.</param>
+    protected override void Manipulate(IRandom random, DoubleArray realVector) {
+      if (ContiguityParameter.ActualValue == null) throw new InvalidOperationException("PolynomialOnePositionManipulator: Parameter " + ContiguityParameter.ActualName + " could not be found.");
+      if (MaximumManipulationParameter.ActualValue == null) throw new InvalidOperationException("PolynomialOnePositionManipulator: Parameter " + MaximumManipulationParameter.ActualName + " could not be found.");
+      Apply(random, realVector, ContiguityParameter.ActualValue, MaximumManipulationParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/SelfAdaptiveNormalAllPositionsManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/SelfAdaptiveNormalAllPositionsManipulator.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/SelfAdaptiveNormalAllPositionsManipulator.cs	(revision 3051)
@@ -0,0 +1,83 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// Manipulates each dimension in the real vector with the mutation strength given 
+  /// in the strategy parameter vector.
+  /// </summary>
+  /// <remarks>
+  /// It is implemented as described in Beyer, H.-G. and Schwefel, H.-P. 2002. Evolution Strategies - A Comprehensive Introduction Natural Computing, 1, pp. 3-52.<br/>
+  /// The strategy vector can be of smaller length than the solution vector, in which case values are taken from the beginning again once the end of the strategy vector is reached.
+  /// </remarks>
+  [Item("SelfAdaptiveNormalAllPositionsManipulator", "This manipulation operator adds a value sigma_i * N(0,1) to the current value in each position i. The values for sigma_i are taken from the strategy vector. It is implemented as described in Beyer, H.-G. and Schwefel, H.-P. 2002. Evolution Strategies - A Comprehensive Introduction Natural Computing, 1, pp. 3-52.")]
+  [StorableClass]
+  public class SelfAdaptiveNormalAllPositionsManipulator : RealVectorManipulator {
+    /// <summary>
+    /// Parameter for the strategy vector.
+    /// </summary>
+    public LookupParameter<DoubleArray> StrategyVectorParameter {
+      get { return (LookupParameter<DoubleArray>)Parameters["StrategyVector"]; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="SelfAdaptiveNormalAllPositionsManipulator"/> with one
+    /// parameter (<c>StrategyVector</c>).
+    /// </summary>
+    public SelfAdaptiveNormalAllPositionsManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleArray>("StrategyVector", "The vector containing the endogenous strategy parameters."));
+    }
+
+    /// <summary>
+    /// Performs an adaptive normally distributed all position manipulation on the given 
+    /// <paramref name="vector"/>.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown when the strategy vector is not
+    /// as long as the vector to get manipulated.</exception>
+    /// <param name="strategyParameters">The strategy vector determining the strength of the mutation.</param>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="vector">The real vector to manipulate.</param>
+    /// <returns>The manipulated real vector.</returns>
+    public static void Apply(IRandom random, DoubleArray vector, DoubleArray strategyParameters) {
+      NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0);
+      for (int i = 0; i < vector.Length; i++) {
+        vector[i] = vector[i] + (N.NextDouble() * strategyParameters[i % strategyParameters.Length]);
+      }
+    }
+
+    /// <summary>
+    /// Checks that the strategy vector is not null and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleArray)"/>.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="realVector">The vector of real values that is manipulated.</param>
+    protected override void Manipulate(IRandom random, DoubleArray realVector) {
+      if (StrategyVectorParameter.ActualValue == null) throw new InvalidOperationException("SelfAdaptiveNormalAllPositionsManipulator: Parameter " + StrategyVectorParameter.ActualName + " could not be found.");
+      Apply(random, realVector, StrategyVectorParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/UniformOnePositionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/UniformOnePositionManipulator.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/UniformOnePositionManipulator.cs	(revision 3051)
@@ -0,0 +1,85 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+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 in a real vector.
+  /// </summary>
+  /// <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.")]
+  [StorableClass]
+  public class UniformOnePositionManipulator : RealVectorManipulator {
+    /// <summary>
+    /// The lower bound of the values in the real vector.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> MinimumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Minimum"]; }
+    }
+    /// <summary>
+    /// The upper bound of the values in the real vector.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> MaximumParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Maximum"]; }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="UniformOnePositionManipulator"/> with two parameters
+    /// (<c>Minimum</c> and <c>Maximum</c>).
+    /// </summary>
+    public UniformOnePositionManipulator() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Minimum", "Minimum of the sampling range for the vector element (included)"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
+    }
+
+    /// <summary>
+    /// Changes randomly a single position in the given real <paramref name="vector"/>.
+    /// </summary>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="vector">The real vector to manipulate.</param>
+    /// <param name="min">The minimum value of the sampling range for 
+    /// the vector element to change (inclusive).</param>
+    /// <param name="max">The maximum value of the sampling range for
+    /// the vector element to change (exclusive).</param>
+    public static void Apply(IRandom random, DoubleArray vector, DoubleValue min, DoubleValue max) {
+      int index = random.Next(vector.Length);
+      vector[index] = min.Value + random.NextDouble() * (max.Value - min.Value);
+    }
+
+    /// <summary>
+    /// Checks if the minimum and maximum parameters are available and forwards the call to <see cref="Apply(IRandom, DoubleArray, DoubleValue, DoubleValue)"/>.
+    /// </summary>
+    /// <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, DoubleArray 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);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Properties/AssemblyInfo.frame
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Properties/AssemblyInfo.frame	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Properties/AssemblyInfo.frame	(revision 3051)
@@ -0,0 +1,57 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Encodings.RealVector")]
+[assembly: AssemblyDescription("HeuristicLab real vector operators")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2010 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("4da6c9ad-b15d-4960-b010-d12318948e2d")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.0.$WCREV$")]
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCreator.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCreator.cs	(revision 3051)
@@ -0,0 +1,72 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// A base class for operators creating real-valued vectors.
+  /// </summary>
+  [Item("RealVectorCreator", "A base class for operators creating real-valued vectors.")]
+  [StorableClass]
+  public abstract class RealVectorCreator : SingleSuccessorOperator, IRealVectorCreator, IStochasticOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<DoubleArray> RealVectorParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["RealVector"]; }
+    }
+    public IValueLookupParameter<IntValue> LengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Length"]; }
+    }
+    public IValueLookupParameter<DoubleValue> MinimumParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Minimum"]; }
+    }
+    public IValueLookupParameter<DoubleValue> MaximumParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Maximum"]; }
+    }
+
+    protected RealVectorCreator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new LookupParameter<DoubleArray>("RealVector", "The vector which should be manipulated."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Length", "The length of the vector."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Minimum", "The lower bound for each element in the vector."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Maximum", "The upper bound for each element in the vector."));
+    }
+
+    public sealed override IOperation Apply() {
+      RealVectorParameter.ActualValue = Create(RandomParameter.ActualValue, LengthParameter.ActualValue, MinimumParameter.ActualValue, MaximumParameter.ActualValue);
+      return base.Apply();
+    }
+
+    protected abstract DoubleArray Create(IRandom random, IntValue length, DoubleValue minimum, DoubleValue maximum);
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCrossover.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCrossover.cs	(revision 3051)
@@ -0,0 +1,64 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// A base class for operators that perform a crossover of real-valued vectors.
+  /// </summary>
+  [Item("RealVectorCrossover", "A base class for operators that perform a crossover of real-valued vectors.")]
+  [StorableClass]
+  public abstract class RealVectorCrossover : SingleSuccessorOperator, IRealVectorCrossover, IStochasticOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemArray<DoubleArray>> ParentsParameter {
+      get { return (SubScopesLookupParameter<DoubleArray>)Parameters["Parents"]; }
+    }
+    public ILookupParameter<DoubleArray> ChildParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Child"]; }
+    }
+
+    protected RealVectorCrossover()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
+      Parameters.Add(new SubScopesLookupParameter<DoubleArray>("Parents", "The parent vectors which should be crossed."));
+      Parameters.Add(new LookupParameter<DoubleArray>("Child", "The child vector resulting from the crossover."));
+    }
+
+    public sealed override IOperation Apply() {
+      ChildParameter.ActualValue = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
+      return base.Apply();
+    }
+
+    protected abstract DoubleArray Cross(IRandom random, ItemArray<DoubleArray> parents);
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorManipulator.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorManipulator.cs	(revision 3051)
@@ -0,0 +1,60 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVector {
+  /// <summary>
+  /// A base class for operators that manipulate real-valued vectors.
+  /// </summary>
+  [Item("RealVectorManipulator", "A base class for operators that manipulate real-valued vectors.")]
+  [StorableClass]
+  public abstract class RealVectorManipulator : SingleSuccessorOperator, IRealVectorManipulator, IStochasticOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<DoubleArray> RealVectorParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["RealVector"]; }
+    }
+
+    protected RealVectorManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new LookupParameter<DoubleArray>("RealVector", "The vector which should be manipulated."));
+    }
+
+    public sealed override IOperation Apply() {
+      Manipulate(RandomParameter.ActualValue, RealVectorParameter.ActualValue);
+      return base.Apply();
+    }
+
+    protected abstract void Manipulate(IRandom random, DoubleArray realVector);
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/AuthoringTests.txt
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/AuthoringTests.txt	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/AuthoringTests.txt	(revision 3051)
@@ -0,0 +1,136 @@
+﻿==========================================================================
+    Visual Studio Team System: Overview of Authoring and Running Tests    
+==========================================================================
+
+This overview describes the features for authoring and running tests in 
+Visual Studio Team System and Visual Studio Team Edition for Software Testers.
+
+Opening Tests
+-------------
+To open a test, open a test project or a test metadata file (a file with
+extension .vsmdi) that contains the definition of the test. You can find
+test projects and metadata files in Solution Explorer.
+
+Viewing Tests
+-------------
+To see which tests are available to you, open the Test View window. Or,
+if you have installed Team Edition for Software Testers, you can also open
+the Test List Editor window to view tests.
+
+To open the Test View window, click the Test menu, point to Windows, and
+then click Test View. To open the Test List Editor window (if you have
+installed Team Edition for Software Testers), click Test, point to Windows,
+and then click Test List Editor.
+
+Running Tests
+-------------
+You can run tests from the Test View window and the Test List Editor window.
+See Viewing Tests to learn how to open these windows. To run one or more
+tests displayed in the Test View window, first select the tests in that
+window; to select multiple tests, hold either the Shift or CTRL key while
+clicking tests. Then click the Run Tests button in the Test View window
+toolbar.
+
+If you have installed Visual Studio Team Edition for Software Testers, you can
+also use the Test List Editor window to run tests. To run tests in Test List Editor,
+select the check box next to each test that you want to run. Then click the
+Run Tests button in the Test List Editor window toolbar.
+
+Viewing Test Results
+--------------------
+When you run a test or a series of tests, the results of the test run will be
+shown in the Test Results window. Each individual test in the run is shown on
+a separate line so that you can see its status. The window contains an
+embedded status bar in the top half of the window that provides you with
+summary details of the complete test run.
+
+To see more detailed results for a particular test result, double-click it in
+the Test Results window. This opens a window that provides more information
+about the particular test result, such as any specific error messages returned
+by the test.
+
+Changing the way that tests are run
+-----------------------------------
+Each time you run one or more tests, a collection of settings is used to
+determine how those tests are run. These settings are contained in a “test
+run configuration” file.
+
+Here is a partial list of the changes you can make with a test run 
+configuration file:
+
+ - Change the naming scheme for each test run.
+ - Change the test controller that the tests are run on so that you can run
+   tests remotely.
+ - Gather code coverage data for the code being tested so that you can see
+   which lines of code are covered by your tests.
+ - Enable and disable test deployment. 
+ - Specify additional files to deploy before tests are run.
+ - Select a different host, ASP.NET, for running ASP.NET unit tests.
+ - Select a different host, the smart device test host, for running smart device unit tests.
+ - Set various properties for the test agents that run your tests.
+ - Run custom scripts at the start and end of each test run so that you can
+   set up the test environment exactly as required each time tests are run.
+ - Set time limits for tests and test runs.
+ - Set the browser mix and the number of times to repeat Web tests in the
+   test run.
+
+By default, a test run configuration file is created whenever you create a
+new test project. You make changes to this file by double-clicking it in 
+Solution Explorer and then changing its settings. (Test run configuration
+files have the extension .testrunconfig.)
+
+A solution can contain multiple test run configuration files. Only one of
+those files, known as the “Active” test run configuration file, is used to
+determine the settings that are currently used for test runs. You select
+the active test run configuration by clicking Select Active Test Run 
+Configuration on the Test menu.
+
+-------------------------------------------------------------------------------
+
+Test Types
+----------
+Using Visual Studio Team Edition for Software Testers, you can create a number
+of different test types:
+
+Unit test: Use a unit test to create a programmatic test in C++, Visual C# or
+Visual Basic that exercises source code. A unit test calls the methods of a
+class, passing suitable parameters, and verifies that the returned value is
+what you expect.
+There are three specialized variants of unit tests:
+ - Data-driven unit tests are created when you configure a unit test to be
+   called repeatedly for each row of a data source. The data from each row
+   is used by the unit test as input data.
+ - ASP.NET unit tests are unit tests that exercise code in an ASP.NET Web
+   application.
+ - Smart device unit tests are unit tests that are deployed to a smart device
+   or emulator and then executed by the smart device test host.  
+
+Web Test: Web tests consist of an ordered series of HTTP requests that you
+record in a browser session using Microsoft Internet Explorer. You can have
+the test report specific details about the pages or sites it requests, such
+as whether a particular page contains a specified string.
+
+Load Test: You use a load test to encapsulate non-manual tests, such as
+unit, Web, and generic tests, and then run them simultaneously by using
+virtual users. Running these tests under load generates test results,
+including performance and other counters, in tables and in graphs.
+
+Generic test: A generic test is an existing program wrapped to function as a
+test in Visual Studio. The following are examples of tests or programs that
+you can turn into generic tests:
+ - An existing test that uses process exit codes to communicate whether the
+   test passed or failed. 0 indicates passing and any other value indicates
+   a failure.
+ - A general program to obtain specific functionality during a test scenario.
+ - A test or program that uses a special XML file (called a “summary results
+   file”), to communicate detailed results.
+
+Manual test: The manual test type is used when the test tasks are to be
+completed by a test engineer as opposed to an automated script.
+
+Ordered test: Use an ordered test to execute a set of tests in an order you
+specify.
+
+-------------------------------------------------------------------------------
+
+
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/Auxiliary.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/Auxiliary.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/Auxiliary.cs	(revision 3051)
@@ -0,0 +1,40 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Data;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+  public static class Auxiliary {
+    public static bool RealVectorIsAlmostEqualByPosition(DoubleArray p1, DoubleArray p2) {
+      bool equal = (p1.Length == p2.Length);
+      if (equal) {
+        for (int i = 0; i < p1.Length; i++) {
+          if (!p1[i].IsAlmost(p2[i])) {
+            equal = false;
+            break;
+          }
+        }
+      }
+      return equal;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/BlendAlphaBetaCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/BlendAlphaBetaCrossoverTest.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/BlendAlphaBetaCrossoverTest.cs	(revision 3051)
@@ -0,0 +1,153 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for BlendAlphaBetaCrossoverTest and is intended
+  ///to contain all BlendAlphaBetaCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class BlendAlphaBetaCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Encodings.RealVector-3.3.dll")]
+    public void BlendAlphaBetaCrossoverCrossTest() {
+      BlendAlphaBetaCrossover_Accessor target = new BlendAlphaBetaCrossover_Accessor(new PrivateObject(typeof(BlendAlphaBetaCrossover)));
+      ItemArray<DoubleArray> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are more than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(5), new DoubleArray(6), new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void BlendAlphaBetaCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArray parent1, parent2, expected, actual;
+      DoubleValue alpha;
+      DoubleValue beta;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.5, 0.5, 0.5, 0.5, 0.5 };
+      alpha = new DoubleValue(0.5);
+      beta = new DoubleValue(0.5);
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.3, 0.15, 0.3, 0.35, 0.45 });
+      actual = BlendAlphaBetaCrossover.Apply(random, parent1, parent2, alpha, beta);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.25, 0.75, 0.25, 0.75, 0.25 };
+      alpha = new DoubleValue(-0.25); // negative values for alpha are not allowed
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = BlendAlphaBetaCrossover.Apply(random, parent1, parent2, alpha, beta);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.25, 0.75, 0.25, 0.75, 0.25, .75 };
+      alpha = new DoubleValue(0.25);
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = BlendAlphaBetaCrossover.Apply(random, parent1, parent2, alpha, beta);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for BlendAlphaBetaCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void BlendAlphaBetaCrossoverConstructorTest() {
+      BlendAlphaBetaCrossover target = new BlendAlphaBetaCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/BlendAlphaCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/BlendAlphaCrossoverTest.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/BlendAlphaCrossoverTest.cs	(revision 3051)
@@ -0,0 +1,162 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for BlendAlphaCrossoverTest and is intended
+  ///to contain all BlendAlphaCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class BlendAlphaCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Encodings.RealVector-3.3.dll")]
+    public void BlendAlphaCrossoverCrossTest() {
+      BlendAlphaCrossover_Accessor target = new BlendAlphaCrossover_Accessor(new PrivateObject(typeof(BlendAlphaCrossover)));
+      ItemArray<DoubleArray> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are more than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(5), new DoubleArray(6), new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void BlendAlphaCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArray parent1, parent2, expected, actual;
+      DoubleValue alpha;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.5, 0.5, 0.5, 0.5, 0.5 };
+      alpha = new DoubleValue(0.5);
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.3, 0.15, 0.3, 0.35, 0.45 });
+      actual = BlendAlphaCrossover.Apply(random, parent1, parent2, alpha);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.25, 0.75, 0.25, 0.75, 0.25 };
+      alpha = new DoubleValue(0.25);
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.225, 0.1875, 0.3, 0.4625, 0.1875 });
+      actual = BlendAlphaCrossover.Apply(random, parent1, parent2, alpha);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.25, 0.75, 0.25, 0.75, 0.25 };
+      alpha = new DoubleValue(-0.25); // negative values for alpha are not allowed
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.225, 0.1875, 0.3, 0.4625, 0.1875 });
+      exceptionFired = false;
+      try {
+        actual = BlendAlphaCrossover.Apply(random, parent1, parent2, alpha);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.25, 0.75, 0.25, 0.75, 0.25, .75 };
+      alpha = new DoubleValue(0.25);
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.225, 0.1875, 0.3, 0.4625, 0.1875 });
+      exceptionFired = false;
+      try {
+        actual = BlendAlphaCrossover.Apply(random, parent1, parent2, alpha);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for BlendAlphaCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void BlendAlphaCrossoverConstructorTest() {
+      BlendAlphaCrossover target = new BlendAlphaCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/DiscreteCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/DiscreteCrossoverTest.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/DiscreteCrossoverTest.cs	(revision 3051)
@@ -0,0 +1,127 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for DiscreteCrossoverTest and is intended
+  ///to contain all DiscreteCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class DiscreteCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Encodings.RealVector-3.3.dll")]
+    public void DiscreteCrossoverCrossTest() {
+      DiscreteCrossover_Accessor target = new DiscreteCrossover_Accessor(new PrivateObject(typeof(DiscreteCrossover)));
+      ItemArray<DoubleArray> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void DiscreteCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArray parent1, parent2, expected, actual;
+      ItemArray<DoubleArray> parents;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.IntNumbers = new int[] { 0, 0, 1, 0, 1 };
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      parents = new ItemArray<DoubleArray>( new DoubleArray[] { parent1, parent2 } );
+      expected = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.8 });
+      actual = DiscreteCrossover.Apply(random, parents);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.IntNumbers = new int[] { 0, 0, 1, 0, 1, 0 };
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { parent1, parent2 });
+      exceptionFired = false;
+      try {
+        actual = DiscreteCrossover.Apply(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for DiscreteCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void DiscreteCrossoverConstructorTest() {
+      DiscreteCrossover target = new DiscreteCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/HeuristicCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/HeuristicCrossoverTest.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/HeuristicCrossoverTest.cs	(revision 3051)
@@ -0,0 +1,136 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for HeuristicCrossoverTest and is intended
+  ///to contain all HeuristicCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class HeuristicCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Encodings.RealVector-3.3.dll")]
+    public void HeuristicCrossoverCrossTest() {
+      HeuristicCrossover_Accessor target = new HeuristicCrossover_Accessor(new PrivateObject(typeof(HeuristicCrossover)));
+      ItemArray<DoubleArray> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are more than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(5), new DoubleArray(6), new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void HeuristicCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArray parent1, parent2, expected, actual;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3 };
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.14, 0.23, 0.3, 0.59, -0.11 });
+      actual = HeuristicCrossover.Apply(random, parent1, parent2);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3 };
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = HeuristicCrossover.Apply(random, parent1, parent2);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for HeuristicCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void HeuristicCrossoverConstructorTest() {
+      HeuristicCrossover target = new HeuristicCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/HeuristicLab.Encodings.RealVector-3.3.Tests.csproj
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/HeuristicLab.Encodings.RealVector-3.3.Tests.csproj	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/HeuristicLab.Encodings.RealVector-3.3.Tests.csproj	(revision 3051)
@@ -0,0 +1,149 @@
+﻿<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{446C4F3D-1A12-465A-9128-97D0F47140C9}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Encodings.RealVector_33.Tests</RootNamespace>
+    <AssemblyName>HeuristicLab.Encodings.RealVector-3.3.Tests</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Auxiliary.cs" />
+    <Compile Include="BlendAlphaCrossoverTest.cs" />
+    <Compile Include="BlendAlphaBetaCrossoverTest.cs" />
+    <Compile Include="PolynomialOnePositionManipulatorTest.cs" />
+    <Compile Include="UniformOnePositionManipulatorTest.cs" />
+    <Compile Include="PolynomialAllPositionManipulatorTest.cs" />
+    <Compile Include="MichalewiczNonUniformOnePositionManipulatorTest.cs" />
+    <Compile Include="SinglePointCrossoverTest.cs" />
+    <Compile Include="SimulatedBinaryCrossoverTest.cs" />
+    <Compile Include="RandomConvexCrossoverTest.cs" />
+    <Compile Include="LocalCrossoverTest.cs" />
+    <Compile Include="HeuristicCrossoverTest.cs" />
+    <Compile Include="DiscreteCrossoverTest.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="MichalewiczNonUniformAllPositionsManipulatorTest.cs" />
+    <Compile Include="TestRandom.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="AuthoringTests.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\HeuristicLab.Common\3.2\HeuristicLab.Common-3.2.csproj">
+      <Project>{1FC004FC-59AF-4249-B1B6-FF25873A20E4}</Project>
+      <Name>HeuristicLab.Common-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
+      <Project>{BBAB9DF5-5EF3-4BA8-ADE9-B36E82114937}</Project>
+      <Name>HeuristicLab.Data-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\HeuristicLab.Operators\3.3\HeuristicLab.Operators-3.3.csproj">
+      <Project>{23DA7FF4-D5B8-41B6-AA96-F0561D24F3EE}</Project>
+      <Name>HeuristicLab.Operators-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
+      <Project>{14AB8D24-25BC-400C-A846-4627AA945192}</Project>
+      <Name>HeuristicLab.Optimization-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">
+      <Project>{56F9106A-079F-4C61-92F6-86A84C2D84B7}</Project>
+      <Name>HeuristicLab.Parameters-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
+      <Project>{102BC7D3-0EF9-439C-8F6D-96FF0FDB8E1B}</Project>
+      <Name>HeuristicLab.Persistence-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\HeuristicLab.PluginInfrastructure\HeuristicLab.PluginInfrastructure.csproj">
+      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
+      <Name>HeuristicLab.PluginInfrastructure</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\HeuristicLab.Encodings.RealVector-3.3.csproj">
+      <Project>{2D4E4565-3ED9-4BEB-AE75-39D871843D24}</Project>
+      <Name>HeuristicLab.Encodings.RealVector-3.3</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Shadow Include="Test References\HeuristicLab.Encodings.RealVector-3.3.accessor" />
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/LocalCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/LocalCrossoverTest.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/LocalCrossoverTest.cs	(revision 3051)
@@ -0,0 +1,136 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for LocalCrossoverTest and is intended
+  ///to contain all LocalCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class LocalCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Encodings.RealVector-3.3.dll")]
+    public void LocalCrossoverCrossTest() {
+      LocalCrossover_Accessor target = new LocalCrossover_Accessor(new PrivateObject(typeof(LocalCrossover)));
+      ItemArray<DoubleArray> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are more than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(5), new DoubleArray(6), new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void LocalCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArray parent1, parent2, expected, actual;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3, 0.1, 0.2, 0.4, 0.23 };
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.34, 0.11, 0.3, 0.32, 0.639 });
+      actual = LocalCrossover.Apply(random, parent1, parent2);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3, 0.1, 0.2, 0.4, 0.23, 0.5};
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = LocalCrossover.Apply(random, parent1, parent2);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for LocalCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void LocalCrossoverConstructorTest() {
+      LocalCrossover target = new LocalCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/MichalewiczNonUniformAllPositionsManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/MichalewiczNonUniformAllPositionsManipulatorTest.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/MichalewiczNonUniformAllPositionsManipulatorTest.cs	(revision 3051)
@@ -0,0 +1,130 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Encodings.RealVector;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+  /// <summary>
+  ///This is a test class for MichalewiczNonUniformAllPositionsManipulator and is intended
+  ///to contain all MichalewiczNonUniformAllPositionsManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class MichalewiczNonUniformAllPositionsManipulatorTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void MichalewiczNonUniformAllPositionsManipulatorApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArray parent, expected;
+      DoubleValue min, max, generationsDependency;
+      IntValue currentGeneration, maximumGenerations;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.2, 0.5, 0.7, 0.8, 0.9, 0.5, 0.2, 0.5, 0.7, 0.8 };
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArray(new double[] { 0.45, 0.22, 0.3, 0.6, 0.14 });
+      min = new DoubleValue(0.3);
+      max = new DoubleValue(0.7);
+      generationsDependency = new DoubleValue(0.1);
+      currentGeneration = new IntValue(1);
+      maximumGenerations = new IntValue(4);
+      MichalewiczNonUniformAllPositionsManipulator.Apply(random, parent, min, max, currentGeneration, maximumGenerations, generationsDependency);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
+      // The following test is not based on published examples
+      exceptionFired = false;
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.2, 0.5, 0.7, 0.8, 0.9, 0.5, 0.2, 0.5, 0.7, 0.8 };
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      min = new DoubleValue(0.3);
+      max = new DoubleValue(0.7);
+      generationsDependency = new DoubleValue(0.1);
+      currentGeneration = new IntValue(5); //current generation > max generation
+      maximumGenerations = new IntValue(4);
+      try {
+        MichalewiczNonUniformAllPositionsManipulator.Apply(random, parent, min, max, currentGeneration, maximumGenerations, generationsDependency);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for MichalewiczNonUniformAllPositionsManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void MichalewiczNonUniformAllPositionsManipulatorConstructorTest() {
+      MichalewiczNonUniformAllPositionsManipulator target = new MichalewiczNonUniformAllPositionsManipulator();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/MichalewiczNonUniformOnePositionManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/MichalewiczNonUniformOnePositionManipulatorTest.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/MichalewiczNonUniformOnePositionManipulatorTest.cs	(revision 3051)
@@ -0,0 +1,132 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Encodings.RealVector;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+  /// <summary>
+  ///This is a test class for MichalewiczNonUniformOnePositionManipulator and is intended
+  ///to contain all MichalewiczNonUniformOnePositionManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class MichalewiczNonUniformOnePositionManipulatorTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void MichalewiczNonUniformOnePositionManipulatorApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArray parent, expected;
+      DoubleValue min, max, generationsDependency;
+      IntValue currentGeneration, maximumGenerations;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.IntNumbers = new int[] { 3 };
+      random.DoubleNumbers = new double[] { 0.2, 0.7 };
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.34, 0.1 });
+      min = new DoubleValue(0.3);
+      max = new DoubleValue(0.7);
+      generationsDependency = new DoubleValue(0.1);
+      currentGeneration = new IntValue(1);
+      maximumGenerations = new IntValue(4);
+      MichalewiczNonUniformOnePositionManipulator.Apply(random, parent, min, max, currentGeneration, maximumGenerations, generationsDependency);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
+      // The following test is not based on published examples
+      exceptionFired = false;
+      random.Reset();
+      random.IntNumbers = new int[] { 3 };
+      random.DoubleNumbers = new double[] { 0.2, 0.7 };
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      min = new DoubleValue(0.3);
+      max = new DoubleValue(0.7);
+      generationsDependency = new DoubleValue(0.1);
+      currentGeneration = new IntValue(5); //current generation > max generation
+      maximumGenerations = new IntValue(4);
+      try {
+        MichalewiczNonUniformOnePositionManipulator.Apply(random, parent, min, max, currentGeneration, maximumGenerations, generationsDependency);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for MichalewiczNonUniformOnePositionManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void MichalewiczNonUniformOnePositionManipulatorConstructorTest() {
+      MichalewiczNonUniformOnePositionManipulator target = new MichalewiczNonUniformOnePositionManipulator();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/PolynomialAllPositionManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/PolynomialAllPositionManipulatorTest.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/PolynomialAllPositionManipulatorTest.cs	(revision 3051)
@@ -0,0 +1,123 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Encodings.RealVector;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+  /// <summary>
+  ///This is a test class for PolynomialAllPositionManipulator and is intended
+  ///to contain all PolynomialAllPositionManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class PolynomialAllPositionManipulatorTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void PolynomialAllPositionManipulatorApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArray parent, expected;
+      DoubleValue contiguity, maxManipulation;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.2, 0.7, 0.8, 0.01, 0.1 };
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArray(new double[] { 0.120213215256006, 0.336631954950876, 0.474551336679454, 0.322759240811056, -0.0182075293954083 });
+      contiguity = new DoubleValue(0.8);
+      maxManipulation = new DoubleValue(0.2);
+      PolynomialAllPositionManipulator.Apply(random, parent, contiguity, maxManipulation);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
+      // The following test is not based on published examples
+      exceptionFired = false;
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.2, 0.7, 0.8, 0.01, 0.1 };
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      contiguity = new DoubleValue(-1); //Contiguity value < 0
+      maxManipulation = new DoubleValue(0.2);
+      try {
+        PolynomialAllPositionManipulator.Apply(random, parent, contiguity, maxManipulation);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for PolynomialAllPositionManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void PolynomialAllPositionManipulatorConstructorTest() {
+      PolynomialAllPositionManipulator target = new PolynomialAllPositionManipulator();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/PolynomialOnePositionManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/PolynomialOnePositionManipulatorTest.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/PolynomialOnePositionManipulatorTest.cs	(revision 3051)
@@ -0,0 +1,125 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Encodings.RealVector;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+  /// <summary>
+  ///This is a test class for PolynomialOnePositionManipulator and is intended
+  ///to contain all PolynomialOnePositionManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class PolynomialOnePositionManipulatorTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void PolynomialOnePositionManipulatorApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArray parent, expected;
+      DoubleValue contiguity, maxManipulation;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.IntNumbers = new int[] { 3 };
+      random.DoubleNumbers = new double[] { 0.2 };
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.1261980542102, 0.1 });
+      contiguity = new DoubleValue(0.2);
+      maxManipulation = new DoubleValue(0.7);
+      PolynomialOnePositionManipulator.Apply(random, parent, contiguity, maxManipulation);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
+      // The following test is not based on published examples
+      exceptionFired = false;
+      random.Reset();
+      random.IntNumbers = new int[] { 3 };
+      random.DoubleNumbers = new double[] { 0.2 };
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      contiguity = new DoubleValue(-1); //Contiguity value < 0
+      maxManipulation = new DoubleValue(0.2);
+      try {
+        PolynomialOnePositionManipulator.Apply(random, parent, contiguity, maxManipulation);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for PolynomialOnePositionManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void PolynomialOnePositionManipulatorConstructorTest() {
+      PolynomialOnePositionManipulator target = new PolynomialOnePositionManipulator();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/Properties/AssemblyInfo.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/Properties/AssemblyInfo.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/Properties/AssemblyInfo.cs	(revision 3051)
@@ -0,0 +1,35 @@
+﻿using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Encodings.RealVector-3.3.Tests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Microsoft")]
+[assembly: AssemblyProduct("HeuristicLab.Encodings.RealVector-3.3.Tests")]
+[assembly: AssemblyCopyright("Copyright © Microsoft 2010")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM componenets.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("06f0de7d-9dfa-4c14-afd2-da4b94c823bb")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/RandomConvexCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/RandomConvexCrossoverTest.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/RandomConvexCrossoverTest.cs	(revision 3051)
@@ -0,0 +1,136 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for RandomConvexCrossoverTest and is intended
+  ///to contain all RandomConvexCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class RandomConvexCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Encodings.RealVector-3.3.dll")]
+    public void RandomConvexCrossoverCrossTest() {
+      RandomConvexCrossover_Accessor target = new RandomConvexCrossover_Accessor(new PrivateObject(typeof(RandomConvexCrossover)));
+      ItemArray<DoubleArray> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are more than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(5), new DoubleArray(6), new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void RandomConvexCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArray parent1, parent2, expected, actual;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3 };
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.34, 0.13, 0.3, 0.29, 0.59 });
+      actual = RandomConvexCrossover.Apply(random, parent1, parent2);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3 };
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = RandomConvexCrossover.Apply(random, parent1, parent2);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for RandomConvexCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void RandomConvexCrossoverConstructorTest() {
+      RandomConvexCrossover target = new RandomConvexCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/SimulatedBinaryCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/SimulatedBinaryCrossoverTest.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/SimulatedBinaryCrossoverTest.cs	(revision 3051)
@@ -0,0 +1,153 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for SimulatedBinaryCrossoverTest and is intended
+  ///to contain all SimulatedBinaryCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class SimulatedBinaryCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Encodings.RealVector-3.3.dll")]
+    public void SimulatedBinaryCrossoverCrossTest() {
+      SimulatedBinaryCrossover_Accessor target = new SimulatedBinaryCrossover_Accessor(new PrivateObject(typeof(SimulatedBinaryCrossover)));
+      ItemArray<DoubleArray> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are more than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(5), new DoubleArray(6), new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void SimulatedBinaryCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArray parent1, parent2, expected, actual;
+      DoubleValue contiguity;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3, 0.9, 0.7, 0.2, 0.8, 0.1, 0.2, 0.3, 0.4, 0.8, 0.7 };
+      contiguity = new DoubleValue(0.3);
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 1.11032829834638, -0.0145477755417797, 0.3, 0.5, 0.1 });
+      actual = SimulatedBinaryCrossover.Apply(random, parent1, parent2, contiguity);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3, 0.9, 0.7, 0.2, 0.8, 0.1, 0.2, 0.3, 0.4, 0.8, 0.7 };
+      contiguity = new DoubleValue(0.3);
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = SimulatedBinaryCrossover.Apply(random, parent1, parent2, contiguity);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test is not based on published examples
+      random.Reset();
+      random.DoubleNumbers = new double[] { 0.3, 0.9, 0.7, 0.2, 0.8, 0.1, 0.2, 0.3, 0.4, 0.8, 0.7 };
+      contiguity = new DoubleValue(-0.3);  //  contiguity < 0
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1}); 
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = SimulatedBinaryCrossover.Apply(random, parent1, parent2, contiguity);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for SimulatedBinaryCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void SimulatedBinaryCrossoverConstructorTest() {
+      SimulatedBinaryCrossover target = new SimulatedBinaryCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/SinglePointCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/SinglePointCrossoverTest.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/SinglePointCrossoverTest.cs	(revision 3051)
@@ -0,0 +1,136 @@
+﻿using HeuristicLab.Encodings.RealVector;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+
+
+  /// <summary>
+  ///This is a test class for SinglePointCrossoverTest and is intended
+  ///to contain all SinglePointCrossoverTest Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class SinglePointCrossoverTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+    /// <summary>
+    ///A test for Cross
+    ///</summary>
+    [TestMethod()]
+    [DeploymentItem("HeuristicLab.Encodings.RealVector-3.3.dll")]
+    public void SinglePointCrossoverCrossTest() {
+      SinglePointCrossover_Accessor target = new SinglePointCrossover_Accessor(new PrivateObject(typeof(SinglePointCrossover)));
+      ItemArray<DoubleArray> parents;
+      TestRandom random = new TestRandom();
+      bool exceptionFired;
+      // The following test checks if there is an exception when there are more than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(5), new DoubleArray(6), new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      }
+      catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+      // The following test checks if there is an exception when there are less than 2 parents
+      random.Reset();
+      parents = new ItemArray<DoubleArray>(new DoubleArray[] { new DoubleArray(4) });
+      exceptionFired = false;
+      try {
+        DoubleArray actual;
+        actual = target.Cross(random, parents);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void SinglePointCrossoverApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArray parent1, parent2, expected, actual;
+      bool exceptionFired;
+      // The following test is not based on published examples
+      random.Reset();
+      random.IntNumbers = new int[] { 3 };
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      expected = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.2, 0.8 });
+      actual = SinglePointCrossover.Apply(random, parent1, parent2);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
+      // The following test is not based on published examples
+      random.Reset();
+      random.IntNumbers = new int[] { 2 };
+      parent1 = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1, 0.9 }); // this parent is longer
+      parent2 = new DoubleArray(new double[] { 0.4, 0.1, 0.3, 0.2, 0.8 });
+      exceptionFired = false;
+      try {
+        actual = SinglePointCrossover.Apply(random, parent1, parent2);
+      } catch (System.ArgumentException) {
+        exceptionFired = true;
+      }
+      Assert.IsTrue(exceptionFired);
+    }
+
+    /// <summary>
+    ///A test for SinglePointCrossover Constructor
+    ///</summary>
+    [TestMethod()]
+    public void SinglePointCrossoverConstructorTest() {
+      SinglePointCrossover target = new SinglePointCrossover();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/Test References/HeuristicLab.Encodings.RealVector-3.3.accessor
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/Test References/HeuristicLab.Encodings.RealVector-3.3.accessor	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/Test References/HeuristicLab.Encodings.RealVector-3.3.accessor	(revision 3051)
@@ -0,0 +1,2 @@
+HeuristicLab.Encodings.RealVector-3.3.dll
+Desktop
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/TestRandom.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/TestRandom.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/TestRandom.cs	(revision 3051)
@@ -0,0 +1,134 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+  public class TestRandom : IRandom {
+    #region Variables and Properties
+    private int[] intNumbers;
+    public int[] IntNumbers {
+      get { return intNumbers; }
+      set {
+        if (value == null) intNumbers = new int[0];
+        else intNumbers = value;
+      }
+    }
+    private int nextIntIndex;
+    private double[] doubleNumbers;
+    public double[] DoubleNumbers {
+      get { return doubleNumbers; }
+      set {
+        if (value == null) doubleNumbers = new double[0];
+        else doubleNumbers = value;
+      }
+    }
+    private int nextDoubleIndex;
+    #endregion
+
+    public TestRandom() {
+      intNumbers = new int[0];
+      doubleNumbers = new double[0];
+      nextIntIndex = 0;
+      nextDoubleIndex = 0;
+    }
+
+    public TestRandom(int[] intNumbers, double[] doubleNumbers) {
+      if (intNumbers == null) intNumbers = new int[0];
+      else this.intNumbers = intNumbers;
+      if (doubleNumbers == null) doubleNumbers = new double[0];
+      else this.doubleNumbers = doubleNumbers;
+      nextIntIndex = 0;
+      nextDoubleIndex = 0;
+    }
+
+    #region IRandom Members
+
+    public void Reset() {
+      nextIntIndex = 0;
+      nextDoubleIndex = 0;
+    }
+
+    public void Reset(int seed) {
+      throw new NotImplementedException();
+    }
+
+    public int Next() {
+      if (nextIntIndex >= intNumbers.Length) throw new InvalidOperationException("Random: No more integer random numbers available");
+      return intNumbers[nextIntIndex++];
+    }
+
+    public int Next(int maxVal) {
+      if (nextIntIndex >= intNumbers.Length) throw new InvalidOperationException("Random: No more integer random numbers available");
+      if (IntNumbers[nextIntIndex] >= maxVal) throw new InvalidOperationException("Random: Next integer random number (" + IntNumbers[nextIntIndex] + ") is >= " + maxVal);
+      return intNumbers[nextIntIndex++];
+    }
+
+    public int Next(int minVal, int maxVal) {
+      if (nextIntIndex >= intNumbers.Length) throw new InvalidOperationException("Random: No more integer random numbers available");
+      if (IntNumbers[nextIntIndex] < minVal || IntNumbers[nextIntIndex] >= maxVal) throw new InvalidOperationException("Random: Next integer random number (" + IntNumbers[nextIntIndex] + ") is not in the range [" + minVal + ";" + maxVal + ")");
+      return intNumbers[nextIntIndex++];
+    }
+
+    public double NextDouble() {
+      if (nextDoubleIndex >= doubleNumbers.Length) throw new InvalidOperationException("Random: No more double random numbers available");
+      if (doubleNumbers[nextDoubleIndex] < 0.0 || doubleNumbers[nextDoubleIndex] >= 1.0) throw new InvalidOperationException("Random: Next double ranomd number (" + DoubleNumbers[nextDoubleIndex] + ") is not in the range [0;1)");
+      return doubleNumbers[nextDoubleIndex++];
+    }
+
+    #endregion
+
+    #region IItem Members
+
+    public string ItemName {
+      get { throw new NotImplementedException(); }
+    }
+
+    public string ItemDescription {
+      get { throw new NotImplementedException(); }
+    }
+
+    public System.Drawing.Image ItemImage {
+      get { throw new NotImplementedException(); }
+    }
+
+    public event EventHandler ToStringChanged;
+
+    #endregion
+
+    #region IDeepCloneable Members
+
+    public IDeepCloneable Clone(Cloner cloner) {
+      throw new NotImplementedException();
+    }
+
+    #endregion
+
+    #region ICloneable Members
+
+    public object Clone() {
+      throw new NotImplementedException();
+    }
+
+    #endregion
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/UniformOnePositionManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 3051)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 3051)
@@ -0,0 +1,109 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using HeuristicLab.Encodings.RealVector;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.RealVector_33.Tests {
+  /// <summary>
+  ///This is a test class for UniformOnePositionManipulator and is intended
+  ///to contain all UniformOnePositionManipulator Unit Tests
+  ///</summary>
+  [TestClass()]
+  public class UniformOnePositionManipulatorTest {
+
+
+    private TestContext testContextInstance;
+
+    /// <summary>
+    ///Gets or sets the test context which provides
+    ///information about and functionality for the current test run.
+    ///</summary>
+    public TestContext TestContext {
+      get {
+        return testContextInstance;
+      }
+      set {
+        testContextInstance = value;
+      }
+    }
+
+    #region Additional test attributes
+    // 
+    //You can use the following additional attributes as you write your tests:
+    //
+    //Use ClassInitialize to run code before running the first test in the class
+    //[ClassInitialize()]
+    //public static void MyClassInitialize(TestContext testContext)
+    //{
+    //}
+    //
+    //Use ClassCleanup to run code after all tests in a class have run
+    //[ClassCleanup()]
+    //public static void MyClassCleanup()
+    //{
+    //}
+    //
+    //Use TestInitialize to run code before running each test
+    //[TestInitialize()]
+    //public void MyTestInitialize()
+    //{
+    //}
+    //
+    //Use TestCleanup to run code after each test has run
+    //[TestCleanup()]
+    //public void MyTestCleanup()
+    //{
+    //}
+    //
+    #endregion
+
+
+    /// <summary>
+    ///A test for Apply
+    ///</summary>
+    [TestMethod()]
+    public void UniformOnePositionManipulatorApplyTest() {
+      TestRandom random = new TestRandom();
+      DoubleArray parent, expected;
+      DoubleValue min, max;
+      // The following test is not based on published examples
+      random.Reset();
+      random.IntNumbers = new int[] { 3 };
+      random.DoubleNumbers = new double[] { 0.2 };
+      parent = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.5, 0.1 });
+      expected = new DoubleArray(new double[] { 0.2, 0.2, 0.3, 0.3, 0.1 });
+      min = new DoubleValue(0.2);
+      max = new DoubleValue(0.7);
+      UniformOnePositionManipulator.Apply(random, parent, min, max);
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
+    }
+
+    /// <summary>
+    ///A test for UniformOnePositionManipulator Constructor
+    ///</summary>
+    [TestMethod()]
+    public void UniformOnePositionManipulatorConstructorTest() {
+      UniformOnePositionManipulator target = new UniformOnePositionManipulator();
+    }
+  }
+}
