Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj	(revision 5382)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj	(revision 5385)
@@ -111,4 +111,5 @@
     <Compile Include="BoundsChecker.cs" />
     <Compile Include="Creators\UniformRandomRealVectorCreator.cs" />
+    <Compile Include="Manipulators\SelfAdaptiveNormalAllPositionsManipulator.cs" />
     <Compile Include="RealVectorCreator.cs" />
     <Compile Include="RealVectorCrossover.cs" />
@@ -140,5 +141,5 @@
     <Compile Include="Interfaces\IRealVectorMoveOperator.cs" />
     <Compile Include="Manipulators\MultiRealVectorManipulator.cs" />
-    <Compile Include="Manipulators\NormalAllPositionsManipulator.cs" />
+    <Compile Include="Manipulators\FixedNormalAllPositionsManipulator.cs" />
     <Compile Include="Moves\AdditiveMoveTabuChecker.cs" />
     <Compile Include="Moves\AdditiveMoveTabuMaker.cs" />
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/FixedNormalAllPositionsManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/FixedNormalAllPositionsManipulator.cs	(revision 5385)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/FixedNormalAllPositionsManipulator.cs	(revision 5385)
@@ -0,0 +1,89 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.RealVectorEncoding {
+  /// <summary>
+  /// Manipulates each dimension in the real vector with the mutation strength given 
+  /// in the strategy parameter vector.
+  /// </summary>
+  /// <remarks>
+  /// It is implemented as described in Beyer, H.-G. and Schwefel, H.-P. 2002. Evolution Strategies - A Comprehensive Introduction Natural Computing, 1, pp. 3-52.<br/>
+  /// The strategy vector can be of smaller length than the solution vector, in which case values are taken from the beginning again once the end of the strategy vector is reached.
+  /// </remarks>
+  [Item("FixedNormalAllPositionsManipulator", "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. If there are less elements in Sigma than positions, then Sigma is cycled. It is implemented as described in Beyer, H.-G. and Schwefel, H.-P. 2002. Evolution Strategies - A Comprehensive Introduction Natural Computing, 1, pp. 3-52.")]
+  [StorableClass]
+  public class FixedNormalAllPositionsManipulator : RealVectorManipulator {
+
+    public IValueParameter<RealVector> SigmaParameter {
+      get { return (IValueParameter<RealVector>)Parameters["Sigma"]; }
+    }
+
+    [StorableConstructor]
+    protected FixedNormalAllPositionsManipulator(bool deserializing) : base(deserializing) { }
+    protected FixedNormalAllPositionsManipulator(FixedNormalAllPositionsManipulator original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="NormalAllPositionsManipulator"/> with one
+    /// parameter (<c>StrategyVector</c>).
+    /// </summary>
+    public FixedNormalAllPositionsManipulator()
+      : base() {
+      Parameters.Add(new ValueParameter<RealVector>("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 RealVector(new double[] { 1 })));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new FixedNormalAllPositionsManipulator(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs an adaptive normally distributed all position manipulation on the given 
+    /// <paramref name="vector"/>.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown when the strategy vector is not
+    /// as long as the vector to get manipulated.</exception>
+    /// <param name="sigma">The strategy vector determining the strength of the mutation.</param>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="vector">The real vector to manipulate.</param>
+    /// <returns>The manipulated real vector.</returns>
+    public static void Apply(IRandom random, RealVector vector, RealVector sigma) {
+      if (sigma == null || sigma.Length == 0) throw new ArgumentException("ERROR: Vector containing the standard deviations is not defined.", "sigma");
+      NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0);
+      for (int i = 0; i < vector.Length; i++) {
+        vector[i] = vector[i] + (N.NextDouble() * sigma[i % sigma.Length]);
+      }
+    }
+
+    /// <summary>
+    /// Checks that the strategy vector is not null and forwards the call to <see cref="Apply(IRandom, RealVector, RealVector)"/>.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="realVector">The vector of real values that is manipulated.</param>
+    protected override void Manipulate(IRandom random, RealVector realVector) {
+      Apply(random, realVector, SigmaParameter.Value);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/NormalAllPositionsManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/NormalAllPositionsManipulator.cs	(revision 5382)
+++ 	(revision )
@@ -1,104 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Random;
-
-namespace HeuristicLab.Encodings.RealVectorEncoding {
-  /// <summary>
-  /// Manipulates each dimension in the real vector with the mutation strength given 
-  /// in the strategy parameter vector.
-  /// </summary>
-  /// <remarks>
-  /// It is implemented as described in Beyer, H.-G. and Schwefel, H.-P. 2002. Evolution Strategies - A Comprehensive Introduction Natural Computing, 1, pp. 3-52.<br/>
-  /// The strategy vector can be of smaller length than the solution vector, in which case values are taken from the beginning again once the end of the strategy vector is reached.
-  /// </remarks>
-  [Item("NormalAllPositionsManipulator", "This manipulation operator adds a value sigma_i * N(0,1) to the current value in each position i. The values for sigma_i are taken from the strategy vector, if there are less elements in the strategy vector than positions, then the strategy vector is cycled. It is implemented as described in Beyer, H.-G. and Schwefel, H.-P. 2002. Evolution Strategies - A Comprehensive Introduction Natural Computing, 1, pp. 3-52.")]
-  [StorableClass]
-  public class NormalAllPositionsManipulator : RealVectorManipulator, ISelfAdaptiveManipulator {
-    public Type StrategyParameterType {
-      get { return typeof(IRealVectorStdDevStrategyParameterOperator); }
-    }
-    /// <summary>
-    /// Parameter for the strategy vector.
-    /// </summary>
-    public IValueLookupParameter<RealVector> StrategyParameterParameter {
-      get { return (IValueLookupParameter<RealVector>)Parameters["StrategyParameter"]; }
-    }
-
-    IParameter ISelfAdaptiveManipulator.StrategyParameterParameter {
-      get { return StrategyParameterParameter; }
-    }
-
-    [StorableConstructor]
-    protected NormalAllPositionsManipulator(bool deserializing) : base(deserializing) { }
-    protected NormalAllPositionsManipulator(NormalAllPositionsManipulator original, Cloner cloner) : base(original, cloner) { }
-    /// <summary>
-    /// Initializes a new instance of <see cref="NormalAllPositionsManipulator"/> with one
-    /// parameter (<c>StrategyVector</c>).
-    /// </summary>
-    public NormalAllPositionsManipulator()
-      : base() {
-      Parameters.Add(new ValueLookupParameter<RealVector>("StrategyParameter", "The vector containing the endogenous strategy parameters."));
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new NormalAllPositionsManipulator(this, cloner);
-    }
-
-    /// <summary>
-    /// Performs an adaptive normally distributed all position manipulation on the given 
-    /// <paramref name="vector"/>.
-    /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown when the strategy vector is not
-    /// as long as the vector to get manipulated.</exception>
-    /// <param name="strategyParameters">The strategy vector determining the strength of the mutation.</param>
-    /// <param name="random">A random number generator.</param>
-    /// <param name="vector">The real vector to manipulate.</param>
-    /// <returns>The manipulated real vector.</returns>
-    public static void Apply(IRandom random, RealVector vector, RealVector strategyParameters) {
-      NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0);
-      if (strategyParameters != null && strategyParameters.Length > 0) {
-        for (int i = 0; i < vector.Length; i++) {
-          vector[i] = vector[i] + (N.NextDouble() * strategyParameters[i % strategyParameters.Length]);
-        }
-      } else {
-        for (int i = 0; i < vector.Length; i++) {
-          vector[i] = vector[i] + N.NextDouble();
-        }
-      }
-    }
-
-    /// <summary>
-    /// Checks that the strategy vector is not null and forwards the call to <see cref="Apply(IRandom, RealVector, RealVector)"/>.
-    /// </summary>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="realVector">The vector of real values that is manipulated.</param>
-    protected override void Manipulate(IRandom random, RealVector realVector) {
-      Apply(random, realVector, StrategyParameterParameter.ActualValue);
-    }
-  }
-}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/SelfAdaptiveNormalAllPositionsManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/SelfAdaptiveNormalAllPositionsManipulator.cs	(revision 5385)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Manipulators/SelfAdaptiveNormalAllPositionsManipulator.cs	(revision 5385)
@@ -0,0 +1,110 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.RealVectorEncoding {
+  /// <summary>
+  /// Manipulates each dimension in the real vector with the mutation strength given 
+  /// in the strategy parameter vector.
+  /// </summary>
+  /// <remarks>
+  /// It is implemented as described in Beyer, H.-G. and Schwefel, H.-P. 2002. Evolution Strategies - A Comprehensive Introduction Natural Computing, 1, pp. 3-52.<br/>
+  /// The strategy vector can be of smaller length than the solution vector, in which case values are taken from the beginning again once the end of the strategy vector is reached.
+  /// </remarks>
+  [Item("SelfAdaptiveNormalAllPositionsManipulator", "This manipulation operator adds a value sigma_i * N(0,1) to the current value in each position i. The values for sigma_i are looked up dynamically. If there are less elements in the strategy vector than positions, then the strategy vector is cycled. It is implemented as described in Beyer, H.-G. and Schwefel, H.-P. 2002. Evolution Strategies - A Comprehensive Introduction Natural Computing, 1, pp. 3-52.")]
+  [StorableClass]
+  // BackwardsCompatibility3.3
+  // Rename class to match file- and itemname when upgrading to 3.4
+  public class NormalAllPositionsManipulator : RealVectorManipulator, ISelfAdaptiveManipulator {
+    public Type StrategyParameterType {
+      get { return typeof(IRealVectorStdDevStrategyParameterOperator); }
+    }
+    /// <summary>
+    /// Parameter for the strategy vector.
+    /// </summary>
+    public ILookupParameter<RealVector> StrategyParameterParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["StrategyParameter"]; }
+    }
+
+    IParameter ISelfAdaptiveManipulator.StrategyParameterParameter {
+      get { return StrategyParameterParameter; }
+    }
+
+    [StorableConstructor]
+    protected NormalAllPositionsManipulator(bool deserializing) : base(deserializing) { }
+    protected NormalAllPositionsManipulator(NormalAllPositionsManipulator original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="NormalAllPositionsManipulator"/> with one
+    /// parameter (<c>StrategyVector</c>).
+    /// </summary>
+    public NormalAllPositionsManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<RealVector>("StrategyParameter", "The vector containing the endogenous strategy parameters."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NormalAllPositionsManipulator(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs an adaptive normally distributed all position manipulation on the given 
+    /// <paramref name="vector"/>.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown when the strategy vector is not
+    /// as long as the vector to get manipulated.</exception>
+    /// <param name="strategyParameters">The strategy vector determining the strength of the mutation.</param>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="vector">The real vector to manipulate.</param>
+    /// <returns>The manipulated real vector.</returns>
+    public static void Apply(IRandom random, RealVector vector, RealVector strategyParameters) {
+      NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0);
+      if (strategyParameters != null) {
+        for (int i = 0; i < vector.Length; i++) {
+          vector[i] = vector[i] + (N.NextDouble() * strategyParameters[i % strategyParameters.Length]);
+        }
+      } else {
+        // BackwardsCompatibility3.3
+        #region Backwards compatible region (remove with 3.4)
+        // when upgrading to 3.4 remove the whole condition and just put the if-branch in place (you should then also throw an ArgumentException when strategyParameters is null or has length 0)
+        for (int i = 0; i < vector.Length; i++) {
+          vector[i] = vector[i] + N.NextDouble();
+        }
+        #endregion
+      }
+    }
+
+    /// <summary>
+    /// Checks that the strategy vector is not null and forwards the call to <see cref="Apply(IRandom, RealVector, RealVector)"/>.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="realVector">The vector of real values that is manipulated.</param>
+    protected override void Manipulate(IRandom random, RealVector realVector) {
+      Apply(random, realVector, StrategyParameterParameter.ActualValue);
+    }
+  }
+}
