Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/BoundsChecker.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/BoundsChecker.cs	(revision 5380)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/BoundsChecker.cs	(revision 5381)
@@ -33,5 +33,5 @@
   /// If not, the elements are corrected.
   /// </summary>
-  [Item("BoundsChecker", "Checks if all elements of a real vector are inside the bounds. If not, elements are corrected.")]
+  [Item("BoundsChecker", "Checks if all elements of a real vector are inside the bounds. If not, elements are set to the respective values of the bounds.")]
   [StorableClass]
   public class BoundsChecker : SingleSuccessorOperator, IRealVectorBoundsChecker {
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 5380)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj	(revision 5381)
@@ -12,5 +12,6 @@
     <AssemblyName>HeuristicLab.Encodings.RealVectorEncoding-3.3</AssemblyName>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
-    <TargetFrameworkProfile></TargetFrameworkProfile>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
     <FileAlignment>512</FileAlignment>
     <SignAssembly>true</SignAssembly>
@@ -157,4 +158,5 @@
     <Compile Include="Manipulators\PolynomialOnePositionManipulator.cs" />
     <Compile Include="Manipulators\UniformOnePositionManipulator.cs" />
+    <Compile Include="ReflectiveBoundsChecker.cs" />
     <Compile Include="StrategyParameters\StdDevStrategyVectorCreator.cs" />
     <Compile Include="StrategyParameters\StdDevStrategyVectorCrossover.cs" />
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/AdditiveMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/AdditiveMoveGenerator.cs	(revision 5380)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/AdditiveMoveGenerator.cs	(revision 5381)
@@ -65,15 +65,6 @@
     public override IOperation Apply() {
       RealVector vector = RealVectorParameter.ActualValue;
-      AdditiveMove[] moves = GenerateMoves(RandomParameter.ActualValue, vector);
       DoubleMatrix bounds = BoundsParameter.ActualValue;
-      if (bounds != null) {
-        for (int i = 0; i < moves.Length; i++) {
-          AdditiveMove move = moves[i];
-          if (vector[move.Dimension] + move.MoveDistance < bounds[move.Dimension % bounds.Rows, 0])
-            vector[move.Dimension] = bounds[move.Dimension % bounds.Rows, 0];
-          else if (vector[move.Dimension] + move.MoveDistance > bounds[move.Dimension % bounds.Rows, 1])
-            vector[move.Dimension] = bounds[move.Dimension % bounds.Rows, 1];
-        }
-      }
+      AdditiveMove[] moves = GenerateMoves(RandomParameter.ActualValue, vector, bounds);
       Scope[] moveScopes = new Scope[moves.Length];
       for (int i = 0; i < moveScopes.Length; i++) {
@@ -85,5 +76,5 @@
     }
 
-    protected abstract AdditiveMove[] GenerateMoves(IRandom random, RealVector realVector);
+    protected abstract AdditiveMove[] GenerateMoves(IRandom random, RealVector realVector, DoubleMatrix bounds);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/StochasticNormalMultiMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/StochasticNormalMultiMoveGenerator.cs	(revision 5380)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/StochasticNormalMultiMoveGenerator.cs	(revision 5381)
@@ -52,16 +52,20 @@
     }
 
-    public static AdditiveMove[] Apply(IRandom random, RealVector realVector, double sigma, int sampleSize) {
+    public static AdditiveMove[] Apply(IRandom random, RealVector vector, double sigma, int sampleSize, DoubleMatrix bounds) {
       AdditiveMove[] moves = new AdditiveMove[sampleSize];
       NormalDistributedRandom N = new NormalDistributedRandom(random, 0, sigma);
       for (int i = 0; i < sampleSize; i++) {
-        int index = random.Next(realVector.Length);
-        moves[i] = new AdditiveMove(index, N.NextDouble());
+        int index = random.Next(vector.Length);
+        double strength = 0, min = bounds[index % bounds.Rows, 0], max = bounds[index % bounds.Rows, 1];
+        do {
+          strength = N.NextDouble();
+        } while (vector[index] + strength < min || vector[index] + strength > max);
+        moves[i] = new AdditiveMove(index, strength);
       }
       return moves;
     }
 
-    protected override AdditiveMove[] GenerateMoves(IRandom random, RealVector realVector) {
-      return Apply(random, realVector, SigmaParameter.ActualValue.Value, SampleSizeParameter.ActualValue.Value);
+    protected override AdditiveMove[] GenerateMoves(IRandom random, RealVector realVector, DoubleMatrix bounds) {
+      return Apply(random, realVector, SigmaParameter.ActualValue.Value, SampleSizeParameter.ActualValue.Value, bounds);
     }
   }
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/StochasticPolynomialMultiMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/StochasticPolynomialMultiMoveGenerator.cs	(revision 5380)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/StochasticPolynomialMultiMoveGenerator.cs	(revision 5381)
@@ -62,15 +62,19 @@
     }
 
