Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/BoundedIntegerVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/BoundedIntegerVectorCrossover.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/BoundedIntegerVectorCrossover.cs	(revision 8019)
@@ -0,0 +1,63 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  [Item("BoundedIntegerVectorCrossover", "Base class for bounded crossovers.")]
+  [StorableClass]
+  public abstract class BoundedIntegerVectorCrossover : IntegerVectorCrossover, IBoundedIntegerVectorOperator {
+
+    public IValueLookupParameter<IntMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
+    }
+
+    [StorableConstructor]
+    protected BoundedIntegerVectorCrossover(bool deserializing) : base(deserializing) { }
+    protected BoundedIntegerVectorCrossover(BoundedIntegerVectorCrossover original, Cloner cloner) : base(original, cloner) { }
+    public BoundedIntegerVectorCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
+    }
+
+    protected sealed override IntegerVector Cross(IRandom random, ItemArray<IntegerVector> parents) {
+      if (BoundsParameter.ActualValue == null) throw new InvalidOperationException(Name + ": Bounds are not defined!");
+      return CrossBounded(random, parents, BoundsParameter.ActualValue);
+    }
+
+    protected abstract IntegerVector CrossBounded(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds);
+
+    protected static int RoundFeasible(int min, int max, int step, double value) {
+      return Math.Max(min, Math.Min(max, (int)Math.Round((value - min) / (double)step) * step + min));
+    }
+    protected static int FloorFeasible(int min, int max, int step, double value) {
+      return Math.Max(min, Math.Min(max, (int)Math.Floor((value - min) / (double)step) * step + min));
+    }
+    protected static int CeilingFeasible(int min, int max, int step, double value) {
+      return Math.Max(min, Math.Min(max, (int)Math.Ceiling((value - min) / (double)step) * step + min));
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/BoundedIntegerVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/BoundedIntegerVectorManipulator.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/BoundedIntegerVectorManipulator.cs	(revision 8019)
@@ -0,0 +1,63 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  [Item("BoundedIntegerVectorManipulator", "Base class for bounded integer vector manipulators.")]
+  [StorableClass]
+  public abstract class BoundedIntegerVectorManipulator : IntegerVectorManipulator, IBoundedIntegerVectorOperator {
+    
+    public IValueLookupParameter<IntMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
+    }
+
+    [StorableConstructor]
+    protected BoundedIntegerVectorManipulator(bool deserializing) : base(deserializing) { }
+    protected BoundedIntegerVectorManipulator(BoundedIntegerVectorManipulator original, Cloner cloner) : base(original, cloner) { }
+    public BoundedIntegerVectorManipulator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
+    }
+
+    protected sealed override void Manipulate(IRandom random, IntegerVector integerVector) {
+      if (BoundsParameter.ActualValue == null) throw new InvalidOperationException("UniformSomePositionsManipulator: Parameter " + BoundsParameter.ActualName + " could not be found.");
+      ManipulateBounded(random, integerVector, BoundsParameter.ActualValue);
+    }
+
+    protected abstract void ManipulateBounded(IRandom random, IntegerVector integerVector, IntMatrix bounds);
+
+    protected static int RoundFeasible(int min, int max, int step, double value) {
+      return Math.Max(min, Math.Min(max, (int)Math.Round((value - min) / (double)step) * step + min));
+    }
+    protected static int FloorFeasible(int min, int max, int step, double value) {
+      return Math.Max(min, Math.Min(max, (int)Math.Floor((value - min) / (double)step) * step + min));
+    }
+    protected static int CeilingFeasible(int min, int max, int step, double value) {
+      return Math.Max(min, Math.Min(max, (int)Math.Ceiling((value - min) / (double)step) * step + min));
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Creators/UniformRandomIntegerVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Creators/UniformRandomIntegerVectorCreator.cs	(revision 7259)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Creators/UniformRandomIntegerVectorCreator.cs	(revision 8019)
@@ -49,9 +49,8 @@
     /// <param name="max">The maximum value of the sampling range for each vector element (exclusive).</param>
     /// <returns>The newly created integer vector.</returns>
-    public static IntegerVector Apply(IRandom random, int length, int min, int max) {
-      int[] result = new int[length];
-      for (int i = 0; i < length; i++)
-        result[i] = random.Next(min, max);
-      return new IntegerVector(result);
+    public static IntegerVector Apply(IRandom random, int length, IntMatrix bounds) {
+      var result = new IntegerVector(length);
+      result.Randomize(random, bounds);
+      return result;
     }
 
@@ -61,9 +60,8 @@
     /// <param name="random">The pseudo random number generator to use.</param>
     /// <param name="length">The length of the int 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>
+    /// <param name="bounds">Contains in each row for each dimension minimum (inclusive), maximum (inclusive), and step size.</param>
     /// <returns>The newly created int vector.</returns>
-    protected override IntegerVector Create(IRandom random, IntValue length, IntValue minimum, IntValue maximum) {
-      return Apply(random, length.Value, minimum.Value, maximum.Value);
+    protected override IntegerVector Create(IRandom random, IntValue length, IntMatrix bounds) {
+      return Apply(random, length.Value, bounds);
     }
   }
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/DiscreteCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/DiscreteCrossover.cs	(revision 7259)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/DiscreteCrossover.cs	(revision 8019)
@@ -45,37 +45,34 @@
 
     /// <summary>
-    /// Performs a discrete crossover operation of the two given parents.
+    /// Performs a discrete crossover operation of any number of given 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="parent1">The first parent for the crossover operation.</param>
-    /// <param name="parent2">The second parent for the crossover operation.</param>
+    /// <param name="parents">The list of parents for the crossover operation.</param>
     /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
-    public static IntegerVector Apply(IRandom random, IntegerVector parent1, IntegerVector parent2) {
-      if (parent1.Length != parent2.Length)
-        throw new ArgumentException("DiscreteCrossover: The parents are of different length.");
+    public static IntegerVector Apply(IRandom random, ItemArray<IntegerVector> parents) {
+      int length = parents[0].Length;
 
-      int length = parent1.Length;
-      int[] result = new int[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");
+      }
 
+      var result = new IntegerVector(length);
       for (int i = 0; i < length; i++) {
-        if (random.NextDouble() < 0.5)
-          result[i] = parent1[i];
-        else
-          result[i] = parent2[i];
+        result[i] = parents[random.Next(parents.Length)][i];
       }
-      return new IntegerVector(result);
+
+      return result;
     }
 
     /// <summary>
-    /// Performs a discrete crossover operation for two given parent integer vectors.
+    /// Performs a discrete crossover operation for any number of given parent integer 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 integer vectors that should be crossed.</param>
+    /// <param name="parents">An array containing integer vectors that should be crossed.</param>
     /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
     protected override IntegerVector Cross(IRandom random, ItemArray<IntegerVector> parents) {
-      if (parents.Length != 2) throw new ArgumentException("ERROR in DiscreteCrossover: The number of parents is not equal to 2");
-      return Apply(random, parents[0], parents[1]);
+      return Apply(random, parents);
     }
   }
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/MultiIntegerVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/MultiIntegerVectorCrossover.cs	(revision 7259)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/MultiIntegerVectorCrossover.cs	(revision 8019)
@@ -25,4 +25,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -34,5 +35,5 @@
   [Item("MultiIntegerVectorCrossover", "Randomly selects and applies one of its crossovers every time it is called.")]
   [StorableClass]
-  public class MultiIntegerVectorCrossover : StochasticMultiBranch<IIntegerVectorCrossover>, IIntegerVectorCrossover, IStochasticOperator {
+  public class MultiIntegerVectorCrossover : StochasticMultiBranch<IIntegerVectorCrossover>, IIntegerVectorCrossover, IStochasticOperator, IBoundedIntegerVectorOperator {
     public override bool CanChangeName {
       get { return false; }
@@ -40,4 +41,8 @@
     protected override bool CreateChildOperation {
       get { return true; }
+    }
+
+    public IValueLookupParameter<IntMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
     }
 
@@ -55,4 +60,5 @@
     public MultiIntegerVectorCrossover()
       : base() {
+      Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
       Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>("Parents", "The parent integer vector which should be crossed."));
       ParentsParameter.ActualName = "IntegerVector";
@@ -88,4 +94,7 @@
         crossover.RandomParameter.ActualName = RandomParameter.Name;
       }
+      foreach (IBoundedIntegerVectorOperator crossover in Operators.OfType<IBoundedIntegerVectorOperator>()) {
+        crossover.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
     }
 
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedAverageCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedAverageCrossover.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedAverageCrossover.cs	(revision 8019)
@@ -0,0 +1,90 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Rounded average crossover for integer vectors.
+  /// </summary>
+  [Item("RoundedAverageCrossover", "Average crossover for integer vectors.")]
+  [StorableClass]
+  public class RoundedAverageCrossover : BoundedIntegerVectorCrossover, IBoundedIntegerVectorOperator {
+
+    [StorableConstructor]
+    protected RoundedAverageCrossover(bool deserializing) : base(deserializing) { }
+    protected RoundedAverageCrossover(RoundedAverageCrossover original, Cloner cloner) : base(original, cloner) { }
+    public RoundedAverageCrossover() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedAverageCrossover(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs an average crossover of the two given parent integer vectors.
+    /// The average is rounded and mapped to the nearest valid value (e.g. if step size is > 1)
+    /// </summary>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">The parents for crossover.</param>
+    /// <param name="bounds">The bounds matrix that contains for each dimension one row with minimum (inclusive), maximum (exclusive), and step size columns.
+    /// If the number of rows is smaller than the number of dimensions the matrix is cycled.</param>
+    /// <returns>The newly created integer vector, resulting from the single point crossover.</returns>
+    public static IntegerVector Apply(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
+      int length = parents[0].Length, parentsCount = parents.Length;
+      if (parents.Length < 2) throw new ArgumentException("RoundedAverageCrossover: The number of parents is less than 2.", "parents");
+      if (bounds == null || bounds.Rows < 1 || bounds.Columns < 2) throw new ArgumentException("AverageCrossover: Invalid bounds specified.", "bounds");
+
+      var result = new IntegerVector(length);
+      try {
+        double avg;
+        for (int i = 0; i < length; i++) {
+          avg = 0;
+          for (int j = 0; j < parentsCount; j++)
+            avg += parents[j][i];
+          avg /= parentsCount;
+          int min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1], step = 1;
+          if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+          result[i] = RoundFeasible(min, max, step, avg);
+        }
+      } catch (IndexOutOfRangeException) {
+        throw new ArgumentException("RoundedAverageCrossover: The parents' vectors are of different length.", "parents");
+      }
+
+      return result;
+    }
+
+    /// <summary>
+    /// Performs an average crossover between two parent integer 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 integer vectors that should be crossed.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The newly created integer vector, resulting from the average crossover.</returns>
+    protected override IntegerVector CrossBounded(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
+      return Apply(random, parents, bounds);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedBlendAlphaBetaCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedBlendAlphaBetaCrossover.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedBlendAlphaBetaCrossover.cs	(revision 8019)
@@ -0,0 +1,162 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Blend alpha-beta crossover for integer vectors (BLX-a-b). Creates a new offspring by selecting a 
+  /// random value from the interval between the two alleles of the parent solutions and rounds the
+  /// result to the nearest feasible value. The interval is increased in both directions as follows:
+  /// Into the direction of the 'better' solution by the factor alpha, into the direction of the
+  /// 'worse' solution by the factor beta.
+  /// </summary>
+  [Item("RoundedBlendAlphaBetaCrossover", "The rounded blend alpha beta crossover (BLX-a-b) for integer 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 beyond the better parent by specifying a higher alpha value, and beyond the worse parent by specifying a higher beta value. The new offspring is sampled uniformly in the extended range and rounded to the next feasible integer.")]
+  [StorableClass]
+  public class RoundedBlendAlphaBetaCrossover : BoundedIntegerVectorCrossover {
+    /// <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 ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    /// <summary>
+    /// The Alpha parameter controls the extension of the range beyond the better parent. The value must be >= 0 and does not depend on Beta.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> AlphaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Alpha"]; }
+    }
+    /// <summary>
+    /// The Beta parameter controls the extension of the range beyond the worse parent. The value must be >= 0 and does not depend on Alpha.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> BetaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Beta"]; }
+    }
+
+    [StorableConstructor]
+    protected RoundedBlendAlphaBetaCrossover(bool deserializing) : base(deserializing) { }
+    protected RoundedBlendAlphaBetaCrossover(RoundedBlendAlphaBetaCrossover original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="RoundedBlendAlphaBetaCrossover"/> with four additional parameters
+    /// (<c>Maximization</c>, <c>Quality</c>, <c>Alpha</c> and <c>Beta</c>).
+    /// </summary>
+    public RoundedBlendAlphaBetaCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "Whether the problem is a maximization problem or not."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The quality values of the parents."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "The Alpha parameter controls the extension of the range beyond the better parent. The value must be >= 0 and does not depend on Beta.", new DoubleValue(0.75)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Beta", "The Beta parameter controls the extension of the range beyond the worse parent. The value must be >= 0 and does not depend on Alpha.", new DoubleValue(0.25)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedBlendAlphaBetaCrossover(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs the rounded 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="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <param name="alpha">The parameter alpha.</param>
+    /// <param name="beta">The parameter beta.</param>
+    /// <returns>The integer vector that results from the crossover.</returns>
+    public static IntegerVector Apply(IRandom random, IntegerVector betterParent, IntegerVector worseParent, IntMatrix bounds, DoubleValue alpha, DoubleValue beta) {
+      if (betterParent.Length != worseParent.Length) throw new ArgumentException("RoundedBlendAlphaBetaCrossover: The parents' vectors are of different length.", "betterParent");
+      if (alpha.Value < 0) throw new ArgumentException("RoundedBlendAlphaBetaCrossover: Parameter alpha must be greater or equal to 0.", "alpha");
+      if (beta.Value < 0) throw new ArgumentException("RoundedBlendAlphaBetaCrossover: Parameter beta must be greater or equal to 0.", "beta");
+      if (bounds == null || bounds.Rows < 1 || bounds.Columns < 2) throw new ArgumentException("RoundedBlendAlphaBetaCrossover: Invalid bounds specified.", "bounds");
+      
+      int length = betterParent.Length;
+      double min, max, d;
+      var result = new IntegerVector(length);
+      int minBound, maxBound, step = 1;
+      for (int i = 0; i < length; i++) {
+        minBound = bounds[i % bounds.Rows, 0];
+        maxBound = bounds[i % bounds.Rows, 1];
+        if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+
+        d = Math.Abs(betterParent[i] - worseParent[i]);
+        if (betterParent[i] <= worseParent[i]) {
+          min = FloorFeasible(minBound, maxBound, step, betterParent[i] - d * alpha.Value);
+          max = CeilingFeasible(minBound, maxBound, step, worseParent[i] + d * beta.Value);
+        } else {
+          min = FloorFeasible(minBound, maxBound, step, worseParent[i] - d * beta.Value);
+          max = CeilingFeasible(minBound, maxBound, step, betterParent[i] + d * alpha.Value);
+        }
+        result[i] = RoundFeasible(minBound, maxBound, step, 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, IntegerVector, IntegerVector, IntMatrix, 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>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The integer vector that results from the crossover.</returns>
+    protected override IntegerVector CrossBounded(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
+      if (parents.Length != 2) throw new ArgumentException("RoundedBlendAlphaBetaCrossover: Number of parents is not equal to 2.", "parents");
+      if (MaximizationParameter.ActualValue == null) throw new InvalidOperationException("RoundedBlendAlphaBetaCrossover: Parameter " + MaximizationParameter.ActualName + " could not be found.");
+      if (QualityParameter.ActualValue == null || QualityParameter.ActualValue.Length != parents.Length) throw new InvalidOperationException("RoundedBlendAlphaBetaCrossover: 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("RoundedBlendAlphaBetaCrossover: Parameter " + AlphaParameter.ActualName + " or paramter " + BetaParameter.ActualName + " could not be found.");
+
+      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], bounds, AlphaParameter.ActualValue, BetaParameter.ActualValue);
+      else {
+        return Apply(random, parents[1], parents[0], bounds, AlphaParameter.ActualValue, BetaParameter.ActualValue);
+      }
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedBlendAlphaCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedBlendAlphaCrossover.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedBlendAlphaCrossover.cs	(revision 8019)
@@ -0,0 +1,119 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Rounded blend alpha crossover for integer vectors (BLX-a). Creates a new offspring by selecting a random value 
+  /// from the interval between the two alleles of the parent solutions and rounding the result to the next feasible
+  /// integer. The interval is increased in both directions by the factor alpha.
+  /// </summary>
+  [Item("RoundedBlendAlphaCrossover", "The rounded blend alpha crossover (BLX-a) for integer vectors creates new offspring by sampling a new value in the range [min_i - d * alpha, max_i + d * alpha) at each position i and rounding the result to the next feasible integer. 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.")]
+  [StorableClass]
+  public class RoundedBlendAlphaCrossover : BoundedIntegerVectorCrossover {
+    /// <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"]; }
+    }
+
+    [StorableConstructor]
+    protected RoundedBlendAlphaCrossover(bool deserializing) : base(deserializing) { }
+    protected RoundedBlendAlphaCrossover(RoundedBlendAlphaCrossover original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="RoundedBlendAlphaCrossover"/> with one parameter (<c>Alpha</c>).
+    /// </summary>
+    public RoundedBlendAlphaCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "The Alpha parameter controls the extension of the range beyond the two parents. It must be >= 0. A value of 0.5 means that half the range is added to both sides of the intervals.", new DoubleValue(0.5)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedBlendAlphaCrossover(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs the rounded blend alpha crossover (BLX-a) of two integer 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
+    /// and rounding the result to the next integer.
+    /// 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="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <param name="alpha">The alpha value for the crossover.</param>
+    /// <returns>The newly created integer vector resulting from the crossover operation.</returns>
+    public static IntegerVector Apply(IRandom random, IntegerVector parent1, IntegerVector parent2, IntMatrix bounds, DoubleValue alpha) {
+      if (parent1.Length != parent2.Length) throw new ArgumentException("RoundedBlendAlphaCrossover: The parents' vectors are of different length.", "parent1");
+      if (alpha.Value < 0) throw new ArgumentException("RoundedBlendAlphaCrossover: Paramter alpha must be greater or equal than 0.", "alpha");
+      if (bounds == null || bounds.Rows < 1 || bounds.Columns < 2) throw new ArgumentException("RoundedBlendAlphaCrossover: Invalid bounds specified.", "bounds");
+
+      int length = parent1.Length;
+      var result = new IntegerVector(length);
+      double max = 0, min = 0, d = 0, resMin = 0, resMax = 0;
+      int minBounds, maxBounds, step = 1;
+
+      for (int i = 0; i < length; i++) {
+        minBounds = bounds[i % bounds.Rows, 0];
+        maxBounds = bounds[i % bounds.Rows, 1];
+        if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+        max = Math.Max(parent1[i], parent2[i]);
+        min = Math.Min(parent1[i], parent2[i]);
+        d = Math.Abs(max - min);
+        resMin = FloorFeasible(minBounds, maxBounds, step, min - d * alpha.Value);
+        resMax = CeilingFeasible(minBounds, maxBounds, step, max + d * alpha.Value);
+
+        result[i] = RoundFeasible(minBounds, maxBounds, step, 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, RealVector, RealVector, 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>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The integer vector resulting from the crossover operation.</returns>
+    protected override IntegerVector CrossBounded(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
+      if (parents.Length != 2) throw new ArgumentException("RoundedBlendAlphaCrossover: The number of parents is not equal to 2", "parents");
+      if (AlphaParameter.ActualValue == null) throw new InvalidOperationException("RoundedBlendAlphaCrossover: Parameter " + AlphaParameter.ActualName + " could not be found.");
+      return Apply(random, parents[0], parents[1], bounds, AlphaParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedHeuristicCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedHeuristicCrossover.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedHeuristicCrossover.cs	(revision 8019)
@@ -0,0 +1,125 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Heuristic crossover for integer 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 result is then rounded to the next feasible integer.
+  /// 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>
+  [Item("RoundedHeuristicCrossover", "The heuristic crossover produces offspring that extend the better parent in direction from the worse to the better parent.")]
+  [StorableClass]
+  public class RoundedHeuristicCrossover : BoundedIntegerVectorCrossover {
+    /// <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 ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    [StorableConstructor]
+    protected RoundedHeuristicCrossover(bool deserializing) : base(deserializing) { }
+    protected RoundedHeuristicCrossover(RoundedHeuristicCrossover original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="RoundedHeuristicCrossover"/> with two variable infos
+    /// (<c>Maximization</c> and <c>Quality</c>).
+    /// </summary>
+    public RoundedHeuristicCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "Whether the problem is a maximization problem or not."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The quality values of the parents."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedHeuristicCrossover(this, cloner);
+    }
+
+    /// <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>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The newly created integer vector, resulting from the heuristic crossover.</returns>
+    public static IntegerVector Apply(IRandom random, IntegerVector betterParent, IntegerVector worseParent, IntMatrix bounds) {
+      if (betterParent.Length != worseParent.Length)
+        throw new ArgumentException("HeuristicCrossover: the two parents are not of the same length");
+
+      int length = betterParent.Length;
+      var result = new IntegerVector(length);
+      double factor = random.NextDouble();
+
+      int min, max, step = 1;
+      for (int i = 0; i < length; i++) {
+        min = bounds[i % bounds.Rows, 0];
+        max = bounds[i % bounds.Rows, 1];
+        if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+        result[i] = RoundFeasible(min, max, step, betterParent[i] + factor * (betterParent[i] - worseParent[i]));
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Performs a heuristic crossover operation for two given parent integer 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>
+    /// /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
+    protected override IntegerVector CrossBounded(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
+      if (parents.Length != 2) throw new ArgumentException("RoundedHeuristicCrossover: The number of parents is not equal to 2");
+
+      if (MaximizationParameter.ActualValue == null) throw new InvalidOperationException("RoundedHeuristicCrossover: Parameter " + MaximizationParameter.ActualName + " could not be found.");
+      if (QualityParameter.ActualValue == null || QualityParameter.ActualValue.Length != parents.Length) throw new InvalidOperationException("RoundedHeuristicCrossover: 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], bounds);
+      else
+        return Apply(random, parents[1], parents[0], bounds);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedLocalCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedLocalCrossover.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedLocalCrossover.cs	(revision 8019)
@@ -0,0 +1,85 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// The rounded local crossover for integer vectors is similar to the <see cref="UniformArithmeticCrossover"/>, but where the factor alpha is chosen randomly in the interval [0;1) for each position.
+  /// </summary>cribed in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL, p. 194.
+  /// </remarks>
+  [Item("RoundedLocalCrossover", @"The runded local crossover is similar to the arithmetic crossover, but uses a random alpha for each position x = alpha * p1 + (1-alpha) * p2.")]
+  [StorableClass]
+  public class RoundedLocalCrossover : BoundedIntegerVectorCrossover {
+    [StorableConstructor]
+    protected RoundedLocalCrossover(bool deserializing) : base(deserializing) { }
+    protected RoundedLocalCrossover(RoundedLocalCrossover original, Cloner cloner) : base(original, cloner) { }
+    public RoundedLocalCrossover() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedLocalCrossover(this, cloner);
+    }
+
+    /// <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 integer vector, resulting from the local crossover.</returns>
+    public static IntegerVector Apply(IRandom random, IntegerVector parent1, IntegerVector parent2, IntMatrix bounds) {
+      if (parent1.Length != parent2.Length)
+        throw new ArgumentException("RoundedLocalCrossover: the two parents are not of the same length");
+
+      double factor;
+      int length = parent1.Length;
+      var result = new IntegerVector(length);
+
+      int min, max, step = 1;
+      for (int i = 0; i < length; i++) {
+        min = bounds[i % bounds.Rows, 0];
+        max = bounds[i % bounds.Rows, 1];
+        if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+        factor = random.NextDouble();
+        result[i] = RoundFeasible(min, max, step, (factor * parent1[i]) + ((1 - factor) * parent2[i]));
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Performs a local crossover operation for two given parent integer 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>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
+    protected override IntegerVector CrossBounded(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
+      if (parents.Length != 2) throw new ArgumentException("RoundedLocalCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1], bounds);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedUniformArithmeticCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedUniformArithmeticCrossover.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedUniformArithmeticCrossover.cs	(revision 8019)
@@ -0,0 +1,110 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// The rounded uniform 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>
+  [Item("RoundedUniformSomePositionsArithmeticCrossover", "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).")]
+  [StorableClass]
+  public class RoundedUniformArithmeticCrossover : BoundedIntegerVectorCrossover, IBoundedIntegerVectorOperator {
+
+    /// <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"]; }
+    }
+
+    [StorableConstructor]
+    protected RoundedUniformArithmeticCrossover(bool deserializing) : base(deserializing) { }
+    protected RoundedUniformArithmeticCrossover(RoundedUniformArithmeticCrossover original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance with two parameters (<c>Alpha</c> and <c>Probability</c>).
+    /// </summary>
+    public RoundedUniformArithmeticCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "The alpha value in the range (0;1) that defines whether the point should be close to parent1 (->1) or parent2 (->0)", new DoubleValue(0.5)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Probability", "The probability for crossing a position in the range (0;1]", new DoubleValue(1)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedUniformArithmeticCrossover(this, cloner);
+    }
+
+    /// <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="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <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 IntegerVector Apply(IRandom random, IntegerVector parent1, IntegerVector parent2, IntMatrix bounds, DoubleValue alpha, DoubleValue probability) {
+      int length = parent1.Length;
+      if (length != parent2.Length) throw new ArgumentException("RoundedUniformArithmeticCrossover: The parent vectors are of different length.", "parent1");
+      if (alpha.Value < 0 || alpha.Value > 1) throw new ArgumentException("RoundedUniformArithmeticCrossover: Parameter alpha must be in the range [0;1]", "alpha");
+      if (probability.Value < 0 || probability.Value > 1) throw new ArgumentException("RoundedUniformArithmeticCrossover: Parameter probability must be in the range [0;1]", "probability");
+
+      var result = new IntegerVector(length);
+      for (int i = 0; i < length; i++) {
+        if (random.NextDouble() < probability.Value) {
+          int min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1], step = 1;
+          if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+          double value = alpha.Value * parent1[i] + (1 - alpha.Value) * parent2[i];
+          result[i] = RoundFeasible(min, max, step, value);
+        } 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 the static Apply method.
+    /// </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>
+    /// /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The vector resulting from the crossover.</returns>
+    protected override IntegerVector CrossBounded(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
+      if (parents.Length != 2) throw new ArgumentException("RoundedUniformArithmeticCrossover: There must be exactly two parents.", "parents");
+      if (AlphaParameter.ActualValue == null) throw new InvalidOperationException("RoundedUniformArithmeticCrossover: Parameter " + AlphaParameter.ActualName + " could not be found.");
+      if (ProbabilityParameter.ActualValue == null) throw new InvalidOperationException("RoundedUniformArithmeticCrossover: Parameter " + ProbabilityParameter.ActualName + " could not be found.");
+      return Apply(random, parents[0], parents[1], bounds, AlphaParameter.ActualValue, ProbabilityParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs	(revision 7259)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs	(revision 8019)
@@ -54,5 +54,5 @@
     public static IntegerVector Apply(IRandom random, IntegerVector parent1, IntegerVector parent2) {
       if (parent1.Length != parent2.Length)
-        throw new ArgumentException("DiscreteCrossover: The parents are of different length.");
+        throw new ArgumentException("SinglePointCrossover: The parents are of different length.");
 
       int length = parent1.Length;
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj	(revision 7259)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj	(revision 8019)
@@ -41,5 +41,5 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
@@ -50,5 +50,5 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
@@ -58,5 +58,5 @@
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
     <DebugSymbols>true</DebugSymbols>
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <DebugType>full</DebugType>
@@ -66,5 +66,5 @@
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <Optimize>true</Optimize>
@@ -76,5 +76,5 @@
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
     <DebugSymbols>true</DebugSymbols>
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <DebugType>full</DebugType>
@@ -84,5 +84,5 @@
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <Optimize>true</Optimize>
@@ -93,4 +93,48 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization.Operators-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <Private>False</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core">
@@ -106,12 +150,21 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="BoundedIntegerVectorCrossover.cs" />
+    <Compile Include="BoundedIntegerVectorManipulator.cs" />
     <Compile Include="Creators\UniformRandomIntegerVectorCreator.cs" />
+    <Compile Include="Crossovers\RoundedAverageCrossover.cs" />
     <Compile Include="Crossovers\DiscreteCrossover.cs">
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="Crossovers\MultiIntegerVectorCrossover.cs" />
+    <Compile Include="Crossovers\RoundedBlendAlphaBetaCrossover.cs" />
+    <Compile Include="Crossovers\RoundedBlendAlphaCrossover.cs" />
+    <Compile Include="Crossovers\RoundedHeuristicCrossover.cs" />
+    <Compile Include="Crossovers\RoundedLocalCrossover.cs" />
     <Compile Include="Crossovers\SinglePointCrossover.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="Crossovers\RoundedUniformArithmeticCrossover.cs" />
+    <Compile Include="Interfaces\IBoundedIntegerVectorOperator.cs" />
     <Compile Include="Interfaces\IIntegerVectorCreator.cs" />
     <Compile Include="Interfaces\IIntegerVectorCrossover.cs" />
@@ -121,4 +174,14 @@
     <Compile Include="IntegerVectorCrossover.cs" />
     <Compile Include="IntegerVectorManipulator.cs" />
+    <Compile Include="Interfaces\IIntegerVectorStdDevStrategyParameterCreator.cs" />
+    <Compile Include="Interfaces\IIntegerVectorStdDevStrategyParameterCrossover.cs" />
+    <Compile Include="Interfaces\IIntegerVectorStdDevStrategyParameterManipulator.cs" />
+    <Compile Include="Interfaces\IIntegerVectorStdDevStrategyParameterOperator.cs" />
+    <Compile Include="Manipulators\UniformSomePositionsManipulator.cs" />
+    <Compile Include="Manipulators\RoundedNormalAllPositionsManipulator.cs" />
+    <Compile Include="Manipulators\SelfAdaptiveRoundedNormalAllPositionsManipulator.cs" />
+    <Compile Include="Manipulators\StdDevStrategyVectorCreator.cs" />
+    <Compile Include="Manipulators\StdDevStrategyVectorCrossover.cs" />
+    <Compile Include="Manipulators\StdDevStrategyVectorManipulator.cs" />
     <Compile Include="Manipulators\UniformOnePositionManipulator.cs">
       <SubType>Code</SubType>
@@ -129,56 +192,4 @@
     <Compile Include="IntegerVectorCreator.cs" />
     <Compile Include="ShakingOperators\IntegerVectorShakingOperator.cs" />
-  </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>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
-      <Project>{A9AD58B9-3EF9-4CC1-97E5-8D909039FF5C}</Project>
-      <Name>HeuristicLab.Common-3.3</Name>
-      <Private>False</Private>
-    </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>
-      <Private>False</Private>
-    </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>
-      <Private>False</Private>
-    </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>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Optimization.Operators\3.3\HeuristicLab.Optimization.Operators-3.3.csproj">
-      <Project>{25087811-F74C-4128-BC86-8324271DA13E}</Project>
-      <Name>HeuristicLab.Optimization.Operators-3.3</Name>
-      <Private>False</Private>
-    </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>
-      <Private>False</Private>
-    </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>
-      <Private>False</Private>
-    </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>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
-      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
-      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVector.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVector.cs	(revision 7259)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVector.cs	(revision 8019)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -49,13 +50,29 @@
     }
 
-    public virtual void Randomize(IRandom random, int startIndex, int length, int min, int max) {
+    public virtual void Randomize(IRandom random, int startIndex, int length, int min, int max, int step = 1) {
       if (length > 0) {
-        for (int i = 0; i < length; i++)
-          array[startIndex + i] = random.Next(min, max);
+        int numbers = (int)Math.Floor((max - min) / (double)step);
+        for (int i = startIndex; i < startIndex + length; i++) {
+          array[i] = random.Next(numbers) * step + min;
+        }
         OnReset();
       }
     }
-    public void Randomize(IRandom random, int min, int max) {
-      Randomize(random, 0, Length, min, max);
+    public virtual void Randomize(IRandom random, int startIndex, int length, IntMatrix bounds) {
+      if (length > 0) {
+        for (int i = startIndex; i < startIndex + length; i++) {
+          int min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1], step = 1;
+          if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+          int numbers = (int)Math.Floor((max - min) / (double)step);
+          array[i] = random.Next(numbers) * step + min;
+        }
+        OnReset();
+      }
+    }
+    public void Randomize(IRandom random, int min, int max, int step = 1) {
+      Randomize(random, 0, Length, min, max, step);
+    }
+    public void Randomize(IRandom random, IntMatrix bounds) {
+      Randomize(random, 0, Length, bounds);
     }
   }
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCreator.cs	(revision 7259)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCreator.cs	(revision 8019)
@@ -47,9 +47,6 @@
       get { return (IValueLookupParameter<IntValue>)Parameters["Length"]; }
     }
-    public IValueLookupParameter<IntValue> MinimumParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Minimum"]; }
-    }
-    public IValueLookupParameter<IntValue> MaximumParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Maximum"]; }
+    public IValueLookupParameter<IntMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
     }
 
@@ -62,14 +59,30 @@
       Parameters.Add(new LookupParameter<IntegerVector>("IntegerVector", "The vector which should be manipulated."));
       Parameters.Add(new ValueLookupParameter<IntValue>("Length", "The length of the vector."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("Minimum", "The inclusive lower bound for each element in the vector."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("Maximum", "The exclusive upper bound for each element in the vector."));
+      Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
     }
 
+    // BackwardsCompatibility3.3
+    #region Backwards compatible code, remove with 3.4
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey("Bounds")) {
+        var min = ((IValueLookupParameter<IntValue>)Parameters["Minimum"]).Value as IntValue;
+        var max = ((IValueLookupParameter<IntValue>)Parameters["Maximum"]).Value as IntValue;
+        Parameters.Remove("Minimum");
+        Parameters.Remove("Maximum");
+        Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
+        if (min != null && max != null) {
+          BoundsParameter.Value = new IntMatrix(new int[,] { { min.Value, max.Value, 1 } });
+        }
+      }
+    }
+    #endregion
+
     public sealed override IOperation Apply() {
-      IntegerVectorParameter.ActualValue = Create(RandomParameter.ActualValue, LengthParameter.ActualValue, MinimumParameter.ActualValue, MaximumParameter.ActualValue);
+      IntegerVectorParameter.ActualValue = Create(RandomParameter.ActualValue, LengthParameter.ActualValue, BoundsParameter.ActualValue);
       return base.Apply();
     }
 
-    protected abstract IntegerVector Create(IRandom random, IntValue length, IntValue minimum, IntValue maximum);
+    protected abstract IntegerVector Create(IRandom random, IntValue length, IntMatrix bounds);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IBoundedIntegerVectorOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IBoundedIntegerVectorOperator.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IBoundedIntegerVectorOperator.cs	(revision 8019)
@@ -0,0 +1,32 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  public interface IBoundedIntegerVectorOperator : IIntegerVectorOperator {
+    /// <summary>
+    /// The bounds parameter must contain at least one row and at least two columns. The first two columns specify min and max values, the last column specifies the step size, but is optional (1 is assumed if omitted).
+    /// </summary>
+    IValueLookupParameter<IntMatrix> BoundsParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCreator.cs	(revision 7259)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCreator.cs	(revision 8019)
@@ -28,8 +28,6 @@
   /// An interface which represents an operator for creating vectors of int-valued data.
   /// </summary>
-  public interface IIntegerVectorCreator : IIntegerVectorOperator, ISolutionCreator {
+  public interface IIntegerVectorCreator : ISolutionCreator, IBoundedIntegerVectorOperator {
     IValueLookupParameter<IntValue> LengthParameter { get; }
-    IValueLookupParameter<IntValue> MinimumParameter { get; }
-    IValueLookupParameter<IntValue> MaximumParameter { get; }
     ILookupParameter<IntegerVector> IntegerVectorParameter { get; }
   }
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterCreator.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterCreator.cs	(revision 8019)
@@ -0,0 +1,31 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.IntegerVectorEncoding {
+  public interface IIntegerVectorStdDevStrategyParameterCreator : IIntegerVectorStdDevStrategyParameterOperator, IStrategyParameterCreator {
+    IValueLookupParameter<IntValue> LengthParameter { get; }
+    IValueLookupParameter<DoubleMatrix> BoundsParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterCrossover.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterCrossover.cs	(revision 8019)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.IntegerVectorEncoding {
+  public interface IIntegerVectorStdDevStrategyParameterCrossover : IIntegerVectorStdDevStrategyParameterOperator, IStrategyParameterCrossover {
+    ILookupParameter<ItemArray<DoubleArray>> ParentsParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterManipulator.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterManipulator.cs	(revision 8019)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.IntegerVectorEncoding {
+  public interface IIntegerVectorStdDevStrategyParameterManipulator : IIntegerVectorStdDevStrategyParameterOperator, IStrategyParameterManipulator {
+    IValueLookupParameter<DoubleMatrix> BoundsParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterOperator.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterOperator.cs	(revision 8019)
@@ -0,0 +1,24 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  public interface IIntegerVectorStdDevStrategyParameterOperator { }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/RoundedNormalAllPositionsManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/RoundedNormalAllPositionsManipulator.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/RoundedNormalAllPositionsManipulator.cs	(revision 8019)
@@ -0,0 +1,92 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Manipulates each dimension in the integer vector with the mutation strength given 
+  /// in the sigma parameter vector and rounds the result to the next feasible value.
+  /// </summary>
+  [Item("RoundedNormalAllPositionsManipulator", "This manipulation operator adds a value sigma_i * N_i(0,1) to the current value in each position i given the values for sigma_i in the parameter. The result is rounded to the next feasible value. If there are less elements in Sigma than positions, then Sigma is cycled.")]
+  [StorableClass]
+  public class RoundedNormalAllPositionsManipulator : BoundedIntegerVectorManipulator {
+
+    public IValueParameter<DoubleArray> SigmaParameter {
+      get { return (IValueParameter<DoubleArray>)Parameters["Sigma"]; }
+    }
+
+    [StorableConstructor]
+    protected RoundedNormalAllPositionsManipulator(bool deserializing) : base(deserializing) { }
+    protected RoundedNormalAllPositionsManipulator(RoundedNormalAllPositionsManipulator original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="RoundedNormalAllPositionsManipulator"/> with one
+    /// parameter (<c>Sigma</c>).
+    /// </summary>
+    public RoundedNormalAllPositionsManipulator()
+      : base() {
+      Parameters.Add(new ValueParameter<DoubleArray>("Sigma", "The vector containing the standard deviations used for manipulating each dimension. If it is only of length one the same sigma will be used for every dimension.", new DoubleArray(new double[] { 1 })));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedNormalAllPositionsManipulator(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs a normally distributed all position manipulation on the given 
+    /// <paramref name="vector"/> and rounds the result to the next feasible value.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown when the sigma vector is null or of length 0.</exception>
+    /// <param name="sigma">The sigma vector determining the strength of the mutation.</param>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="vector">The integer vector to manipulate.</param>#
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The manipulated integer vector.</returns>
+    public static void Apply(IRandom random, IntegerVector vector, IntMatrix bounds, DoubleArray sigma) {
+      if (sigma == null || sigma.Length == 0) throw new ArgumentException("RoundedNormalAllPositionsManipulator: Vector containing the standard deviations is not defined.", "sigma");
+      if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("RoundedNormalAllPositionsManipulator: Invalid bounds specified.", "bounds");
+      var N = new NormalDistributedRandom(random, 0.0, 1.0);
+      for (int i = 0; i < vector.Length; i++) {
+        int min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1], step = 1;
+        if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+
+        int value = (vector[i] + (int)Math.Round((N.NextDouble() * sigma[i % sigma.Length])) - min) / step;
+        vector[i] = RoundFeasible(min, max, step, value);
+      }
+    }
+
+    /// <summary>
+    /// Retrieves the bounds and forwards the call to the static Apply method.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="vector">The vector of integer values that is manipulated.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    protected override void ManipulateBounded(IRandom random, IntegerVector vector, IntMatrix bounds) {
+      Apply(random, vector, bounds, SigmaParameter.Value);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/SelfAdaptiveRoundedNormalAllPositionsManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/SelfAdaptiveRoundedNormalAllPositionsManipulator.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/SelfAdaptiveRoundedNormalAllPositionsManipulator.cs	(revision 8019)
@@ -0,0 +1,103 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Manipulates each dimension in the integer vector with the mutation strength given 
+  /// in the strategy parameter vector.
+  /// </summary>
+  [Item("SelfAdaptiveRoundedNormalAllPositionsManipulator", "This manipulation operator adds a value sigma_i * N(0,1) to the current value in each position i. The resulting value is rounded to the next feasible value. The values for sigma_i are looked up dynamically. If there are less elements in the strategy vector than positions, then the strategy vector is cycled.")]
+  [StorableClass]
+  public class SelfAdaptiveRoundedNormalAllPositionsManipulator : BoundedIntegerVectorManipulator, ISelfAdaptiveManipulator {
+    public Type StrategyParameterType {
+      get { return typeof(IIntegerVectorStdDevStrategyParameterOperator); }
+    }
+    /// <summary>
+    /// Parameter for the strategy vector.
+    /// </summary>
+    public ILookupParameter<DoubleArray> StrategyParameterParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["StrategyParameter"]; }
+    }
+
+    IParameter ISelfAdaptiveManipulator.StrategyParameterParameter {
+      get { return StrategyParameterParameter; }
+    }
+
+    [StorableConstructor]
+    protected SelfAdaptiveRoundedNormalAllPositionsManipulator(bool deserializing) : base(deserializing) { }
+    protected SelfAdaptiveRoundedNormalAllPositionsManipulator(SelfAdaptiveRoundedNormalAllPositionsManipulator original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="SelfAdaptiveRoundedNormalAllPositionsManipulator"/> with one.
+    /// </summary>
+    public SelfAdaptiveRoundedNormalAllPositionsManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleArray>("StrategyParameter", "The vector containing the endogenous strategy parameters."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SelfAdaptiveRoundedNormalAllPositionsManipulator(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs an adaptive normally distributed all position manipulation on the given 
+    /// <paramref name="vector"/> and rounding the results to the next feasible value.
+    /// </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 integer vector to manipulate.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    public static void Apply(IRandom random, IntegerVector vector, IntMatrix bounds, DoubleArray strategyParameters) {
+      if (strategyParameters == null || strategyParameters.Length == 0) throw new ArgumentException("SelfAdaptiveRoundedNormalAllPositionsManipulator: Vector containing the standard deviations is not defined.", "sigma");
+      if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("SelfAdaptiveRoundedNormalAllPositionsManipulator: Invalid bounds specified.", "bounds");
+      var N = new NormalDistributedRandom(random, 0.0, 1.0);
+      if (strategyParameters != null) {
+        for (int i = 0; i < vector.Length; i++) {
+          int min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1], step = 1;
+          if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+
+          int value = (vector[i] + (int)Math.Round((N.NextDouble() * strategyParameters[i % strategyParameters.Length])) - min) / step;
+          vector[i] = RoundFeasible(min, max, step, value);
+        }
+      }
+    }
+
+    /// <summary>
+    /// Checks that the strategy vector is not null and forwards the call to the static Apply method.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="vector">The vector of integer values that is manipulated.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    protected override void ManipulateBounded(IRandom random, IntegerVector vector, IntMatrix bounds) {
+      Apply(random, vector, bounds, StrategyParameterParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/StdDevStrategyVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/StdDevStrategyVectorCreator.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/StdDevStrategyVectorCreator.cs	(revision 8019)
@@ -0,0 +1,78 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  [Item("StdDevStrategyVectorCreator", "Creates the endogeneous strategy parameters.")]
+  [StorableClass]
+  public class StdDevStrategyVectorCreator : SingleSuccessorOperator, IStochasticOperator, IIntegerVectorStdDevStrategyParameterCreator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<DoubleArray> StrategyParameterParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["StrategyParameter"]; }
+    }
+    public IValueLookupParameter<IntValue> LengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Length"]; }
+    }
+    public IValueLookupParameter<DoubleMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
+
+    [StorableConstructor]
+    protected StdDevStrategyVectorCreator(bool deserializing) : base(deserializing) { }
+    protected StdDevStrategyVectorCreator(StdDevStrategyVectorCreator original, Cloner cloner) : base(original, cloner) { }
+    public StdDevStrategyVectorCreator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new LookupParameter<DoubleArray>("StrategyParameter", "The crossed strategy parameter."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Length", "The length of the vector."));
+      Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "A 2 column matrix specifying the lower and upper bound for each dimension. If there are less rows than dimension the bounds vector is cycled.", new DoubleMatrix(new double[,] { { 0, 5 } })));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StdDevStrategyVectorCreator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      StrategyParameterParameter.ActualValue = Randomize(RandomParameter.ActualValue, LengthParameter.ActualValue.Value, BoundsParameter.ActualValue);
+      return base.Apply();
+    }
+
+    private DoubleArray Randomize(IRandom random, int length, DoubleMatrix bounds) {
+      var result = new DoubleArray(length);
+      for (int i = 0; i < length; i++) {
+        result[i] = random.NextDouble() * bounds[i % bounds.Rows, 1] - bounds[i % bounds.Rows, 0];
+      }
+      return result;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/StdDevStrategyVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/StdDevStrategyVectorCrossover.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/StdDevStrategyVectorCrossover.cs	(revision 8019)
@@ -0,0 +1,79 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  [Item("StdDevStrategyVectorCrossover", "Crosses the strategy vector by using intermediate recombination (average crossover).")]
+  [StorableClass]
+  public class StdDevStrategyVectorCrossover : SingleSuccessorOperator, IStochasticOperator, IIntegerVectorStdDevStrategyParameterCrossover {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemArray<DoubleArray>> ParentsParameter {
+      get { return (ILookupParameter<ItemArray<DoubleArray>>)Parameters["ParentStrategyParameter"]; }
+    }
+    public ILookupParameter<DoubleArray> StrategyParameterParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["StrategyParameter"]; }
+    }
+
+    [StorableConstructor]
+    protected StdDevStrategyVectorCrossover(bool deserializing) : base(deserializing) { }
+    protected StdDevStrategyVectorCrossover(StdDevStrategyVectorCrossover original, Cloner cloner) : base(original, cloner) { }
+    public StdDevStrategyVectorCrossover()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>("ParentStrategyParameter", "The strategy parameters to cross."));
+      Parameters.Add(new LookupParameter<DoubleArray>("StrategyParameter", "The crossed strategy parameter."));
+      ParentsParameter.ActualName = "StrategyParameter";
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StdDevStrategyVectorCrossover(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      StrategyParameterParameter.ActualValue = Average(RandomParameter.ActualValue, ParentsParameter.ActualValue);
+      return base.Apply();
+    }
+
+    private DoubleArray Average(IRandom random, ItemArray<DoubleArray> parents) {
+      int length = parents[0].Length;
+      var result = new DoubleArray(length);
+      for (int i = 0; i < length; i++) {
+        for (int p = 0; p < parents.Length; p++) {
+          result[i] += parents[p][i];
+        }
+        result[i] /= parents.Length;
+      }
+      return result;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/StdDevStrategyVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/StdDevStrategyVectorManipulator.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/StdDevStrategyVectorManipulator.cs	(revision 8019)
@@ -0,0 +1,113 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Mutates the endogenous strategy parameters.
+  /// </summary>
+  [Item("StdDevStrategyVectorManipulator", "Mutates the endogenous strategy parameters.")]
+  [StorableClass]
+  public class StdDevStrategyVectorManipulator : SingleSuccessorOperator, IStochasticOperator, IIntegerVectorStdDevStrategyParameterManipulator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<DoubleArray> StrategyParameterParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["StrategyParameter"]; }
+    }
+    public IValueLookupParameter<DoubleValue> GeneralLearningRateParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["GeneralLearningRate"]; }
+    }
+    public IValueLookupParameter<DoubleValue> LearningRateParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["LearningRate"]; }
+    }
+    public IValueLookupParameter<DoubleMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
+
+    [StorableConstructor]
+    protected StdDevStrategyVectorManipulator(bool deserializing) : base(deserializing) { }
+    protected StdDevStrategyVectorManipulator(StdDevStrategyVectorManipulator original, Cloner cloner) : base(original, cloner) { }
+    public StdDevStrategyVectorManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new LookupParameter<DoubleArray>("StrategyParameter", "The strategy parameter to manipulate."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("GeneralLearningRate", "The general learning rate (tau0)."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("LearningRate", "The learning rate (tau)."));
+      Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "A 2 column matrix specifying the lower and upper bound for each dimension. If there are less rows than dimension the bounds vector is cycled.", new DoubleMatrix(new double[,] { { 0, 5 } })));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StdDevStrategyVectorManipulator(this, cloner);
+    }
+
+    /// <summary>
+    /// Mutates the endogenous strategy parameters.
+    /// </summary>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="vector">The strategy vector to manipulate.</param>
+    /// <param name="generalLearningRate">The general learning rate dampens the mutation over all dimensions.</param>
+    /// <param name="learningRate">The learning rate dampens the mutation in each dimension.</param>
+    /// <param name="bounds">The minimal and maximal value for each component, bounds are cycled if the length of bounds is smaller than the length of vector</param>
+    public static void Apply(IRandom random, DoubleArray vector, double generalLearningRate, double learningRate, DoubleMatrix bounds) {
+      NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0);
+      double generalMultiplier = Math.Exp(generalLearningRate * N.NextDouble());
+      for (int i = 0; i < vector.Length; i++) {
+        double change = vector[i] * generalMultiplier * Math.Exp(learningRate * N.NextDouble());
+        if (bounds != null) {
+          double min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1];
+          if (min == max) vector[i] = min;
+          else {
+            if (change < min || change > max) change = Math.Max(min, Math.Min(max, change));
+            vector[i] = change;
+          }
+        }
+      }
+    }
+    /// <summary>
+    /// Mutates the endogenous strategy parameters.
+    /// </summary>
+    /// <remarks>Calls <see cref="OperatorBase.Apply"/> of base class <see cref="OperatorBase"/>.</remarks>
+    /// <inheritdoc select="returns"/>
+    public override IOperation Apply() {
+      var strategyParams = StrategyParameterParameter.ActualValue;
+      if (strategyParams != null) { // only apply if there is a strategy vector
+        IRandom random = RandomParameter.ActualValue;
+        double tau0 = GeneralLearningRateParameter.ActualValue.Value;
+        double tau = LearningRateParameter.ActualValue.Value;
+        Apply(random, strategyParams, tau0, tau, BoundsParameter.ActualValue);
+      }
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformOnePositionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformOnePositionManipulator.cs	(revision 7259)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformOnePositionManipulator.cs	(revision 8019)
@@ -36,17 +36,5 @@
   [Item("UniformOnePositionManipulator", " Uniformly distributed change of a single position of an integer vector. It is implemented as described in Michalewicz, Z. 1999. Genetic Algorithms + Data Structures = Evolution Programs. Third, Revised and Extended Edition, Spring-Verlag Berlin Heidelberg.")]
   [StorableClass]
-  public class UniformOnePositionManipulator : IntegerVectorManipulator {
-    /// <summary>
-    /// The lower bound of the values in the int vector.
-    /// </summary>
-    public ValueLookupParameter<IntValue> MinimumParameter {
-      get { return (ValueLookupParameter<IntValue>)Parameters["Minimum"]; }
-    }
-    /// <summary>
-    /// The upper bound of the values in the int vector.
-    /// </summary>
-    public ValueLookupParameter<IntValue> MaximumParameter {
-      get { return (ValueLookupParameter<IntValue>)Parameters["Maximum"]; }
-    }
+  public class UniformOnePositionManipulator : BoundedIntegerVectorManipulator {
 
     [StorableConstructor]
@@ -57,13 +45,26 @@
     /// (<c>Minimum</c> and <c>Maximum</c>).
     /// </summary>
-    public UniformOnePositionManipulator()
-      : base() {
-      Parameters.Add(new ValueLookupParameter<IntValue>("Minimum", "Minimum of the sampling range for the vector element (included)"));
-      Parameters.Add(new ValueLookupParameter<IntValue>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
-    }
+    public UniformOnePositionManipulator() : base() { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
       return new UniformOnePositionManipulator(this, cloner);
     }
+
+    // BackwardsCompatibility3.3
+    #region Backwards compatible code, remove with 3.4
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey("Bounds")) {
+        var min = ((IValueLookupParameter<IntValue>)Parameters["Minimum"]).Value as IntValue;
+        var max = ((IValueLookupParameter<IntValue>)Parameters["Maximum"]).Value as IntValue;
+        Parameters.Remove("Minimum");
+        Parameters.Remove("Maximum");
+        Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
+        if (min != null && max != null) {
+          BoundsParameter.Value = new IntMatrix(new int[,] { { min.Value, max.Value, 1 } });
+        }
+      }
+    }
+    #endregion
 
     /// <summary>
@@ -76,7 +77,14 @@
     /// <param name="max">The maximum value of the sampling range for
     /// the vector element to change (exclusive).</param>
-    public static void Apply(IRandom random, IntegerVector vector, IntValue min, IntValue max) {
-      int index = random.Next(vector.Length);
-      vector[index] = random.Next(min.Value, max.Value);
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    public static void Apply(IRandom random, IntegerVector vector, IntMatrix bounds) {
+      Manipulate(random, vector, bounds, random.Next(vector.Length));
+    }
+
+    public static void Manipulate(IRandom random, IntegerVector vector, IntMatrix bounds, int index) {
+      if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("UniformOnePositionManipulator: Invalid bounds specified", "bounds");
+      int min = bounds[index % bounds.Rows, 0], max = bounds[index % bounds.Rows, 1], step = 1;
+      if (bounds.Columns > 2) step = bounds[index % bounds.Rows, 2];
+      vector[index] = RoundFeasible(min, max, step, random.Next(min, max + 1));
     }
 
@@ -87,8 +95,8 @@
     /// <param name="random">A random number generator.</param>
     /// <param name="vector">The integer vector to manipulate.</param>
-    protected override void Manipulate(IRandom random, IntegerVector vector) {
-      if (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, vector, MinimumParameter.ActualValue, MaximumParameter.ActualValue);
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    protected override void ManipulateBounded(IRandom random, IntegerVector vector, IntMatrix bounds) {
+      if (BoundsParameter.ActualValue == null) throw new InvalidOperationException("UniformOnePositionManipulator: Parameter " + BoundsParameter.ActualName + " could not be found.");
+      Apply(random, vector, bounds);
     }
   }
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformSomePositionsManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformSomePositionsManipulator.cs	(revision 8019)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformSomePositionsManipulator.cs	(revision 8019)
@@ -0,0 +1,89 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Uniformly distributed change of several, but at least one, positions of an integer 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("UniformSomePositionsManipulator", "Uniformly distributed change of several, but at least one, positions of an integer vector. It is implemented as described in Michalewicz, Z. 1999. Genetic Algorithms + Data Structures = Evolution Programs. Third, Revised and Extended Edition, Spring-Verlag Berlin Heidelberg.")]
+  [StorableClass]
+  public class UniformSomePositionsManipulator : BoundedIntegerVectorManipulator {
+
+    public IValueLookupParameter<DoubleValue> ProbabilityParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Probability"]; }
+    }
+
+    [StorableConstructor]
+    protected UniformSomePositionsManipulator(bool deserializing) : base(deserializing) { }
+    protected UniformSomePositionsManipulator(UniformSomePositionsManipulator original, Cloner cloner) : base(original, cloner) { }
+    public UniformSomePositionsManipulator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Probability", "The probability for each dimension to be manipulated.", new DoubleValue(0.5)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformSomePositionsManipulator(this, cloner);
+    }
+
+    /// <summary>
+    /// Changes randomly several, but at least one, positions in the given integer <paramref name="vector"/>, according to the given probabilities.
+    /// </summary>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="vector">The integer vector to manipulate.</param>
+    /// <param name="bounds"> Contains the minimum value (inclusive), maximum value (exclusive), and step size of the sampling range for 
+    /// the vector element to change.</param>
+    /// <param name="probability">The probability for each dimension to be manipulated..</param>
+    public static void Apply(IRandom random, IntegerVector vector, IntMatrix bounds, double probability) {
+      if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("UniformSomePositionsManipulator: Invalid bounds specified", "bounds");
+      bool atLeastOneManipulated = false;
+      for (int index = 0; index < vector.Length; index++) {
+        if (random.NextDouble() < probability) {
+          atLeastOneManipulated = true;
+          UniformOnePositionManipulator.Manipulate(random, vector, bounds, index);
+        }
+      }
+
+      if (!atLeastOneManipulated) {
+        UniformOnePositionManipulator.Manipulate(random, vector, bounds, random.Next(vector.Length));
+      }
+    }
+
+    /// <summary>
+    /// Changes randomly several, but at least one, positions in the given integer <paramref name="vector"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="vector">The integer vector to manipulate.</param>
+    protected override void ManipulateBounded(IRandom random, IntegerVector vector, IntMatrix bounds) {
+      Apply(random, vector, bounds, ProbabilityParameter.ActualValue.Value);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Plugin.cs.frame
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Plugin.cs.frame	(revision 7259)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Plugin.cs.frame	(revision 8019)
@@ -37,4 +37,5 @@
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Random", "3.3")]
   public class HeuristicLabEncodingsIntegerVectorEncodingPlugin : PluginBase {
   }
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/ShakingOperators/IntegerVectorShakingOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/ShakingOperators/IntegerVectorShakingOperator.cs	(revision 7259)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/ShakingOperators/IntegerVectorShakingOperator.cs	(revision 8019)
@@ -58,5 +58,5 @@
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator that will be used for stochastic shaking operators."));
       foreach (IIntegerVectorManipulator shaker in ApplicationManager.Manager.GetInstances<IIntegerVectorManipulator>().OrderBy(x => x.Name))
-        Operators.Add(shaker);
+        if (!(shaker is ISelfAdaptiveManipulator)) Operators.Add(shaker);
     }
 