-    public static AdditiveMove[] Apply(IRandom random, RealVector realVector, double contiguity, int sampleSize, double maxManipulation) {
+    public static AdditiveMove[] Apply(IRandom random, RealVector vector, double contiguity, int sampleSize, double maxManipulation, DoubleMatrix bounds) {
       AdditiveMove[] moves = new AdditiveMove[sampleSize];
       for (int i = 0; i < sampleSize; i++) {
-        int index = random.Next(realVector.Length);
-        moves[i] = new AdditiveMove(index, PolynomialOnePositionManipulator.Apply(random, contiguity) * maxManipulation);
+        int index = random.Next(vector.Length);
+        double strength = 0, min = bounds[index % bounds.Rows, 0], max = bounds[index % bounds.Rows, 1];
+        do {
+          strength = PolynomialOnePositionManipulator.Apply(random, contiguity) * maxManipulation;
+        } while (vector[index] + strength < min || vector[index] + strength > max);
+        moves[i] = new AdditiveMove(index, strength);
       }
       return moves;
     }
 
-    protected override AdditiveMove[] GenerateMoves(IRandom random, RealVector realVector) {
-      return Apply(random, realVector, ContiguityParameter.ActualValue.Value, SampleSizeParameter.ActualValue.Value, MaximumManipulationParameter.ActualValue.Value);
+    protected override AdditiveMove[] GenerateMoves(IRandom random, RealVector realVector, DoubleMatrix bounds) {
+      return Apply(random, realVector, ContiguityParameter.ActualValue.Value, SampleSizeParameter.ActualValue.Value, MaximumManipulationParameter.ActualValue.Value, bounds);
     }
   }
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCrossover.cs	(revision 5380)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorCrossover.cs	(revision 5381)
@@ -51,4 +51,7 @@
       get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
     }
+    public OptionalValueParameter<IRealVectorBoundsChecker> BoundsCheckerParameter {
+      get { return (OptionalValueParameter<IRealVectorBoundsChecker>)Parameters["BoundsChecker"]; }
+    }
 
     [StorableConstructor]
@@ -63,12 +66,26 @@
       ChildParameter.ActualName = "RealVector";
       Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The lower and upper bounds of the real vector."));
+      Parameters.Add(new OptionalValueParameter<IRealVectorBoundsChecker>("BoundsChecker", "The bounds checker that ensures that the values stay within the bounds.", new BoundsChecker()));
     }
+
+    // BackwardsCompatibility3.3
+    #region Backwards compatible code (remove with 3.4)
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey("BoundsChecker"))
+        Parameters.Add(new OptionalValueParameter<IRealVectorBoundsChecker>("BoundsChecker", "The bounds checker that ensures that the values stay within the bounds.", new BoundsChecker()));
+    }
+    #endregion
 
     public sealed override IOperation Apply() {
       RealVector result = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
-      DoubleMatrix bounds = BoundsParameter.ActualValue;
-      if (bounds != null) BoundsChecker.Apply(result, bounds);
-      ChildParameter.ActualValue = result;
-      return base.Apply();
+
+      IRealVectorBoundsChecker checker = BoundsCheckerParameter.Value;
+      IOperation successor = base.Apply();
+      if (checker != null) {
+        IOperation checkerOperation = ExecutionContext.CreateChildOperation(checker);
+        if (successor == null) return checkerOperation;
+        else return new OperationCollection(checkerOperation, successor);
+      } else return successor;
     }
 
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorManipulator.cs	(revision 5380)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorManipulator.cs	(revision 5381)
@@ -48,4 +48,7 @@
       get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
     }
+    public OptionalValueParameter<IRealVectorBoundsChecker> BoundsCheckerParameter {
+      get { return (OptionalValueParameter<IRealVectorBoundsChecker>)Parameters["BoundsChecker"]; }
+    }
 
     [StorableConstructor]
@@ -57,12 +60,27 @@
       Parameters.Add(new LookupParameter<RealVector>("RealVector", "The vector which should be manipulated."));
       Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The lower and upper bounds of the real vector."));
+      Parameters.Add(new OptionalValueParameter<IRealVectorBoundsChecker>("BoundsChecker", "The bounds checker that ensures that the values stay within the bounds.", new BoundsChecker()));
     }
+
+    // BackwardsCompatibility3.3
+    #region Backwards compatible code (remove with 3.4)
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey("BoundsChecker"))
+        Parameters.Add(new OptionalValueParameter<IRealVectorBoundsChecker>("BoundsChecker", "The bounds checker that ensures that the values stay within the bounds.", new BoundsChecker()));
+    }
+    #endregion
 
     public sealed override IOperation Apply() {
       RealVector vector = RealVectorParameter.ActualValue;
       Manipulate(RandomParameter.ActualValue, vector);
-      DoubleMatrix bounds = BoundsParameter.ActualValue;
-      if (bounds != null) BoundsChecker.Apply(vector, bounds);
-      return base.Apply();
+
+      IRealVectorBoundsChecker checker = BoundsCheckerParameter.Value;
+      IOperation successor = base.Apply();
+      if (checker != null) {
+        IOperation checkerOperation = ExecutionContext.CreateChildOperation(checker);
+        if (successor == null) return checkerOperation;
+        else return new OperationCollection(checkerOperation, successor);
+      } else return successor;
     }
 
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ReflectiveBoundsChecker.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ReflectiveBoundsChecker.cs	(revision 5381)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/ReflectiveBoundsChecker.cs	(revision 5381)
@@ -0,0 +1,103 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.RealVectorEncoding {
+  /// <summary>
+  /// Checks if all elements of a real vector are inside the bounds. 
+  /// If not, the elements are corrected.
+  /// </summary>
+  [Item("ReflectiveBoundsChecker", "Checks if all elements of a real vector are inside the bounds. If not, elements are mirrored at the bounds.")]
+  [StorableClass]
+  public class ReflectiveBoundsChecker : SingleSuccessorOperator, IRealVectorBoundsChecker {
+    public LookupParameter<RealVector> RealVectorParameter {
+      get { return (LookupParameter<RealVector>)Parameters["RealVector"]; }
+    }
+    public ValueLookupParameter<DoubleMatrix> BoundsParameter {
+      get { return (ValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
+
+    [StorableConstructor]
+    protected ReflectiveBoundsChecker(bool deserializing) : base(deserializing) { }
+    protected ReflectiveBoundsChecker(ReflectiveBoundsChecker original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="BoundsChecker"/> with two parameters
+    /// (<c>RealVector</c>, <c>Bounds</c>).
+    /// </summary>
+    public ReflectiveBoundsChecker()
+      : base() {
+      Parameters.Add(new LookupParameter<RealVector>("RealVector", "The real-valued vector for which the bounds should be checked."));
+      Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The lower and upper bound (1st and 2nd column) of the positions in the vector. If there are less rows than dimensions, the rows are cycled."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ReflectiveBoundsChecker(this, cloner);
+    }
+
+    /// <summary>
+    /// Checks if all elements of the given <paramref name="vector"/> are inside the bounds and if not they are corrected.
+    /// </summary>
+    /// <param name="bounds">The lower and upper bound (1st and 2nd column) of the positions in the vector. If there are less rows than dimensions, the rows are cycled.</param>
+    /// <param name="vector">The vector to check.</param>
+    /// <returns>The corrected real vector.</returns>
+    public static void Apply(RealVector vector, DoubleMatrix bounds) {
+      for (int i = 0; i < vector.Length; i++) {
+        double min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1];
+        if (vector[i] < min) {
+          int reflectionCount = (int)Math.Truncate((min - vector[i]) / (max - min)) + 1;
+          double reflection = (min - vector[i]) % (max - min);
+          if (IsOdd(reflectionCount)) vector[i] = min + reflection;
+          else vector[i] = max - reflection;
+        }
+        if (vector[i] > max) {
+          int reflectionCount = (int)Math.Truncate((vector[i] - max) / (max - min)) + 1;
+          double reflection = (vector[i] - max) % (max - min);
+          if (IsOdd(reflectionCount)) vector[i] = max - reflection;
+          else vector[i] = min + reflection;
+        }
+      }
+    }
+
+    private static bool IsOdd(int number) {
+      return number % 2 == 1;
+    }
+
+    /// <summary>
+    /// Checks if all elements of the given <paramref name="vector"/> are inside the bounds and if not they are corrected.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown when either vector or bounds could not be found.</exception>
+    /// <remarks>Calls <see cref="Apply(RealVector, DoubleMatrix)"/>.</remarks>
+    /// <inheritdoc select="returns" />
+    public override IOperation Apply() {
+      if (RealVectorParameter.ActualValue == null) throw new InvalidOperationException("ReflectiveBoundsChecker: Parameter " + RealVectorParameter.ActualName + " could not be found.");
+      if (BoundsParameter.ActualValue == null) throw new InvalidOperationException("ReflectiveBoundsChecker: Parameter " + BoundsParameter.ActualName + " could not be found.");
+      Apply(RealVectorParameter.ActualValue, BoundsParameter.ActualValue);
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/StrategyParameters/StdDevStrategyVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/StrategyParameters/StdDevStrategyVectorManipulator.cs	(revision 5380)
+++ trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/StrategyParameters/StdDevStrategyVectorManipulator.cs	(revision 5381)
@@ -89,9 +89,13 @@
       double generalMultiplier = Math.Exp(generalLearningRate * N.NextDouble());
       for (int i = 0; i < vector.Length; i++) {
-        vector[i] *= generalMultiplier * Math.Exp(learningRate * N.NextDouble());
+        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 (vector[i] < min) vector[i] = min;
-          if (vector[i] > max) vector[i] = max;
+          if (min == max) vector[i] = min;
+          else {
+            while (change < min || change > max)
+              change = vector[i] * generalMultiplier * Math.Exp(learningRate * N.NextDouble());
+            vector[i] = change;
+          }
         }
       }
Index: trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/HeuristicLab.Problems.TestFunctions-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/HeuristicLab.Problems.TestFunctions-3.3.csproj	(revision 5380)
+++ trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/HeuristicLab.Problems.TestFunctions-3.3.csproj	(revision 5381)
@@ -12,5 +12,6 @@
     <AssemblyName>HeuristicLab.Problems.TestFunctions-3.3</AssemblyName>
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
-    <TargetFrameworkProfile></TargetFrameworkProfile>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
     <FileAlignment>512</FileAlignment>
     <SignAssembly>true</SignAssembly>
@@ -128,8 +129,6 @@
     <Compile Include="Evaluators\ZakharovEvaluator.cs" />
     <Compile Include="HeuristicLabProblemsTestFunctionsPlugin.cs" />
-    <Compile Include="Interfaces\IRealVectorPSODecoder.cs" />
     <Compile Include="Interfaces\IBestSingleObjectiveTestFunctionSolutionAnalyzer.cs" />
     <Compile Include="Interfaces\IRastriginMoveEvaluator.cs" />
-    <Compile Include="Interfaces\IRealVectorPSOEncoder.cs" />
     <Compile Include="Interfaces\ISingleObjectiveTestFunctionAdditiveMoveEvaluator.cs" />
     <Compile Include="Interfaces\ISingleObjectiveTestFunctionMoveEvaluator.cs" />
Index: trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IRealVectorPSODecoder.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IRealVectorPSODecoder.cs	(revision 5380)
+++ 	(revision )
@@ -1,29 +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 HeuristicLab.Core;
-using HeuristicLab.Optimization;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  public interface IRealVectorPSODecoder : IRealVectorDecoder {
-    IParameter OriginalRealVectorParameter { get; }
-  }
-}
Index: trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IRealVectorPSOEncoder.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IRealVectorPSOEncoder.cs	(revision 5380)
+++ 	(revision )
@@ -1,29 +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 HeuristicLab.Core;
-using HeuristicLab.Optimization;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  public interface IRealVectorPSOEncoder : IRealVectorEncoder {
-    IParameter OriginalRealVectorParameter { get; }
-  }
-}
Index: trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/RealVectorToRealVectorEncoder.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/RealVectorToRealVectorEncoder.cs	(revision 5380)
+++ trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/RealVectorToRealVectorEncoder.cs	(revision 5381)
@@ -20,40 +20,15 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Operators;
-using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Problems.TestFunctions {
-  public class RealVectorToRealVectorEncoder : SingleSuccessorOperator, IRealVectorPSOEncoder, IRealVectorOperator {
-    #region Parameters
-
-    public IParameter OriginalRealVectorParameter {
-      get { return (IParameter)Parameters["OriginalRealVector"]; }
-    }
-
-    public IParameter RealVectorParameter {
-      get { return (IParameter)Parameters["RealVector"]; }
-    }
-
-    public ILookupParameter<IntValue> LengthParameter {
-      get { return (ILookupParameter<IntValue>)Parameters["Length"]; }
-    }
-
-    public IValueLookupParameter<DoubleMatrix> BoundsParameter {
-      get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
-    }
-
-    protected ScopeParameter CurrentScopeParameter {
-      get { return (ScopeParameter)Parameters["CurrentScope"]; }
-    }
-    #endregion
-
-    public IScope CurrentScope {
-      get { return CurrentScopeParameter.ActualValue; }
-    }
+  // BackwardsCompatibility3.3
+  #region Backwards compatible code (remove with 3.4)
+  [Obsolete("This operator should not be used anymore.")]
+  internal class RealVectorToRealVectorEncoder : SingleSuccessorOperator {
 
     [StorableConstructor]
@@ -62,9 +37,4 @@
     public RealVectorToRealVectorEncoder()
       : base() {
-      Parameters.Add(new LookupParameter<RealVector>("OriginalRealVector", "The original real vector."));
-      Parameters.Add(new LookupParameter<RealVector>("RealVector", "The resulting reference to the original real vector."));
-      Parameters.Add(new LookupParameter<IntValue>("Length", "Vector length."));
-      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope bounds matrix should be cloned."));
-      Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The lower and upper bounds in each dimension."));
     }
 
@@ -74,7 +44,4 @@
 
     public override IOperation Apply() {
-      RealVectorParameter.ActualValue = OriginalRealVectorParameter.ActualValue;
-      IItem value = (IItem)BoundsParameter.ActualValue.Clone();
-      CurrentScope.Variables.Add(new Variable("ParticleBounds", BoundsParameter.Description, value == null ? null : (IItem)value.Clone()));
       return base.Apply();
     }
@@ -84,3 +51,4 @@
     }
   }
+  #endregion
 }
Index: trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs	(revision 5380)
+++ trunk/sources/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs	(revision 5381)
@@ -403,14 +403,11 @@
         op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
       }
-      foreach (IRealVectorPSOEncoder op in Operators.OfType<IRealVectorPSOEncoder>()) {
-        ((ILookupParameter)op.OriginalRealVectorParameter).ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        op.BoundsParameter.Value = (DoubleMatrix)BoundsParameter.Value.Clone();
-        op.BoundsParameter.ActualName = "ParticleBounds";
-      }
     }
     private void UpdateStrategyVectorBounds() {
       DoubleMatrix strategyBounds = (DoubleMatrix)Bounds.Clone();
-      for (int i = 0; i < strategyBounds.Rows; i++)
+      for (int i = 0; i < strategyBounds.Rows; i++) {
         if (strategyBounds[i, 0] < 0) strategyBounds[i, 0] = 0;
+        strategyBounds[i, 1] = 0.1 * (Bounds[i, 1] - Bounds[i, 0]);
+      }
       strategyVectorCreator.BoundsParameter.Value = strategyBounds;
     }
