Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Analyzers/BestSingleObjectiveTestFunctionSolutionAnalyzer.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Analyzers/BestSingleObjectiveTestFunctionSolutionAnalyzer.cs	(revision 13401)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Analyzers/BestSingleObjectiveTestFunctionSolutionAnalyzer.cs	(revision 13403)
@@ -44,15 +44,9 @@
       get { return (LookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
-    public ScopeTreeLookupParameter<RealVector> RealVectorParameter {
-      get { return (ScopeTreeLookupParameter<RealVector>)Parameters["RealVector"]; }
+    public IScopeTreeLookupParameter<RealVector> RealVectorsParameter {
+      get { return (IScopeTreeLookupParameter<RealVector>)Parameters["RealVectors"]; }
     }
-    ILookupParameter IBestSingleObjectiveTestFunctionSolutionAnalyzer.RealVectorParameter {
-      get { return RealVectorParameter; }
-    }
-    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
-    }
-    ILookupParameter IBestSingleObjectiveTestFunctionSolutionAnalyzer.QualityParameter {
-      get { return QualityParameter; }
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
     public ILookupParameter<SingleObjectiveTestFunctionSolution> BestSolutionParameter {
@@ -68,9 +62,9 @@
       get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
     }
-    public IValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator> EvaluatorParameter {
-      get { return (IValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator>)Parameters["Evaluator"]; }
+    public IValueLookupParameter<ISingleObjectiveTestFunction> TestFunctionParameter {
+      get { return (IValueLookupParameter<ISingleObjectiveTestFunction>)Parameters["TestFunction"]; }
     }
-    public ILookupParameter<DoubleMatrix> BoundsParameter {
-      get { return (ILookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    public IValueLookupParameter<DoubleMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
     }
 
@@ -81,5 +75,5 @@
       : base() {
       Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem."));
-      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("RealVector", "The SingleObjectiveTestFunction solutions from which the best solution should be visualized."));
+      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("RealVectors", "The SingleObjectiveTestFunction solutions from which the best solution should be visualized."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The qualities of the SingleObjectiveTestFunction solutions which should be visualized."));
       Parameters.Add(new LookupParameter<SingleObjectiveTestFunctionSolution>("BestSolution", "The best SingleObjectiveTestFunction solution."));
@@ -87,9 +81,9 @@
       Parameters.Add(new LookupParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution."));
       Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the SingleObjectiveTestFunction solution should be stored."));
-      Parameters.Add(new ValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator>("Evaluator", "The evaluator with which the solution is evaluated."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("Bounds", "The bounds of the function."));
+      Parameters.Add(new ValueLookupParameter<ISingleObjectiveTestFunction>("TestFunction", "The evaluator with which the solution is evaluated."));
+      Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The bounds of the function."));
 
       MaximizationParameter.Hidden = true;
-      RealVectorParameter.Hidden = true;
+      RealVectorsParameter.Hidden = true;
       QualityParameter.Hidden = true;
       BestSolutionParameter.Hidden = true;
@@ -97,17 +91,6 @@
       BestKnownQualityParameter.Hidden = true;
       ResultsParameter.Hidden = true;
-      EvaluatorParameter.Hidden = true;
+      TestFunctionParameter.Hidden = true;
       BoundsParameter.Hidden = true;
-    }
-
-    /// <summary>
-    /// This method can simply be removed when the plugin version is > 3.3
-    /// </summary>
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      // BackwardsCompatibility3.3
-      // Bounds are introduced in 3.3.0.3894
-      if (!Parameters.ContainsKey("Bounds"))
-        Parameters.Add(new LookupParameter<DoubleMatrix>("Bounds", "The bounds of the function."));
     }
 
@@ -117,5 +100,5 @@
 
     public override IOperation Apply() {
-      ItemArray<RealVector> realVectors = RealVectorParameter.ActualValue;
+      ItemArray<RealVector> realVectors = RealVectorsParameter.ActualValue;
       ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
       bool max = MaximizationParameter.ActualValue.Value;
@@ -140,5 +123,5 @@
         solution = new SingleObjectiveTestFunctionSolution((RealVector)realVectors[i].Clone(),
                                                            (DoubleValue)qualities[i].Clone(),
-                                                           EvaluatorParameter.ActualValue);
+                                                           TestFunctionParameter.ActualValue);
         solution.Population = realVectors[i].Length == 2
           ? new ItemArray<RealVector>(realVectors.Select(x => x.Clone()).Cast<RealVector>())
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Ackley.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Ackley.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Ackley.cs	(revision 13403)
@@ -0,0 +1,115 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// The Ackley function as described in Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg
+  /// is highly multimodal. It has a single global minimum at the origin with value 0.
+  /// </summary
+  [Item("Ackley", "Evaluates the Ackley function on a given point. The optimum of this function is 0 at the origin. It is implemented as described in Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg.")]
+  [StorableClass]
+  public class Ackley : SingleObjectiveTestFunction {
+    /// <summary>
+    /// Returns false as the Ackley function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -32.768, 32.768 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (1).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 1; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
+    }
+
+    [StorableConstructor]
+    protected Ackley(bool deserializing) : base(deserializing) { }
+    protected Ackley(Ackley original, Cloner cloner) : base(original, cloner) { }
+    public Ackley() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Ackley(this, cloner);
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      return new RealVector(dimension);
+    }
+
+    /// <summary>
+    /// Evaluates the Ackley function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Ackley function at the given point.</returns>
+    public static double Apply(RealVector point) {
+      double result;
+      double val;
+
+      val = 0;
+      for (int i = 0; i < point.Length; i++)
+        val += point[i] * point[i];
+      val /= point.Length;
+      val = -0.2 * Math.Sqrt(val);
+      result = 20 - 20 * Math.Exp(val);
+
+      val = 0;
+      for (int i = 0; i < point.Length; i++)
+        val += Math.Cos(2 * Math.PI * point[i]);
+      val /= point.Length;
+      result += Math.E - Math.Exp(val);
+      return (result);
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Ackley function at the given point.</returns>
+    public override double Evaluate(RealVector point) {
+      return Apply(point);
+    }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Beale.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Beale.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Beale.cs	(revision 13403)
@@ -0,0 +1,104 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// The Beale function is defined for 2 dimensions with an optimum of 0 at (3, 0.5).
+  /// It is implemented as described in Moré, J.J., Garbow, B., and Hillstrom, K. 1981. Testing unconstrained optimization software. ACM Transactions on Mathematical Software 7, pp. 136-140, ACM.
+  /// </summary>
+  [Item("Beale", "Evaluates the Beale function on a given point. The optimum of this function is 0 at (3,0.5). It is implemented as described in Moré, J.J., Garbow, B., and Hillstrom, K. 1981. Testing unconstrained optimization software. ACM Transactions on Mathematical Software 7, pp. 136-140, ACM.")]
+  [StorableClass]
+  public class Beale : SingleObjectiveTestFunction {
+    /// <summary>
+    /// Returns false as the Beale function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -4.5, 4.5 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (2).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 2; }
+    }
+    /// <summary>
+    /// Gets the maximum problem size (2).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return 2; }
+    }
+
+    [StorableConstructor]
+    protected Beale(bool deserializing) : base(deserializing) { }
+    protected Beale(Beale original, Cloner cloner) : base(original, cloner) { }
+    public Beale() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Beale(this, cloner);
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      if (dimension != 2) throw new ArgumentException(Name + ": This function is only defined for 2 dimensions.", "dimension");
+      return new RealVector(new double[] { 3, 0.5 });
+    }
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Beale function at the given point.</returns>
+    public static double Apply(RealVector point) {
+      double x1 = point[0], x2 = point[1];
+      double f1 = 1.5 - x1 * (1 - x2);
+      double f2 = 2.25 - x1 * (1 - x2 * x2);
+      double f3 = 2.625 - x1 * (1 - x2 * x2 * x2);
+      return (f1 * f1) + (f2 * f2) + (f3 * f3);
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Beale function at the given point.</returns>
+    public override double Evaluate(RealVector point) {
+      return Apply(point);
+    }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Booth.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Booth.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Booth.cs	(revision 13403)
@@ -0,0 +1,100 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// The Booth function is implemented as described on http://www-optima.amp.i.kyoto-u.ac.jp/member/student/hedar/Hedar_files/TestGO_files/Page816.htm, last accessed April 12th, 2010.
+  /// </summary>
+  [Item("Booth", "Evaluates the Booth function on a given point. The optimum of this function is 0 at (1,3). It is implemented as described on http://www-optima.amp.i.kyoto-u.ac.jp/member/student/hedar/Hedar_files/TestGO_files/Page816.htm, last accessed April 12th, 2010.")]
+  [StorableClass]
+  public class Booth : SingleObjectiveTestFunction {
+    /// <summary>
+    /// Returns false as the Booth function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -10, 10 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (2).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 2; }
+    }
+    /// <summary>
+    /// Gets the maximum problem size (2).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return 2; }
+    }
+
+    [StorableConstructor]
+    protected Booth(bool deserializing) : base(deserializing) { }
+    protected Booth(Booth original, Cloner cloner) : base(original, cloner) { }
+    public Booth() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Booth(this, cloner);
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      if (dimension != 2) throw new ArgumentException(Name + ": This function is only defined for 2 dimensions.", "dimension");
+      return new RealVector(new double[] { 1, 3 });
+    }
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Booth function at the given point.</returns>
+    public static double Apply(RealVector point) {
+      return (point[0] + 2 * point[1] - 7) * (point[0] + 2 * point[1] - 7)
+        + (2 * point[0] + point[1] - 5) * (2 * point[0] + point[1] - 5);
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Booth function at the given point.</returns>
+    public override double Evaluate(RealVector point) {
+      return Apply(point);
+    }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Griewank.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Griewank.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Griewank.cs	(revision 13403)
@@ -0,0 +1,149 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// The Griewank function is introduced in Griewank, A.O. 1981. Generalized descent for global optimization. Journal of Optimization Theory and Applications 34, pp. 11-39.
+  /// It is a multimodal fitness function in the range [-600,600]^n.
+  /// Here it is implemented as described (without the modifications) in Locatelli, M. 2003. A note on the Griewank test function. Journal of Global Optimization 25, pp. 169-174, Springer.
+  /// </summary>
+  [Item("Griewank", "Evaluates the Griewank function on a given point. The optimum of this function is 0 at the origin. It is introduced by Griewank A.O. 1981 and implemented as described (without the modifications) in Locatelli, M. 2003. A note on the Griewank test function. Journal of Global Optimization 25, pp. 169-174, Springer.")]
+  [StorableClass]
+  public class Griewank : SingleObjectiveTestFunction {
+    /// <summary>
+    /// Returns false as the Griewank function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -600, 600 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (1).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 1; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
+    }
+
+    [StorableConstructor]
+    protected Griewank(bool deserializing) : base(deserializing) { }
+    protected Griewank(Griewank original, Cloner cloner) : base(original, cloner) { }
+    public Griewank() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Griewank(this, cloner);
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      return new RealVector(dimension);
+    }
+    /// <summary>
+    /// If dimension of the problem is less or equal than 100 the values of Math.Sqrt(i + 1) are precomputed.
+    /// </summary>
+    private double[] sqrts;
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Griewank function at the given point.</returns>
+    public static double Apply(RealVector point) {
+      double result = 0;
+      double val = 0;
+
+      for (int i = 0; i < point.Length; i++)
+        result += point[i] * point[i];
+      result = result / 4000;
+
+      val = Math.Cos(point[0]);
+      for (int i = 1; i < point.Length; i++)
+        val *= Math.Cos(point[i] / Math.Sqrt(i + 1));
+
+      result = result - val + 1;
+      return result;
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>. It uses an array of precomputed values for Math.Sqrt(i + 1) with i = 0..N
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <param name="sqrts">The precomputed array of square roots.</param>
+    /// <returns>The result value of the Griewank function at the given point.</returns>
+    private static double Apply(RealVector point, double[] sqrts) {
+      double result = 0;
+      double val = 0;
+
+      for (int i = 0; i < point.Length; i++)
+        result += point[i] * point[i];
+      result = result / 4000;
+
+      val = Math.Cos(point[0]);
+      for (int i = 1; i < point.Length; i++)
+        val *= Math.Cos(point[i] / sqrts[i]);
+
+      result = result - val + 1;
+      return result;
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Griewank function at the given point.</returns>
+    public override double Evaluate(RealVector point) {
+      if (point.Length > 100)
+        return Apply(point);
+      else {
+        if (sqrts == null || sqrts.Length < point.Length) ComputeSqrts(point.Length);
+        return Apply(point, sqrts);
+      }
+    }
+
+    private void ComputeSqrts(int length) {
+      sqrts = new double[length];
+      for (int i = 0; i < length; i++) sqrts[i] = Math.Sqrt(i + 1);
+    }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Levy.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Levy.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Levy.cs	(revision 13403)
@@ -0,0 +1,117 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// The Levy function is implemented as described on http://www-optima.amp.i.kyoto-u.ac.jp/member/student/hedar/Hedar_files/TestGO_files/Page2056.htm, last accessed April 12th, 2010.
+  /// </summary>
+  [Item("Levy", "Evaluates the Levy function on a given point. The optimum of this function is 0 at (1,1,...,1). It is implemented as described on http://www-optima.amp.i.kyoto-u.ac.jp/member/student/hedar/Hedar_files/TestGO_files/Page2056.htm, last accessed April 12th, 2010.")]
+  [StorableClass]
+  public class Levy : SingleObjectiveTestFunction {
+    /// <summary>
+    /// Returns false as the Levy function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -10, 10 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (2).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 2; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
+    }
+
+    [StorableConstructor]
+    protected Levy(bool deserializing) : base(deserializing) { }
+    protected Levy(Levy original, Cloner cloner) : base(original, cloner) { }
+    public Levy() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Levy(this, cloner);
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      if (dimension < 2) throw new ArgumentException(Name + ": This function is not defined for 1 dimension.");
+      RealVector result = new RealVector(dimension);
+      for (int i = 0; i < dimension; i++) result[i] = 1;
+      return result;
+    }
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Levy function at the given point.</returns>
+    public static double Apply(RealVector point) {
+      int length = point.Length;
+      double[] z = new double[length];
+      double s;
+
+      for (int i = 0; i < length; i++) {
+        z[i] = 1 + (point[i] - 1) / 4;
+      }
+
+      s = Math.Sin(Math.PI * z[0]);
+      if (Math.Abs(s) < 1e-15) s = 0; // Math.Sin(Math.PI) == 0.00000000000000012246063538223773
+      s *= s;
+
+      for (int i = 0; i < length - 1; i++) {
+        s += (z[i] - 1) * (z[i] - 1) * (1 + 10 * Math.Pow(Math.Sin(Math.PI * z[i] + 1), 2));
+      }
+
+      return s + Math.Pow(z[length - 1] - 1, 2) * (1 + Math.Pow(Math.Sin(2 * Math.PI * z[length - 1]), 2));
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Levy function at the given point.</returns>
+    public override double Evaluate(RealVector point) {
+      return Apply(point);
+    }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Matyas.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Matyas.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Matyas.cs	(revision 13403)
@@ -0,0 +1,99 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// The Matyas function is implemented as described on http://www-optima.amp.i.kyoto-u.ac.jp/member/student/hedar/Hedar_files/TestGO_files/Page2213.htm, last accessed April 12th, 2010.
+  /// </summary>
+  [Item("Matyas", "Evaluates the Matyas function on a given point. The optimum of this function is 0 at the origin. It is implemented as described on http://www-optima.amp.i.kyoto-u.ac.jp/member/student/hedar/Hedar_files/TestGO_files/Page2213.htm, last accessed April 12th, 2010.")]
+  [StorableClass]
+  public class Matyas : SingleObjectiveTestFunction {
+    /// <summary>
+    /// Returns false as the Matyas function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -10, 10 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (2).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 2; }
+    }
+    /// <summary>
+    /// Gets the maximum problem size (2).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return 2; }
+    }
+
+    [StorableConstructor]
+    protected Matyas(bool deserializing) : base(deserializing) { }
+    protected Matyas(Matyas original, Cloner cloner) : base(original, cloner) { }
+    public Matyas() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Matyas(this, cloner);
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      if (dimension != 2) throw new ArgumentException(Name + ": This function is only defined for 2 dimensions.", "dimension");
+      return new RealVector(dimension);
+    }
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Matyas function at the given point.</returns>
+    public static double Apply(RealVector point) {
+      return 0.26 * (point[0] * point[0] + point[1] * point[1]) - 0.48 * point[0] * point[1];
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Matyas function at the given point.</returns>
+    public override double Evaluate(RealVector point) {
+      return Apply(point);
+    }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Multinormal.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Multinormal.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Multinormal.cs	(revision 13403)
@@ -0,0 +1,184 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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 System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.TestFunctions.Evaluators {
+  [Item("Multinormal", "Evaluates a random multinormal function on a given point.")]
+  [StorableClass]
+  public class Multinormal : SingleObjectiveTestFunction {
+
+    private ItemList<RealVector> centers {
+      get { return (ItemList<RealVector>)Parameters["Centers"].ActualValue; }
+      set { Parameters["Centers"].ActualValue = value; }
+    }
+    private RealVector s_2s {
+      get { return (RealVector)Parameters["s^2s"].ActualValue; }
+      set { Parameters["s^2s"].ActualValue = value; }
+    }
+
+    public IRandom Random {
+      get { return ((ValueParameter<IRandom>)Parameters["Random"]).Value; }
+      set { ((ValueParameter<IRandom>)Parameters["Random"]).Value = value; }
+    }
+
+    private Dictionary<int, List<RealVector>> stdCenters;
+    public IEnumerable<RealVector> Centers(int nDim) {
+      if (stdCenters == null)
+        stdCenters = new Dictionary<int, List<RealVector>>();
+      if (!stdCenters.ContainsKey(nDim))
+        stdCenters[nDim] = GetCenters(nDim).ToList();
+      return stdCenters[nDim];
+    }
+
+    private IEnumerable<RealVector> GetCenters(int nDim) {
+      RealVector r0 = new RealVector(nDim);
+      for (int i = 0; i < r0.Length; i++)
+        r0[i] = 5;
+      yield return r0;
+      for (int i = 1; i < 1 << nDim; i++) {
+        RealVector r = new RealVector(nDim);
+        for (int j = 0; j < nDim; j++) {
+          r[j] = (i >> j) % 2 == 0 ? Random.NextDouble() + 4.5 : Random.NextDouble() + 14.5;
+        }
+        yield return r;
+      }
+    }
+
+    private Dictionary<int, List<double>> stdSigma_2s;
+    public IEnumerable<double> Sigma_2s(int nDim) {
+      if (stdSigma_2s == null)
+        stdSigma_2s = new Dictionary<int, List<double>>();
+      if (!stdSigma_2s.ContainsKey(nDim))
+        stdSigma_2s[nDim] = GetSigma_2s(nDim).ToList();
+      return stdSigma_2s[nDim];
+    }
+    private IEnumerable<double> GetSigma_2s(int nDim) {
+      yield return 0.2;
+      for (int i = 1; i < (1 << nDim) - 1; i++) {
+        yield return Random.NextDouble() * 0.5 + 0.75;
+      }
+      yield return 2;
+    }
+
+    [StorableConstructor]
+    protected Multinormal(bool deserializing) : base(deserializing) { }
+    protected Multinormal(Multinormal original, Cloner cloner) : base(original, cloner) { }
+    public Multinormal() {
+      Parameters.Add(new ValueParameter<ItemList<RealVector>>("Centers", "Centers of normal distributions"));
+      Parameters.Add(new ValueParameter<RealVector>("s^2s", "sigma^2 of normal distributions"));
+      Parameters.Add(new ValueParameter<IRandom>("Random", "The random number generator that will make random instances", new MersenneTwister(0)));
+      centers = new ItemList<RealVector>();
+      s_2s = new RealVector();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Multinormal(this, cloner);
+    }
+
+    private double FastFindOptimum(out RealVector bestSolution) {
+      var optima = centers.Select((c, i) => new { f = Evaluate(c), i }).OrderBy(v => v.f).ToList();
+      if (optima.Count == 0) {
+        bestSolution = new RealVector();
+        return 0;
+      } else {
+        var best = optima.First();
+        bestSolution = centers[best.i];
+        return best.f;
+      }
+    }
+
+    public static double N(RealVector x, RealVector x0, double s_2) {
+      Debug.Assert(x.Length == x0.Length);
+      double d = 0;
+      for (int i = 0; i < x.Length; i++) {
+        d += (x[i] - x0[i]) * (x[i] - x0[i]);
+      }
+      return Math.Exp(-d / (2 * s_2)) / (2 * Math.PI * s_2);
+    }
+
+    public override bool Maximization {
+      get { return false; }
+    }
+
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { 0, 20 } }); }
+    }
+
+    public override double BestKnownQuality {
+      get {
+        if (centers.Count == 0) {
+          return -1 / (2 * Math.PI * 0.2);
+        } else {
+          RealVector bestSolution;
+          return FastFindOptimum(out bestSolution);
+        }
+      }
+    }
+
+    public override int MinimumProblemSize { get { return 1; } }
+
+    public override int MaximumProblemSize { get { return 100; } }
+
+    private RealVector Shorten(RealVector x, int dimensions) {
+      return new RealVector(x.Take(dimensions).ToArray());
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      if (centers.Count == 0) {
+        RealVector r = new RealVector(dimension);
+        for (int i = 0; i < r.Length; i++)
+          r[i] = 5;
+        return r;
+      } else {
+        RealVector bestSolution;
+        FastFindOptimum(out bestSolution);
+        return Shorten(bestSolution, dimension);
+      }
+    }
+
+    public override double Evaluate(RealVector point) {
+      double value = 0;
+      if (centers.Count == 0) {
+        var c = Centers(point.Length).GetEnumerator();
+        var s = Sigma_2s(point.Length).GetEnumerator();
+        while (c.MoveNext() && s.MoveNext()) {
+          value -= N(point, c.Current, s.Current);
+        }
+      } else {
+        for (int i = 0; i < centers.Count; i++) {
+          value -= N(point, centers[i], s_2s[i]);
+        }
+      }
+      return value;
+    }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Random.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Random.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Random.cs	(revision 13403)
@@ -0,0 +1,92 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// A function that returns a random variable in [0;1) independent of the inputs.
+  /// </summary
+  [Item("Random", "Returns a random value in [0;1) that is independent of the inputs.")]
+  [StorableClass]
+  public class Random : SingleObjectiveTestFunction {
+    /// <summary>
+    /// It does not really matter.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// The minimum value that can be "found" is 0.
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -100, 100 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (1).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 1; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
+    }
+
+    public IValueParameter<IRandom> RandomParameter {
+      get { return (IValueParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    [StorableConstructor]
+    protected Random(bool deserializing) : base(deserializing) { }
+    protected Random(Random original, Cloner cloner) : base(original, cloner) { }
+    public Random()
+      : base() {
+      Parameters.Add(new ValueParameter<IRandom>("Random", "The random number generator to use.", new MersenneTwister(0)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Random(this, cloner);
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      return null;
+    }
+
+    public override double Evaluate(RealVector point) {
+      return RandomParameter.Value.NextDouble();
+    }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Rastrigin.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Rastrigin.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Rastrigin.cs	(revision 13403)
@@ -0,0 +1,125 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// The generalized Rastrigin function y = Sum((x_i)^2 + A * (1 - Cos(2pi*x_i))) is a highly multimodal function that has its optimal value 0 at the origin.
+  /// It is implemented as described in Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg.
+  /// </summary
+  [Item("Rastrigin", "Evaluates the generalized Rastrigin function y = Sum((x_i)^2 + A * (1 - Cos(2pi*x_i))) on a given point. The optimum of this function is 0 at the origin. It is implemented as described in Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg.")]
+  [StorableClass]
+  public class Rastrigin : SingleObjectiveTestFunction {
+    /// <summary>
+    /// Returns false as the Rastrigin function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -5.12, 5.12 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (1).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 1; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
+    }
+    /// <summary>
+    /// The parameter A is a parameter of the objective function y = Sum((x_i)^2 + A * (1 - Cos(2pi*x_i))). Default is A = 10.
+    /// </summary>
+    public ValueParameter<DoubleValue> AParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["A"]; }
+    }
+    /// <summary>
+    /// The parameter A is a parameter of the objective function y = Sum((x_i)^2 + A * (1 - Cos(2pi*x_i))). Default is A = 10.
+    /// </summary>
+    public DoubleValue A {
+      get { return AParameter.Value; }
+      set { if (value != null) AParameter.Value = value; }
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      return new RealVector(dimension);
+    }
+
+    [StorableConstructor]
+    protected Rastrigin(bool deserializing) : base(deserializing) { }
+    protected Rastrigin(Rastrigin original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of the RastriginEvaluator with one parameter (<c>A</c>).
+    /// </summary>
+    public Rastrigin()
+      : base() {
+      Parameters.Add(new ValueParameter<DoubleValue>("A", "The parameter A is a parameter of the objective function y = Sum((x_i)^2 + A * (1 - Cos(2pi*x_i))). Default is A = 10.", new DoubleValue(10)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Rastrigin(this, cloner);
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Rastrigin function at the given point.</returns>
+    public static double Apply(RealVector point, double a) {
+      double result = a * point.Length;
+      for (int i = 0; i < point.Length; i++) {
+        result += point[i] * point[i];
+        result -= a * Math.Cos(2 * Math.PI * point[i]);
+      }
+      return (result);
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Rastrigin function at the given point.</returns>
+    public override double Evaluate(RealVector point) {
+      return Apply(point, A.Value);
+    }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Rosenbrock.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Rosenbrock.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Rosenbrock.cs	(revision 13403)
@@ -0,0 +1,111 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// The Rosenbrock function features a flat valley in which the global optimum is located.
+  /// It is implemented as generalized Rosenbrock function as for example given in Shang, Y.-W. and Qiu, Y.-H. 2006. A Note on the Extended Rosenbrock Function. Evolutionary Computation 14, pp. 119-126, MIT Press.
+  /// </summary>
+  [Item("Rosenbrock", @"The Rosenbrock function features a flat valley in which the global optimum is located.
+For 2 and 3 dimensions the single minimum of this function is 0 at (1,1,...,1), for 4 to 30 dimensions there is an additional local minimum close to (-1,1,...,1).
+It is unknown how many local minima there are for dimensions greater than 30.
+It is implemented as generalized Rosenbrock function for which the 2 dimensional function is a special case, as for example given in Shang, Y.-W. and Qiu, Y.-H. 2006. A Note on the Extended Rosenbrock Function. Evolutionary Computation 14, pp. 119-126, MIT Press.")]
+  [StorableClass]
+  public class Rosenbrock : SingleObjectiveTestFunction {
+    /// <summary>
+    /// Returns false as the Rosenbrock function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -2.048, 2.048 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (2).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 2; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
+    }
+
+    [StorableConstructor]
+    protected Rosenbrock(bool deserializing) : base(deserializing) { }
+    protected Rosenbrock(Rosenbrock original, Cloner cloner) : base(original, cloner) { }
+    public Rosenbrock() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Rosenbrock(this, cloner);
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      if (dimension < 2) throw new ArgumentException(Name + ": This function is not defined for 1 dimension.");
+      RealVector result = new RealVector(dimension);
+      for (int i = 0; i < dimension; i++) result[i] = 1;
+      return result;
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Rosenbrock function at the given point.</returns>
+    public static double Apply(RealVector point) {
+      double result = 0;
+      for (int i = 0; i < point.Length - 1; i++) {
+        result += 100 * (point[i] * point[i] - point[i + 1]) * (point[i] * point[i] - point[i + 1]);
+        result += (point[i] - 1) * (point[i] - 1);
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Rosenbrock function at the given point.</returns>
+    public override double Evaluate(RealVector point) {
+      return Apply(point);
+    }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Schwefel.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Schwefel.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Schwefel.cs	(revision 13403)
@@ -0,0 +1,102 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// The Schwefel function (sine root) is implemented as described in Affenzeller, M. and Wagner, S. 2005. Offspring Selection: A New Self-Adaptive Selection Scheme for Genetic Algorithms.  Ribeiro, B., Albrecht, R. F., Dobnikar, A., Pearson, D. W., and Steele, N. C. (eds.). Adaptive and Natural Computing Algorithms, pp. 218-221, Springer.
+  /// </summary>
+  [Item("Schwefel", "Evaluates the Schwefel function (sine root) on a given point. In the given bounds [-500;500] the optimum of this function is close to 0 at (420.968746453712,420.968746453712,...,420.968746453712). It is implemented as described in Affenzeller, M. and Wagner, S. 2005. Offspring Selection: A New Self-Adaptive Selection Scheme for Genetic Algorithms.  Ribeiro, B., Albrecht, R. F., Dobnikar, A., Pearson, D. W., and Steele, N. C. (eds.). Adaptive and Natural Computing Algorithms, pp. 218-221, Springer.")]
+  [StorableClass]
+  public class Schwefel : SingleObjectiveTestFunction {
+    /// <summary>
+    /// Returns false as the Schwefel (sine root) function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -500, 500 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (1).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 1; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
+    }
+
+    [StorableConstructor]
+    protected Schwefel(bool deserializing) : base(deserializing) { }
+    protected Schwefel(Schwefel original, Cloner cloner) : base(original, cloner) { }
+    public Schwefel() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Schwefel(this, cloner);
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      return null;
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Schwefel function at the given point.</returns>
+    public static double Apply(RealVector point) {
+      double result = 418.982887272433 * point.Length;
+      for (int i = 0; i < point.Length; i++)
+        result -= point[i] * Math.Sin(Math.Sqrt(Math.Abs(point[i])));
+      return (result);
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Schwefel function at the given point.</returns>
+    public override double Evaluate(RealVector point) {
+      return Apply(point);
+    }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/SingleObjectiveTestFunction.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/SingleObjectiveTestFunction.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/SingleObjectiveTestFunction.cs	(revision 13403)
@@ -0,0 +1,83 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// Base class for a test function evaluator.
+  /// </summary>
+  [Item("Single-Objective Function", "Base class for single objective functions.")]
+  [StorableClass]
+  public abstract class SingleObjectiveTestFunction : ParameterizedNamedItem, ISingleObjectiveTestFunction {
+    /// <summary>
+    /// These operators should not change their name through the GUI
+    /// </summary>
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    /// <summary>
+    /// Returns whether the actual function constitutes a maximization or minimization problem.
+    /// </summary>
+    public abstract bool Maximization { get; }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public abstract DoubleMatrix Bounds { get; }
+    /// <summary>
+    /// Gets the optimum function value.
+    /// </summary>
+    public abstract double BestKnownQuality { get; }
+    /// <summary>
+    /// Gets the minimum problem size.
+    /// </summary>
+    public abstract int MinimumProblemSize { get; }
+    /// <summary>
+    /// Gets the maximum problem size.
+    /// </summary>
+    public abstract int MaximumProblemSize { get; }
+
+    [StorableConstructor]
+    protected SingleObjectiveTestFunction(bool deserializing) : base(deserializing) { }
+    protected SingleObjectiveTestFunction(SingleObjectiveTestFunction original, Cloner cloner) : base(original, cloner) { }
+    protected SingleObjectiveTestFunction() : base() { }
+
+    public virtual double Evaluate2D(double x, double y) {
+      return Evaluate(new RealVector(new double[] { x, y }));
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the function at the given point.</returns>
+    public abstract double Evaluate(RealVector point);
+
+    /// <summary>
+    /// Gets the best known solution for this function.
+    /// </summary>
+    public abstract RealVector GetBestKnownSolution(int dimension);
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Sphere.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Sphere.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Sphere.cs	(revision 13403)
@@ -0,0 +1,138 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// The sphere function is a unimodal function that has its optimum at the origin.
+  /// 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.
+  /// </summary>
+  [Item("Sphere", "Evaluates the Sphere function y = C * ||X||^Alpha on a given point. The optimum of this function is 0 at the origin. 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 Sphere : SingleObjectiveTestFunction {
+    /// <summary>
+    /// Returns false as the Sphere function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -5.12, 5.12 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (1).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 1; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Sphere(this, cloner);
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      return new RealVector(dimension);
+    }
+
+    /// <summary>
+    /// The parameter C modifies the steepness of the objective function y = C * ||X||^Alpha. Default is C = 1.
+    /// </summary>
+    public ValueParameter<DoubleValue> CParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["C"]; }
+    }
+    /// <summary>
+    /// The parameter Alpha modifies the steepness of the objective function y = C * ||X||^Alpha. Default is Alpha = 2.
+    /// </summary>
+    public ValueParameter<DoubleValue> AlphaParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["Alpha"]; }
+    }
+    /// <summary>
+    /// The parameter C modifies the steepness of the objective function y = C * ||X||^Alpha. Default is C = 1.
+    /// </summary>
+    public DoubleValue C {
+      get { return CParameter.Value; }
+      set { if (value != null) CParameter.Value = value; }
+    }
+    /// <summary>
+    /// The parameter Alpha modifies the steepness of the objective function y = C * ||X||^Alpha. Default is Alpha = 2.
+    /// </summary>
+    public DoubleValue Alpha {
+      get { return AlphaParameter.Value; }
+      set { if (value != null) AlphaParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected Sphere(bool deserializing) : base(deserializing) { }
+    protected Sphere(Sphere original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of the SphereEvaluator with two parameters (<c>C</c> and <c>Alpha</c>).
+    /// </summary>
+    public Sphere()
+      : base() {
+      Parameters.Add(new ValueParameter<DoubleValue>("C", "The parameter C modifies the steepness of the objective function y = C * ||X||^Alpha. Default is C = 1.", new DoubleValue(1)));
+      Parameters.Add(new ValueParameter<DoubleValue>("Alpha", "The parameter Alpha modifies the steepness of the objective function y = C * ||X||^Alpha. Default is Alpha = 2.", new DoubleValue(2)));
+    }
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Sphere function at the given point.</returns>
+    public static double Apply(RealVector point, double c, double alpha) {
+      double result = 0;
+      for (int i = 0; i < point.Length; i++)
+        result += point[i] * point[i];
+      if (alpha != 2) result = Math.Pow(Math.Sqrt(result), alpha);
+      return c * result;
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Sphere function at the given point.</returns>
+    public override double Evaluate(RealVector point) {
+      return Apply(point, C.Value, Alpha.Value);
+    }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/SumSquares.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/SumSquares.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/SumSquares.cs	(revision 13403)
@@ -0,0 +1,102 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// The Sum Squares function is defined as sum(i * x_i * x_i) for i = 1..n
+  /// </summary>
+  [Item("SumSquares", "Evaluates the sum squares function on a given point. The optimum of this function is 0 at the origin. The Sum Squares function is defined as sum(i * x_i * x_i) for i = 1..n.")]
+  [StorableClass]
+  public class SumSquares : SingleObjectiveTestFunction {
+    /// <summary>
+    /// Returns false as the Sum Squares function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -10, 10 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (1).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 1; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
+    }
+
+    [StorableConstructor]
+    protected SumSquares(bool deserializing) : base(deserializing) { }
+    protected SumSquares(SumSquares original, Cloner cloner) : base(original, cloner) { }
+    public SumSquares() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SumSquares(this, cloner);
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      return new RealVector(dimension);
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Sum Squares function at the given point.</returns>
+    public static double Apply(RealVector point) {
+      double result = 0;
+      for (int i = 0; i < point.Length; i++) {
+        result += (i + 1) * point[i] * point[i];
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Sum Squares function at the given point.</returns>
+    public override double Evaluate(RealVector point) {
+      return Apply(point);
+    }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Zakharov.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Zakharov.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Zakharov.cs	(revision 13403)
@@ -0,0 +1,106 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// The Zakharov function is implemented as described in Hedar, A. & Fukushima, M. 2004. Heuristic pattern search and its hybridization with simulated annealing for nonlinear global optimization. Optimization Methods and Software 19, pp. 291-308, Taylor & Francis.
+  /// </summary>
+  [Item("Zakharov", "Evaluates the Zakharov function on a given point. The optimum of this function is 0 at the origin. It is implemented as described in Hedar, A. & Fukushima, M. 2004. Heuristic pattern search and its hybridization with simulated annealing for nonlinear global optimization. Optimization Methods and Software 19, pp. 291-308, Taylor & Francis.")]
+  [StorableClass]
+  public class Zakharov : SingleObjectiveTestFunction {
+    /// <summary>
+    /// Returns false as the Zakharov function is a minimization problem.
+    /// </summary>
+    public override bool Maximization {
+      get { return false; }
+    }
+    /// <summary>
+    /// Gets the optimum function value (0).
+    /// </summary>
+    public override double BestKnownQuality {
+      get { return 0; }
+    }
+    /// <summary>
+    /// Gets the lower and upper bound of the function.
+    /// </summary>
+    public override DoubleMatrix Bounds {
+      get { return new DoubleMatrix(new double[,] { { -5, 10 } }); }
+    }
+    /// <summary>
+    /// Gets the minimum problem size (1).
+    /// </summary>
+    public override int MinimumProblemSize {
+      get { return 1; }
+    }
+    /// <summary>
+    /// Gets the (theoretical) maximum problem size (2^31 - 1).
+    /// </summary>
+    public override int MaximumProblemSize {
+      get { return int.MaxValue; }
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      return new RealVector(dimension);
+    }
+
+    [StorableConstructor]
+    protected Zakharov(bool deserializing) : base(deserializing) { }
+    protected Zakharov(Zakharov original, Cloner cloner) : base(original, cloner) { }
+    public Zakharov() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Zakharov(this, cloner);
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Zakharov function at the given point.</returns>
+    public static double Apply(RealVector point) {
+      int length = point.Length;
+      double s1 = 0;
+      double s2 = 0;
+
+      for (int i = 0; i < length; i++) {
+        s1 += point[i] * point[i];
+        s2 += 0.5 * i * point[i];
+      }
+      return s1 + (s2 * s2) + (s2 * s2 * s2 * s2);
+    }
+
+    /// <summary>
+    /// Evaluates the test function for a specific <paramref name="point"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="point">N-dimensional point for which the test function should be evaluated.</param>
+    /// <returns>The result value of the Zakharov function at the given point.</returns>
+    public override double Evaluate(RealVector point) {
+      return Apply(point);
+    }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/HeuristicLab.Problems.TestFunctions-3.3.csproj
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/HeuristicLab.Problems.TestFunctions-3.3.csproj	(revision 13401)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/HeuristicLab.Problems.TestFunctions-3.3.csproj	(revision 13403)
@@ -114,10 +114,11 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Evaluators\RandomEvaluator.cs" />
+    <Compile Include="Functions\Random.cs" />
     <Compile Include="Improvers\SingleObjectiveTestFunctionImprovementOperator.cs" />
     <Compile Include="Instances\SOTFData.cs" />
     <Compile Include="Instances\SOTFDataDescriptor.cs" />
     <Compile Include="Instances\SOTFInstanceProvider.cs" />
-    <Compile Include="MoveEvaluators\RandomAdditiveMoveEvaluator.cs" />
+    <Compile Include="Interfaces\ITestFunctionSolutionSimilarityCalculator.cs" />
+    <Compile Include="Interfaces\ISingleObjectiveTestFuntionImprovementOperator.cs" />
     <Compile Include="PathRelinkers\SingleObjectiveTestFunctionPathRelinker.cs" />
     <Compile Include="Plugin.cs" />
@@ -128,41 +129,24 @@
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="Evaluators\AckleyEvaluator.cs" />
-    <Compile Include="Evaluators\BealeEvaluator.cs" />
-    <Compile Include="Evaluators\BoothEvaluator.cs" />
-    <Compile Include="Evaluators\GriewankEvaluator.cs" />
-    <Compile Include="Evaluators\LevyEvaluator.cs" />
-    <Compile Include="Evaluators\MatyasEvaluator.cs" />
-    <Compile Include="Evaluators\MultinormalEvaluator.cs" />
-    <Compile Include="Evaluators\RastriginEvaluator.cs" />
-    <Compile Include="Evaluators\RosenbrockEvaluator.cs" />
-    <Compile Include="Evaluators\SchwefelEvaluator.cs" />
-    <Compile Include="Evaluators\SingleObjectiveTestFunctionProblemEvaluator.cs" />
-    <Compile Include="Evaluators\SphereEvaluator.cs" />
-    <Compile Include="Evaluators\SumSquaresEvaluator.cs" />
-    <Compile Include="Evaluators\ZakharovEvaluator.cs" />
+    <Compile Include="Functions\Ackley.cs" />
+    <Compile Include="Functions\Beale.cs" />
+    <Compile Include="Functions\Booth.cs" />
+    <Compile Include="Functions\Griewank.cs" />
+    <Compile Include="Functions\Levy.cs" />
+    <Compile Include="Functions\Matyas.cs" />
+    <Compile Include="Functions\Multinormal.cs" />
+    <Compile Include="Functions\Rastrigin.cs" />
+    <Compile Include="Functions\Rosenbrock.cs" />
+    <Compile Include="Functions\Schwefel.cs" />
+    <Compile Include="Functions\SingleObjectiveTestFunction.cs" />
+    <Compile Include="Functions\Sphere.cs" />
+    <Compile Include="Functions\SumSquares.cs" />
+    <Compile Include="Functions\Zakharov.cs" />
     <Compile Include="Interfaces\IBestSingleObjectiveTestFunctionSolutionAnalyzer.cs" />
-    <Compile Include="Interfaces\IRastriginMoveEvaluator.cs" />
     <Compile Include="Interfaces\ISingleObjectiveTestFunctionAdditiveMoveEvaluator.cs" />
     <Compile Include="Interfaces\ISingleObjectiveTestFunctionMoveEvaluator.cs" />
-    <Compile Include="Interfaces\ISingleObjectiveTestFunctionProblemEvaluator.cs" />
+    <Compile Include="Interfaces\ISingleObjectiveTestFunction.cs" />
     <Compile Include="Interfaces\ISingleObjectiveTestFunctionProblemSolutionsVisualizer.cs" />
-    <Compile Include="Interfaces\ISphereMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\AckleyAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\BealeAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\BoothAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\MultinormalAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\GriewankAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\ZakharovAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\SumSquaresAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\SphereAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\SchwefelAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\MatyasAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\RosenbrockAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\RastriginAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\LevyAdditiveMoveEvaluator.cs" />
     <Compile Include="MoveEvaluators\AdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\RealVectorAdditiveMoveWrapper.cs" />
-    <Compile Include="RealVectorToRealVectorEncoder.cs" />
     <Compile Include="SimilarityCalculators\SingleObjectiveTestFunctionSimilarityCalculator.cs" />
     <Compile Include="SingleObjectiveTestFunctionSolution.cs" />
@@ -239,4 +223,9 @@
       <Project>{3540e29e-4793-49e7-8ee2-fea7f61c3994}</Project>
       <Name>HeuristicLab.Problems.Instances-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Random\3.3\HeuristicLab.Random-3.3.csproj">
+      <Project>{f4539fb6-4708-40c9-be64-0a1390aea197}</Project>
+      <Name>HeuristicLab.Random-3.3</Name>
       <Private>False</Private>
     </ProjectReference>
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Improvers/SingleObjectiveTestFunctionImprovementOperator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Improvers/SingleObjectiveTestFunctionImprovementOperator.cs	(revision 13401)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Improvers/SingleObjectiveTestFunctionImprovementOperator.cs	(revision 13403)
@@ -26,5 +26,4 @@
 using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -40,5 +39,5 @@
   [Item("SingleObjectiveTestFunctionImprovementOperator", "An operator that improves test functions solutions. It is implemented as described in Laguna, M. and Martí, R. (2003). Scatter Search: Methodology and Implementations in C. Operations Research/Computer Science Interfaces Series, Vol. 24. Springer.")]
   [StorableClass]
-  public sealed class SingleObjectiveTestFunctionImprovementOperator : SingleSuccessorOperator, ISingleObjectiveImprovementOperator {
+  public sealed class SingleObjectiveTestFunctionImprovementOperator : SingleSuccessorOperator, ISingleObjectiveTestFunctionImprovementOperator {
     #region Parameter properties
     public IValueParameter<DoubleValue> AlphaParameter {
@@ -51,12 +50,9 @@
       get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
     }
-    public ScopeParameter CurrentScopeParameter {
-      get { return (ScopeParameter)Parameters["CurrentScope"]; }
-    }
     public IValueParameter<DoubleValue> DeltaParameter {
       get { return (IValueParameter<DoubleValue>)Parameters["Delta"]; }
     }
-    public IValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator> EvaluatorParameter {
-      get { return (IValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator>)Parameters["Evaluator"]; }
+    public IValueLookupParameter<ISingleObjectiveTestFunction> TestFunctionParameter {
+      get { return (IValueLookupParameter<ISingleObjectiveTestFunction>)Parameters["TestFunction"]; }
     }
     public IValueParameter<DoubleValue> GammaParameter {
@@ -78,21 +74,9 @@
       get { return BetaParameter.Value; }
     }
-    private DoubleMatrix Bounds {
-      get { return BoundsParameter.ActualValue; }
-    }
-    public IScope CurrentScope {
-      get { return CurrentScopeParameter.ActualValue; }
-    }
     private DoubleValue Delta {
       get { return DeltaParameter.Value; }
     }
-    public ISingleObjectiveTestFunctionProblemEvaluator Evaluator {
-      get { return EvaluatorParameter.ActualValue; }
-    }
     private DoubleValue Gamma {
       get { return GammaParameter.Value; }
-    }
-    public IntValue ImprovementAttempts {
-      get { return ImprovementAttemptsParameter.ActualValue; }
     }
     #endregion
@@ -106,11 +90,10 @@
       Parameters.Add(new ValueParameter<DoubleValue>("Alpha", new DoubleValue(1.0)));
       Parameters.Add(new ValueParameter<DoubleValue>("Beta", new DoubleValue(2.0)));
+      Parameters.Add(new ValueParameter<DoubleValue>("Delta", new DoubleValue(0.5)));
+      Parameters.Add(new ValueParameter<DoubleValue>("Gamma", new DoubleValue(0.5)));
+      Parameters.Add(new ValueLookupParameter<ISingleObjectiveTestFunction>("TestFunction", "The operator used to evaluate solutions."));
       Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The lower and upper bounds in each dimension."));
-      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope that contains the solution to be improved."));
-      Parameters.Add(new ValueParameter<DoubleValue>("Delta", new DoubleValue(0.5)));
-      Parameters.Add(new ValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator>("Evaluator", "The operator used to evaluate solutions."));
-      Parameters.Add(new ValueParameter<DoubleValue>("Gamma", new DoubleValue(0.5)));
       Parameters.Add(new ValueLookupParameter<IntValue>("ImprovementAttempts", "The number of improvement attempts the operator should perform.", new IntValue(100)));
-      Parameters.Add(new ValueLookupParameter<IItem>("Solution", "The solution to be improved. This parameter is used for name translation only."));
+      Parameters.Add(new ValueLookupParameter<IItem>("Solution", "The solution to be improved. This parameter is used for name translation only.")); // TODO: Problematic, this cannot be wired! IImprovementOperators need to be generic
       #endregion
     }
@@ -121,11 +104,13 @@
 
     public override IOperation Apply() {
-      RealVector bestSol = CurrentScope.Variables[SolutionParameter.ActualName].Value as RealVector;
+      RealVector bestSol = ExecutionContext.Scope.Variables[SolutionParameter.ActualName].Value as RealVector;
       if (bestSol == null)
         throw new ArgumentException("Cannot improve solution because it has the wrong type.");
 
-      var evaluator = Evaluator;
+      var bounds = BoundsParameter.ActualValue;
+      var function = TestFunctionParameter.ActualValue;
+      var maxIterations = ImprovementAttemptsParameter.ActualValue.Value;
 
-      double bestSolQuality = evaluator.Evaluate(bestSol);
+      double bestSolQuality = function.Evaluate(bestSol);
 
       // create perturbed solutions
@@ -133,13 +118,13 @@
       for (int i = 0; i < simplex.Length; i++) {
         simplex[i] = bestSol.Clone() as RealVector;
-        simplex[i][i] += 0.1 * (Bounds[0, 1] - Bounds[0, 0]);
-        if (simplex[i][i] > Bounds[0, 1]) simplex[i][i] = Bounds[0, 1];
-        if (simplex[i][i] < Bounds[0, 0]) simplex[i][i] = Bounds[0, 0];
+        simplex[i][i] += 0.1 * (bounds[0, 1] - bounds[0, 0]);
+        if (simplex[i][i] > bounds[0, 1]) simplex[i][i] = bounds[0, 1];
+        if (simplex[i][i] < bounds[0, 0]) simplex[i][i] = bounds[0, 0];
       }
 
       // improve solutions
-      for (int i = 0; i < ImprovementAttempts.Value; i++) {
+      for (int i = 0; i < maxIterations; i++) {
         // order according to their objective function value
-        Array.Sort(simplex, (x, y) => evaluator.Evaluate(x).CompareTo(evaluator.Evaluate(y)));
+        Array.Sort(simplex, (x, y) => function.Evaluate(x).CompareTo(function.Evaluate(y)));
 
         // calculate centroid
@@ -155,30 +140,30 @@
         for (int j = 0; j < reflectionPoint.Length; j++)
           reflectionPoint[j] = centroid[j] + Alpha.Value * (centroid[j] - simplex[simplex.Length - 1][j]);
-        double reflectionPointQuality = evaluator.Evaluate(reflectionPoint);
-        if (evaluator.Evaluate(simplex[0]) <= reflectionPointQuality
-            && reflectionPointQuality < evaluator.Evaluate(simplex[simplex.Length - 2]))
+        double reflectionPointQuality = function.Evaluate(reflectionPoint);
+        if (function.Evaluate(simplex[0]) <= reflectionPointQuality
+            && reflectionPointQuality < function.Evaluate(simplex[simplex.Length - 2]))
           simplex[simplex.Length - 1] = reflectionPoint;
 
         // expansion
-        if (reflectionPointQuality < evaluator.Evaluate(simplex[0])) {
+        if (reflectionPointQuality < function.Evaluate(simplex[0])) {
           RealVector expansionPoint = new RealVector(bestSol.Length);
           for (int j = 0; j < expansionPoint.Length; j++)
             expansionPoint[j] = centroid[j] + Beta.Value * (reflectionPoint[j] - centroid[j]);
-          simplex[simplex.Length - 1] = evaluator.Evaluate(expansionPoint) < reflectionPointQuality ? expansionPoint : reflectionPoint;
+          simplex[simplex.Length - 1] = function.Evaluate(expansionPoint) < reflectionPointQuality ? expansionPoint : reflectionPoint;
         }
 
         // contraction
-        if (evaluator.Evaluate(simplex[simplex.Length - 2]) <= reflectionPointQuality
-            && reflectionPointQuality < evaluator.Evaluate(simplex[simplex.Length - 1])) {
+        if (function.Evaluate(simplex[simplex.Length - 2]) <= reflectionPointQuality
+            && reflectionPointQuality < function.Evaluate(simplex[simplex.Length - 1])) {
           RealVector outsideContractionPoint = new RealVector(bestSol.Length);
           for (int j = 0; j < outsideContractionPoint.Length; j++)
             outsideContractionPoint[j] = centroid[j] + Gamma.Value * (reflectionPoint[j] - centroid[j]);
-          if (evaluator.Evaluate(outsideContractionPoint) <= reflectionPointQuality) {
+          if (function.Evaluate(outsideContractionPoint) <= reflectionPointQuality) {
             simplex[simplex.Length - 1] = outsideContractionPoint;
-            if (evaluator.Evaluate(reflectionPoint) >= evaluator.Evaluate(simplex[simplex.Length - 1])) {
+            if (function.Evaluate(reflectionPoint) >= function.Evaluate(simplex[simplex.Length - 1])) {
               RealVector insideContractionPoint = new RealVector(bestSol.Length);
               for (int j = 0; j < insideContractionPoint.Length; j++)
                 insideContractionPoint[j] = centroid[j] - Gamma.Value * (reflectionPoint[j] - centroid[j]);
-              if (evaluator.Evaluate(insideContractionPoint) < evaluator.Evaluate(simplex[simplex.Length - 1])) simplex[simplex.Length - 1] = insideContractionPoint;
+              if (function.Evaluate(insideContractionPoint) < function.Evaluate(simplex[simplex.Length - 1])) simplex[simplex.Length - 1] = insideContractionPoint;
             }
           }
@@ -192,10 +177,10 @@
 
       for (int i = 0; i < simplex[0].Length; i++) {
-        if (simplex[0][i] > Bounds[0, 1]) simplex[0][i] = Bounds[0, 1];
-        if (simplex[0][i] < Bounds[0, 0]) simplex[0][i] = Bounds[0, 0];
+        if (simplex[0][i] > bounds[0, 1]) simplex[0][i] = bounds[0, 1];
+        if (simplex[0][i] < bounds[0, 0]) simplex[0][i] = bounds[0, 0];
       }
 
-      CurrentScope.Variables[SolutionParameter.ActualName].Value = simplex[0];
-      CurrentScope.Variables.Add(new Variable("LocalEvaluatedSolutions", ImprovementAttempts));
+      ExecutionContext.Scope.Variables[SolutionParameter.ActualName].Value = simplex[0];
+      ExecutionContext.Scope.Variables.Add(new Variable("LocalEvaluatedSolutions", new IntValue(maxIterations)));
 
       return base.Apply();
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Instances/SOTFData.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Instances/SOTFData.cs	(revision 13401)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Instances/SOTFData.cs	(revision 13403)
@@ -39,5 +39,5 @@
     /// The operator used for evaluations
     /// </summary>
-    public ISingleObjectiveTestFunctionProblemEvaluator Evaluator { get; set; }
+    public ISingleObjectiveTestFunction TestFunction { get; set; }
   }
 }
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Instances/SOTFDataDescriptor.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Instances/SOTFDataDescriptor.cs	(revision 13401)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Instances/SOTFDataDescriptor.cs	(revision 13403)
@@ -24,14 +24,14 @@
 namespace HeuristicLab.Problems.TestFunctions {
   internal class SOTFDataDescriptor : IDataDescriptor {
-    public string Name { get { return Evaluator.FunctionName + " Function"; } }
+    public string Name { get { return TestFunction.ItemName + " Function"; } }
 
     public string Description {
-      get { return Evaluator.Description; }
+      get { return TestFunction.Description; }
     }
 
-    internal ISingleObjectiveTestFunctionProblemEvaluator Evaluator { get; set; }
+    internal ISingleObjectiveTestFunction TestFunction { get; set; }
 
-    public SOTFDataDescriptor(ISingleObjectiveTestFunctionProblemEvaluator evaluator) {
-      Evaluator = evaluator;
+    public SOTFDataDescriptor(ISingleObjectiveTestFunction testFunction) {
+      TestFunction = testFunction;
     }
   }
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Instances/SOTFInstanceProvider.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Instances/SOTFInstanceProvider.cs	(revision 13401)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Instances/SOTFInstanceProvider.cs	(revision 13403)
@@ -45,5 +45,5 @@
 
     public override IEnumerable<IDataDescriptor> GetDataDescriptors() {
-      var evaluators = ApplicationManager.Manager.GetInstances<ISingleObjectiveTestFunctionProblemEvaluator>()
+      var evaluators = ApplicationManager.Manager.GetInstances<ISingleObjectiveTestFunction>()
                                                  .OrderBy(x => x.Name);
       return evaluators.Select(x => new SOTFDataDescriptor(x));
@@ -55,5 +55,5 @@
         Name = descriptor.Name,
         Description = descriptor.Description,
-        Evaluator = descriptor.Evaluator
+        TestFunction = descriptor.TestFunction
       };
     }
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IBestSingleObjectiveTestFunctionSolutionAnalyzer.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IBestSingleObjectiveTestFunctionSolutionAnalyzer.cs	(revision 13401)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IBestSingleObjectiveTestFunctionSolutionAnalyzer.cs	(revision 13403)
@@ -21,4 +21,6 @@
 
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Optimization;
 
@@ -27,7 +29,7 @@
   /// An interface which represents operators for analyzing the best solution of single objective TestFunction Problems given in real vector representation.
   /// </summary>
-  public interface IBestSingleObjectiveTestFunctionSolutionAnalyzer : IAnalyzer, ISingleObjectiveOperator {
-    ILookupParameter RealVectorParameter { get; }
-    ILookupParameter QualityParameter { get; }
+  public interface IBestSingleObjectiveTestFunctionSolutionAnalyzer : IAnalyzer, ISingleObjectiveOperator,
+    IRealVectorSolutionsOperator, IRealVectorBoundedOperator {
+    IScopeTreeLookupParameter<DoubleValue> QualityParameter { get; }
     ILookupParameter<SingleObjectiveTestFunctionSolution> BestSolutionParameter { get; }
     IValueLookupParameter<ResultCollection> ResultsParameter { get; }
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IRastriginMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IRastriginMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,28 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  public interface IRastriginMoveEvaluator : ISingleObjectiveTestFunctionAdditiveMoveEvaluator {
-    DoubleValue A { get; set; }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunction.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunction.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunction.cs	(revision 13403)
@@ -0,0 +1,41 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// An interface which represents an evaluation operator for single objective test functions.
+  /// </summary>
+  public interface ISingleObjectiveTestFunction : INamedItem {
+    bool Maximization { get; }
+    DoubleMatrix Bounds { get; }
+    double BestKnownQuality { get; }
+    int MinimumProblemSize { get; }
+    int MaximumProblemSize { get; }
+
+    double Evaluate2D(double x, double y);
+    double Evaluate(RealVector point);
+    RealVector GetBestKnownSolution(int dimension);
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionAdditiveMoveEvaluator.cs	(revision 13401)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionAdditiveMoveEvaluator.cs	(revision 13403)
@@ -23,5 +23,5 @@
 
 namespace HeuristicLab.Problems.TestFunctions {
-  public interface ISingleObjectiveTestFunctionAdditiveMoveEvaluator : ISingleObjectiveTestFunctionMoveEvaluator, IAdditiveRealVectorMoveOperator {
+  public interface ISingleObjectiveTestFunctionAdditiveMoveEvaluator : ISingleObjectiveTestFunctionMoveEvaluator, IRealVectorAdditiveMoveOperator {
   }
 }
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionMoveEvaluator.cs	(revision 13401)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionMoveEvaluator.cs	(revision 13403)
@@ -20,10 +20,8 @@
 #endregion
 
-using System;
 using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Problems.TestFunctions {
   public interface ISingleObjectiveTestFunctionMoveEvaluator : ISingleObjectiveMoveEvaluator, IMoveOperator {
-    Type EvaluatorType { get; }
   }
 }
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionProblemEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionProblemEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,45 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Optimization;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  /// <summary>
-  /// An interface which represents an evaluation operator for single objective test functions.
-  /// </summary>
-  public interface ISingleObjectiveTestFunctionProblemEvaluator : ISingleObjectiveEvaluator {
-    bool Maximization { get; }
-    DoubleMatrix Bounds { get; }
-    double BestKnownQuality { get; }
-    int MinimumProblemSize { get; }
-    int MaximumProblemSize { get; }
-    string FunctionName { get; }
-
-    ILookupParameter<RealVector> PointParameter { get; }
-
-    double Evaluate2D(double x, double y);
-    double Evaluate(RealVector point);
-    RealVector GetBestKnownSolution(int dimension);
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFuntionImprovementOperator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFuntionImprovementOperator.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFuntionImprovementOperator.cs	(revision 13403)
@@ -0,0 +1,28 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  public interface ISingleObjectiveTestFunctionImprovementOperator : ISingleObjectiveImprovementOperator, IRealVectorBoundedOperator {
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISphereMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISphereMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,29 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  public interface ISphereMoveEvaluator : ISingleObjectiveTestFunctionAdditiveMoveEvaluator {
-    DoubleValue C { get; set; }
-    DoubleValue Alpha { get; set; }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ITestFunctionSolutionSimilarityCalculator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ITestFunctionSolutionSimilarityCalculator.cs	(revision 13403)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ITestFunctionSolutionSimilarityCalculator.cs	(revision 13403)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  public interface ITestFunctionSolutionSimilarityCalculator : ISolutionSimilarityCalculator {
+    DoubleMatrix Bounds { get; set; }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/AckleyAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/AckleyAdditiveMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,49 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  [Item("AckleyAdditiveMoveEvaluator", "Class for evaluating an additive move on the Ackley function.")]
-  [StorableClass]
-  public class AckleyAdditiveMoveEvaluator : AdditiveMoveEvaluator {
-    public override System.Type EvaluatorType {
-      get { return typeof(AckleyEvaluator); }
-    }
-
-    [StorableConstructor]
-    protected AckleyAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected AckleyAdditiveMoveEvaluator(AckleyAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public AckleyAdditiveMoveEvaluator() : base() { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new AckleyAdditiveMoveEvaluator(this, cloner);
-    }
-
-    protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
-      RealVectorAdditiveMoveWrapper wrapper = new RealVectorAdditiveMoveWrapper(move, point);
-      return AckleyEvaluator.Apply(wrapper);
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/AdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/AdditiveMoveEvaluator.cs	(revision 13401)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/AdditiveMoveEvaluator.cs	(revision 13403)
@@ -20,5 +20,4 @@
 #endregion
 
-using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -32,7 +31,6 @@
   [Item("AdditiveMoveEvaluator", "Base class for evaluating an additive move.")]
   [StorableClass]
-  public abstract class AdditiveMoveEvaluator : SingleSuccessorOperator, ISingleObjectiveTestFunctionAdditiveMoveEvaluator {
+  public class AdditiveMoveEvaluator : SingleSuccessorOperator, ISingleObjectiveTestFunctionAdditiveMoveEvaluator {
 
-    public abstract Type EvaluatorType { get; }
     public override bool CanChangeName {
       get { return false; }
@@ -51,9 +49,12 @@
       get { return (ILookupParameter<AdditiveMove>)Parameters["AdditiveMove"]; }
     }
+    public ILookupParameter<ISingleObjectiveTestFunction> TestFunctionParameter {
+      get { return (ILookupParameter<ISingleObjectiveTestFunction>)Parameters["TestFunction"]; }
+    }
 
     [StorableConstructor]
     protected AdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
     protected AdditiveMoveEvaluator(AdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    protected AdditiveMoveEvaluator()
+    public AdditiveMoveEvaluator()
       : base() {
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of a test function solution."));
@@ -61,9 +62,21 @@
       Parameters.Add(new LookupParameter<RealVector>("Point", "The point to evaluate the move on."));
       Parameters.Add(new LookupParameter<AdditiveMove>("AdditiveMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<ISingleObjectiveTestFunction>("TestFunction", "The test function that is used."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AdditiveMoveEvaluator(this, cloner);
     }
 
     public override IOperation Apply() {
-      double mq = Evaluate(QualityParameter.ActualValue.Value, RealVectorParameter.ActualValue, AdditiveMoveParameter.ActualValue);
-      DoubleValue moveQuality = MoveQualityParameter.ActualValue;
+      var function = TestFunctionParameter.ActualValue;
+      var move = AdditiveMoveParameter.ActualValue;
+      var vector = RealVectorParameter.ActualValue;
+      var clone = (RealVector)vector.Clone();
+
+      AdditiveMoveMaker.Apply(clone, move);
+      var mq = function.Evaluate(clone);
+
+      var moveQuality = MoveQualityParameter.ActualValue;
       if (moveQuality == null) {
         MoveQualityParameter.ActualValue = new DoubleValue(mq);
@@ -71,6 +84,4 @@
       return base.Apply();
     }
-
-    protected abstract double Evaluate(double quality, RealVector point, AdditiveMove move);
   }
 }
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/BealeAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/BealeAdditiveMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,49 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  [Item("BealeAdditiveMoveEvaluator", "Class for evaluating an additive move on the Beale function.")]
-  [StorableClass]
-  public class BealeAdditiveMoveEvaluator : AdditiveMoveEvaluator {
-    public override System.Type EvaluatorType {
-      get { return typeof(BealeEvaluator); }
-    }
-
-    [StorableConstructor]
-    protected BealeAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected BealeAdditiveMoveEvaluator(BealeAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public BealeAdditiveMoveEvaluator() : base() { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new BealeAdditiveMoveEvaluator(this, cloner);
-    }
-
-    protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
-      RealVectorAdditiveMoveWrapper wrapper = new RealVectorAdditiveMoveWrapper(move, point);
-      return BealeEvaluator.Apply(wrapper);
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/BoothAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/BoothAdditiveMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,49 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  [Item("BoothAdditiveMoveEvaluator", "Class for evaluating an additive move on the Booth function.")]
-  [StorableClass]
-  public class BoothAdditiveMoveEvaluator : AdditiveMoveEvaluator {
-    public override System.Type EvaluatorType {
-      get { return typeof(BoothEvaluator); }
-    }
-
-    [StorableConstructor]
-    protected BoothAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected BoothAdditiveMoveEvaluator(BoothAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public BoothAdditiveMoveEvaluator() : base() { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new BoothAdditiveMoveEvaluator(this, cloner);
-    }
-
-    protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
-      RealVectorAdditiveMoveWrapper wrapper = new RealVectorAdditiveMoveWrapper(move, point);
-      return BoothEvaluator.Apply(wrapper);
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/GriewankAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/GriewankAdditiveMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,49 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  [Item("GriewankAdditiveMoveEvaluator", "Class for evaluating an additive move on the Griewank function.")]
-  [StorableClass]
-  public class GriewankAdditiveMoveEvaluator : AdditiveMoveEvaluator {
-    public override System.Type EvaluatorType {
-      get { return typeof(GriewankEvaluator); }
-    }
-
-    [StorableConstructor]
-    protected GriewankAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected GriewankAdditiveMoveEvaluator(GriewankAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public GriewankAdditiveMoveEvaluator() : base() { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new GriewankAdditiveMoveEvaluator(this, cloner);
-    }
-
-    protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
-      RealVectorAdditiveMoveWrapper wrapper = new RealVectorAdditiveMoveWrapper(move, point);
-      return GriewankEvaluator.Apply(wrapper);
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/LevyAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/LevyAdditiveMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,49 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  [Item("LevyAdditiveMoveEvaluator", "Class for evaluating an additive move on the Levy function.")]
-  [StorableClass]
-  public class LevyAdditiveMoveEvaluator : AdditiveMoveEvaluator {
-    public override System.Type EvaluatorType {
-      get { return typeof(LevyEvaluator); }
-    }
-
-    [StorableConstructor]
-    protected LevyAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected LevyAdditiveMoveEvaluator(LevyAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public LevyAdditiveMoveEvaluator() : base() { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new LevyAdditiveMoveEvaluator(this, cloner);
-    }
-
-    protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
-      RealVectorAdditiveMoveWrapper wrapper = new RealVectorAdditiveMoveWrapper(move, point);
-      return LevyEvaluator.Apply(wrapper);
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/MatyasAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/MatyasAdditiveMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,49 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  [Item("MatyasAdditiveMoveEvaluator", "Class for evaluating an additive move on the Matyas function.")]
-  [StorableClass]
-  public class MatyasAdditiveMoveEvaluator : AdditiveMoveEvaluator {
-    public override System.Type EvaluatorType {
-      get { return typeof(MatyasEvaluator); }
-    }
-
-    [StorableConstructor]
-    protected MatyasAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected MatyasAdditiveMoveEvaluator(MatyasAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public MatyasAdditiveMoveEvaluator() : base() { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MatyasAdditiveMoveEvaluator(this, cloner);
-    }
-
-    protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
-      RealVectorAdditiveMoveWrapper wrapper = new RealVectorAdditiveMoveWrapper(move, point);
-      return MatyasEvaluator.Apply(wrapper);
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/MultinormalAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/MultinormalAdditiveMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,61 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.TestFunctions.Evaluators;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  [Item("MultinormalAdditiveMoveEvaluator", "Class for evaluating an additive move on the multinormal function.")]
-  [StorableClass]
-  public class MultinormalAdditiveMoveEvaluator : AdditiveMoveEvaluator {
-    public LookupParameter<ISingleObjectiveTestFunctionProblemEvaluator> EvaluatorParameter {
-      get { return (LookupParameter<ISingleObjectiveTestFunctionProblemEvaluator>)Parameters["Evaluator"]; }
-    }
-
-    [StorableConstructor]
-    protected MultinormalAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected MultinormalAdditiveMoveEvaluator(MultinormalAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public MultinormalAdditiveMoveEvaluator() {
-      Parameters.Add(new LookupParameter<ISingleObjectiveTestFunctionProblemEvaluator>("Evaluator", ""));
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultinormalAdditiveMoveEvaluator(this, cloner);
-    }
-
-    public override System.Type EvaluatorType {
-      get { return typeof(MultinormalEvaluator); }
-    }
-
-    protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
-      RealVectorAdditiveMoveWrapper wrapper = new RealVectorAdditiveMoveWrapper(move, point);
-      var eval = EvaluatorParameter.ActualValue as MultinormalEvaluator;
-      if (eval != null)
-        return eval.Evaluate(wrapper);
-      throw new InvalidOperationException("evaluator is not a multinormal evaluator");
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RandomAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RandomAdditiveMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,56 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  [Item("RandomAdditiveMoveEvaluator", "Class for evaluating an additive move on the Random function.")]
-  [StorableClass]
-  public class RandomAdditiveMoveEvaluator : AdditiveMoveEvaluator {
-    public override System.Type EvaluatorType {
-      get { return typeof(RandomEvaluator); }
-    }
-
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
-    }
-
-    [StorableConstructor]
-    protected RandomAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected RandomAdditiveMoveEvaluator(RandomAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public RandomAdditiveMoveEvaluator()
-      : base() {
-      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new RandomAdditiveMoveEvaluator(this, cloner);
-    }
-
-    protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
-      return RandomParameter.ActualValue.NextDouble();
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RastriginAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RastriginAdditiveMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,66 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  [Item("RastriginAdditiveMoveEvaluator", "Class for evaluating an additive move on the Rastrigin function.")]
-  [StorableClass]
-  public class RastriginAdditiveMoveEvaluator : AdditiveMoveEvaluator, IRastriginMoveEvaluator {
-    public override System.Type EvaluatorType {
-      get { return typeof(RastriginEvaluator); }
-    }
-    /// <summary>
-    /// The parameter A is a parameter of the objective function y = Sum((x_i)^2 + A * (1 - Cos(2pi*x_i))). Default is A = 10.
-    /// </summary>
-    public ValueParameter<DoubleValue> AParameter {
-      get { return (ValueParameter<DoubleValue>)Parameters["A"]; }
-    }
-    /// <summary>
-    /// The parameter A is a parameter of the objective function y = Sum((x_i)^2 + A * (1 - Cos(2pi*x_i))). Default is A = 10.
-    /// </summary>
-    public DoubleValue A {
-      get { return AParameter.Value; }
-      set { if (value != null) AParameter.Value = value; }
-    }
-
-    [StorableConstructor]
-    protected RastriginAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected RastriginAdditiveMoveEvaluator(RastriginAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public RastriginAdditiveMoveEvaluator() {
-      Parameters.Add(new ValueParameter<DoubleValue>("A", "The parameter A is a parameter of the objective function y = Sum((x_i)^2 + A * (1 - Cos(2pi*x_i))). Default is A = 10.", new DoubleValue(10)));
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new RastriginAdditiveMoveEvaluator(this, cloner);
-    }
-
-    protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
-      RealVectorAdditiveMoveWrapper wrapper = new RealVectorAdditiveMoveWrapper(move, point);
-      return RastriginEvaluator.Apply(wrapper, A.Value);
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RealVectorAdditiveMoveWrapper.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RealVectorAdditiveMoveWrapper.cs	(revision 13401)
+++ 	(revision )
@@ -1,76 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.PluginInfrastructure;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  /// <summary>
-  /// This wrapper disguises as real vector for use in the evaluation functions.
-  /// </summary>
-  [NonDiscoverableType]
-  internal sealed class RealVectorAdditiveMoveWrapper : RealVector {
-    private int dimension;
-    private double moveDistance;
-    private RealVector vector;
-
-    private RealVectorAdditiveMoveWrapper(bool deserializing) : base(deserializing) { }
-    private RealVectorAdditiveMoveWrapper(RealVectorAdditiveMoveWrapper original, Cloner cloner)
-      : base(original, cloner) {
-      this.dimension = original.dimension;
-      this.moveDistance = original.moveDistance;
-      this.vector = cloner.Clone(vector);
-    }
-    public RealVectorAdditiveMoveWrapper(AdditiveMove move, RealVector vector) {
-      dimension = move.Dimension;
-      moveDistance = move.MoveDistance;
-      this.vector = vector;
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new RealVectorAdditiveMoveWrapper(this, cloner);
-    }
-
-    public override double this[int index] {
-      get {
-        if (index != dimension)
-          return vector[index];
-        else return vector[index] + moveDistance;
-      }
-      set {
-        throw new System.NotSupportedException("Error: Writing to the wrapper is not allowed.");
-      }
-    }
-
-    public override int Length {
-      get {
-        return vector.Length;
-      }
-      #region Mono Compatibility
-      // this setter should be protected, but the Mono compiler couldn't handle it
-      set {
-        throw new System.NotSupportedException("Error: Setting the lenght of the wrapper is not allowed.");
-      }
-      #endregion
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RosenbrockAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RosenbrockAdditiveMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,49 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  [Item("RosenbrockAdditiveMoveEvaluator", "Class for evaluating an additive move on the Rosenbrock function.")]
-  [StorableClass]
-  public class RosenbrockAdditiveMoveEvaluator : AdditiveMoveEvaluator {
-    public override System.Type EvaluatorType {
-      get { return typeof(RosenbrockEvaluator); }
-    }
-
-    [StorableConstructor]
-    protected RosenbrockAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected RosenbrockAdditiveMoveEvaluator(RosenbrockAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public RosenbrockAdditiveMoveEvaluator() : base() { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new RosenbrockAdditiveMoveEvaluator(this, cloner);
-    }
-
-    protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
-      RealVectorAdditiveMoveWrapper wrapper = new RealVectorAdditiveMoveWrapper(move, point);
-      return RosenbrockEvaluator.Apply(wrapper);
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SchwefelAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SchwefelAdditiveMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,49 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  [Item("SchwefelAdditiveMoveEvaluator", "Class for evaluating an additive move on the Schwefel function.")]
-  [StorableClass]
-  public class SchwefelAdditiveMoveEvaluator : AdditiveMoveEvaluator {
-    public override System.Type EvaluatorType {
-      get { return typeof(SchwefelEvaluator); }
-    }
-
-    [StorableConstructor]
-    protected SchwefelAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected SchwefelAdditiveMoveEvaluator(SchwefelAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public SchwefelAdditiveMoveEvaluator() : base() { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SchwefelAdditiveMoveEvaluator(this, cloner);
-    }
-
-    protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
-      RealVectorAdditiveMoveWrapper wrapper = new RealVectorAdditiveMoveWrapper(move, point);
-      return SchwefelEvaluator.Apply(wrapper);
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SphereAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SphereAdditiveMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,81 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  [Item("SphereAdditiveMoveEvaluator", "Class for evaluating an additive move on the Sphere function.")]
-  [StorableClass]
-  public class SphereAdditiveMoveEvaluator : AdditiveMoveEvaluator, ISphereMoveEvaluator {
-    /// <summary>
-    /// The parameter C modifies the steepness of the objective function y = C * ||X||^Alpha. Default is C = 1.
-    /// </summary>
-    public ValueParameter<DoubleValue> CParameter {
-      get { return (ValueParameter<DoubleValue>)Parameters["C"]; }
-    }
-    /// <summary>
-    /// The parameter Alpha modifies the steepness of the objective function y = C * ||X||^Alpha. Default is Alpha = 2.
-    /// </summary>
-    public ValueParameter<DoubleValue> AlphaParameter {
-      get { return (ValueParameter<DoubleValue>)Parameters["Alpha"]; }
-    }
-    /// <summary>
-    /// The parameter C modifies the steepness of the objective function y = C * ||X||^Alpha. Default is C = 1.
-    /// </summary>
-    public DoubleValue C {
-      get { return CParameter.Value; }
-      set { if (value != null) CParameter.Value = value; }
-    }
-    /// <summary>
-    /// The parameter Alpha modifies the steepness of the objective function y = C * ||X||^Alpha. Default is Alpha = 2.
-    /// </summary>
-    public DoubleValue Alpha {
-      get { return AlphaParameter.Value; }
-      set { if (value != null) AlphaParameter.Value = value; }
-    }
-
-    public override System.Type EvaluatorType {
-      get { return typeof(SphereEvaluator); }
-    }
-
-    [StorableConstructor]
-    protected SphereAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected SphereAdditiveMoveEvaluator(SphereAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public SphereAdditiveMoveEvaluator() {
-      Parameters.Add(new ValueParameter<DoubleValue>("C", "The parameter C modifies the steepness of the objective function y = C * ||X||^Alpha. Default is C = 1.", new DoubleValue(1)));
-      Parameters.Add(new ValueParameter<DoubleValue>("Alpha", "The parameter Alpha modifies the steepness of the objective function y = C * ||X||^Alpha. Default is Alpha = 2.", new DoubleValue(2)));
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SphereAdditiveMoveEvaluator(this, cloner);
-    }
-
-    protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
-      RealVectorAdditiveMoveWrapper wrapper = new RealVectorAdditiveMoveWrapper(move, point);
-      return SphereEvaluator.Apply(wrapper, C.Value, Alpha.Value);
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SumSquaresAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SumSquaresAdditiveMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,49 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  [Item("SumSquaresAdditiveMoveEvaluator", "Class for evaluating an additive move on the SumSquares function.")]
-  [StorableClass]
-  public class SumSquaresAdditiveMoveEvaluator : AdditiveMoveEvaluator {
-    public override System.Type EvaluatorType {
-      get { return typeof(SumSquaresEvaluator); }
-    }
-
-    [StorableConstructor]
-    protected SumSquaresAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected SumSquaresAdditiveMoveEvaluator(SumSquaresAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public SumSquaresAdditiveMoveEvaluator() : base() { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SumSquaresAdditiveMoveEvaluator(this, cloner);
-    }
-
-    protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
-      RealVectorAdditiveMoveWrapper wrapper = new RealVectorAdditiveMoveWrapper(move, point);
-      return SumSquaresEvaluator.Apply(wrapper);
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/ZakharovAdditiveMoveEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/ZakharovAdditiveMoveEvaluator.cs	(revision 13401)
+++ 	(revision )
@@ -1,49 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Encodings.RealVectorEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  [Item("ZakharovAdditiveMoveEvaluator", "Class for evaluating an additive move on the Zakharov function.")]
-  [StorableClass]
-  public class ZakharovAdditiveMoveEvaluator : AdditiveMoveEvaluator {
-    public override System.Type EvaluatorType {
-      get { return typeof(ZakharovEvaluator); }
-    }
-
-    [StorableConstructor]
-    protected ZakharovAdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected ZakharovAdditiveMoveEvaluator(ZakharovAdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public ZakharovAdditiveMoveEvaluator() : base() { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ZakharovAdditiveMoveEvaluator(this, cloner);
-    }
-
-    protected override double Evaluate(double quality, RealVector point, AdditiveMove move) {
-      RealVectorAdditiveMoveWrapper wrapper = new RealVectorAdditiveMoveWrapper(move, point);
-      return ZakharovEvaluator.Apply(wrapper);
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/RealVectorToRealVectorEncoder.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/RealVectorToRealVectorEncoder.cs	(revision 13401)
+++ 	(revision )
@@ -1,54 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 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.Operators;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.TestFunctions {
-  // BackwardsCompatibility3.3
-  #region Backwards compatible code (remove with 3.4)
-  [Obsolete("This operator should not be used anymore.")]
-  internal class RealVectorToRealVectorEncoder : SingleSuccessorOperator {
-
-    [StorableConstructor]
-    protected RealVectorToRealVectorEncoder(bool deserializing) : base(deserializing) { }
-    protected RealVectorToRealVectorEncoder(RealVectorToRealVectorEncoder original, Cloner cloner) : base(original, cloner) { }
-    public RealVectorToRealVectorEncoder()
-      : base() {
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new RealVectorToRealVectorEncoder(this, cloner);
-    }
-
-    public override IOperation Apply() {
-      return base.Apply();
-    }
-
-    public override bool CanChangeName {
-      get { return false; }
-    }
-  }
-  #endregion
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SimilarityCalculators/SingleObjectiveTestFunctionSimilarityCalculator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SimilarityCalculators/SingleObjectiveTestFunctionSimilarityCalculator.cs	(revision 13401)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SimilarityCalculators/SingleObjectiveTestFunctionSimilarityCalculator.cs	(revision 13403)
@@ -37,5 +37,5 @@
   [Item("SingleObjectiveTestFunctionSimilarityCalculator", "An operator that performs similarity calculation between two test functions solutions. The operator calculates the similarity based on the euclidean distance of the two solutions in n-dimensional space.")]
   [StorableClass]
-  public sealed class SingleObjectiveTestFunctionSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {
+  public sealed class SingleObjectiveTestFunctionSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator, ITestFunctionSolutionSimilarityCalculator {
     protected override bool IsCommutative { get { return true; } }
 
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs	(revision 13401)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs	(revision 13403)
@@ -32,5 +32,4 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Problems.Instances;
 
@@ -40,51 +39,42 @@
   [Creatable(CreatableAttribute.Categories.Problems, Priority = 90)]
   public sealed class SingleObjectiveTestFunctionProblem :
-    SingleObjectiveHeuristicOptimizationProblem<ISingleObjectiveTestFunctionProblemEvaluator, IRealVectorCreator>,
-    ISingleObjectiveProblem<RealVectorEncoding, RealVector>, IStorableContent, IProblemInstanceConsumer<SOTFData> {
-    public string Filename { get; set; }
-
-    [Storable]
-    private StdDevStrategyVectorCreator strategyVectorCreator;
-    [Storable]
-    private StdDevStrategyVectorCrossover strategyVectorCrossover;
-    [Storable]
-    private StdDevStrategyVectorManipulator strategyVectorManipulator;
+    SingleObjectiveProblem<RealVectorEncoding, RealVector>,
+    IProblemInstanceConsumer<SOTFData> {
+
+    public override bool Maximization {
+      get { return Parameters.ContainsKey("TestFunction") && TestFunction.Maximization; }
+    }
 
     #region Parameter Properties
-    public ValueParameter<DoubleMatrix> BoundsParameter {
-      get { return (ValueParameter<DoubleMatrix>)Parameters["Bounds"]; }
-    }
-    public ValueParameter<IntValue> ProblemSizeParameter {
-      get { return (ValueParameter<IntValue>)Parameters["ProblemSize"]; }
+    private IFixedValueParameter<IntValue> ProblemSizeParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["ProblemSize"]; }
+    }
+    private IValueParameter<DoubleMatrix> BoundsParameter {
+      get { return (IValueParameter<DoubleMatrix>)Parameters["Bounds"]; }
     }
     public OptionalValueParameter<RealVector> BestKnownSolutionParameter {
       get { return (OptionalValueParameter<RealVector>)Parameters["BestKnownSolution"]; }
     }
+    public IValueParameter<ISingleObjectiveTestFunction> TestFunctionParameter {
+      get { return (IValueParameter<ISingleObjectiveTestFunction>)Parameters["TestFunction"]; }
+    }
     #endregion
 
     #region Properties
+    public int ProblemSize {
+      get { return ProblemSizeParameter.Value.Value; }
+      set { ProblemSizeParameter.Value.Value = value; }
+    }
     public DoubleMatrix Bounds {
       get { return BoundsParameter.Value; }
       set { BoundsParameter.Value = value; }
     }
-    public IntValue ProblemSize {
-      get { return ProblemSizeParameter.Value; }
-      set { ProblemSizeParameter.Value = value; }
-    }
+    public ISingleObjectiveTestFunction TestFunction {
+      get { return TestFunctionParameter.Value; }
+      set { TestFunctionParameter.Value = value; }
+    }
+
     private BestSingleObjectiveTestFunctionSolutionAnalyzer BestSingleObjectiveTestFunctionSolutionAnalyzer {
       get { return Operators.OfType<BestSingleObjectiveTestFunctionSolutionAnalyzer>().FirstOrDefault(); }
-    }
-    #endregion
-
-    // BackwardsCompatibility3.3
-    #region Backwards compatible code, remove with 3.4
-    [Obsolete]
-    [Storable(Name = "operators")]
-    private IEnumerable<IOperator> oldOperators {
-      get { return null; }
-      set {
-        if (value != null && value.Any())
-          Operators.AddRange(value);
-      }
     }
     #endregion
@@ -94,32 +84,19 @@
     private SingleObjectiveTestFunctionProblem(SingleObjectiveTestFunctionProblem original, Cloner cloner)
       : base(original, cloner) {
-      strategyVectorCreator = cloner.Clone(original.strategyVectorCreator);
-      strategyVectorCrossover = cloner.Clone(original.strategyVectorCrossover);
-      strategyVectorManipulator = cloner.Clone(original.strategyVectorManipulator);
       RegisterEventHandlers();
     }
     public SingleObjectiveTestFunctionProblem()
-      : base(new AckleyEvaluator(), new UniformRandomRealVectorCreator()) {
-      Parameters.Add(new ValueParameter<DoubleMatrix>("Bounds", "The lower and upper bounds in each dimension.", Evaluator.Bounds));
-      Parameters.Add(new ValueParameter<IntValue>("ProblemSize", "The dimension of the problem.", new IntValue(2)));
+      : base(new RealVectorEncoding("Point")) {
+      Parameters.Add(new FixedValueParameter<IntValue>("ProblemSize", "The dimensionality of the problem instance (number of variables in the function).", new IntValue(2)));
+      Parameters.Add(new ValueParameter<DoubleMatrix>("Bounds", "The bounds of the solution given as either one line for all variables or a line for each variable. The first column specifies lower bound, the second upper bound.", new DoubleMatrix(new double[,] { { -100, 100 } })));
       Parameters.Add(new OptionalValueParameter<RealVector>("BestKnownSolution", "The best known solution for this test function instance."));
-
-      Maximization.Value = Evaluator.Maximization;
-      BestKnownQuality = new DoubleValue(Evaluator.BestKnownQuality);
-
-      strategyVectorCreator = new StdDevStrategyVectorCreator();
-      strategyVectorCreator.LengthParameter.ActualName = ProblemSizeParameter.Name;
-      strategyVectorCrossover = new StdDevStrategyVectorCrossover();
-      strategyVectorManipulator = new StdDevStrategyVectorManipulator();
-      strategyVectorManipulator.LearningRateParameter.Value = new DoubleValue(0.5);
-      strategyVectorManipulator.GeneralLearningRateParameter.Value = new DoubleValue(0.5);
-
-      SolutionCreator.RealVectorParameter.ActualName = "Point";
-      ParameterizeSolutionCreator();
-      ParameterizeEvaluator();
+      Parameters.Add(new ValueParameter<ISingleObjectiveTestFunction>("TestFunction", "The function that is to be optimized.", new Ackley()));
+
+      Encoding.LengthParameter = ProblemSizeParameter;
+      Encoding.BoundsParameter = BoundsParameter;
+      BestKnownQuality = TestFunction.BestKnownQuality;
 
       InitializeOperators();
       RegisterEventHandlers();
-      UpdateStrategyVectorBounds();
     }
 
@@ -128,135 +105,57 @@
     }
 
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
+    private void RegisterEventHandlers() {
+      Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+      TestFunctionParameter.ValueChanged += TestFunctionParameterOnValueChanged;
+      ProblemSizeParameter.Value.ValueChanged += ProblemSizeOnValueChanged;
+      BoundsParameter.ValueChanged += BoundsParameterOnValueChanged;
+    }
+
+    public override double Evaluate(RealVector individual, IRandom random) {
+      return TestFunction.Evaluate(individual);
+    }
+
     #region Events
-    protected override void OnSolutionCreatorChanged() {
-      base.OnSolutionCreatorChanged();
-      ParameterizeSolutionCreator();
-      ParameterizeAnalyzers();
-      SolutionCreator.RealVectorParameter.ActualNameChanged += new EventHandler(SolutionCreator_RealVectorParameter_ActualNameChanged);
-      SolutionCreator_RealVectorParameter_ActualNameChanged(null, EventArgs.Empty);
+    protected override void OnEncodingChanged() {
+      base.OnEncodingChanged();
+      Parameterize();
     }
     protected override void OnEvaluatorChanged() {
       base.OnEvaluatorChanged();
-      bool problemSizeChange = ProblemSize.Value < Evaluator.MinimumProblemSize
-        || ProblemSize.Value > Evaluator.MaximumProblemSize;
+      Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+      Parameterize();
+    }
+    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+      Parameterize();
+    }
+    private void TestFunctionParameterOnValueChanged(object sender, EventArgs eventArgs) {
+      var problemSizeChange = ProblemSize < TestFunction.MinimumProblemSize
+                              || ProblemSize > TestFunction.MaximumProblemSize;
       if (problemSizeChange) {
-        ProblemSize.Value = Math.Max(Evaluator.MinimumProblemSize, Math.Min(ProblemSize.Value, Evaluator.MaximumProblemSize));
-      } else {
-        ParameterizeEvaluator();
-      }
-      UpdateMoveEvaluators();
-      ParameterizeAnalyzers();
-      Maximization.Value = Evaluator.Maximization;
-      BoundsParameter.Value = Evaluator.Bounds;
-      BestKnownQuality = new DoubleValue(Evaluator.BestKnownQuality);
-      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
-      Evaluator_QualityParameter_ActualNameChanged(null, EventArgs.Empty);
+        ProblemSize = Math.Max(TestFunction.MinimumProblemSize, Math.Min(ProblemSize, TestFunction.MaximumProblemSize));
+      }
+      BestKnownQuality = TestFunction.BestKnownQuality;
+      Bounds = (DoubleMatrix)TestFunction.Bounds.Clone();
+      var bestSolution = TestFunction.GetBestKnownSolution(ProblemSize);
+      BestKnownSolutionParameter.Value = bestSolution;
+
       OnReset();
     }
-    private void ProblemSizeParameter_ValueChanged(object sender, EventArgs e) {
-      ProblemSize.ValueChanged += new EventHandler(ProblemSize_ValueChanged);
-      ProblemSize_ValueChanged(null, EventArgs.Empty);
-    }
-    private void ProblemSize_ValueChanged(object sender, EventArgs e) {
-      if (ProblemSize.Value < 1) ProblemSize.Value = 1;
-      ParameterizeSolutionCreator();
-      ParameterizeEvaluator();
-      strategyVectorManipulator.GeneralLearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * ProblemSize.Value));
-      strategyVectorManipulator.LearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Math.Sqrt(ProblemSize.Value)));
-      OnReset();
-    }
-    private void SolutionCreator_RealVectorParameter_ActualNameChanged(object sender, EventArgs e) {
-      ParameterizeEvaluator();
-      ParameterizeOperators();
-      ParameterizeAnalyzers();
-    }
-    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
-      ParameterizeOperators();
-    }
-    private void BoundsParameter_ValueChanged(object sender, EventArgs e) {
-      Bounds.ToStringChanged += new EventHandler(Bounds_ToStringChanged);
-      Bounds_ToStringChanged(null, EventArgs.Empty);
-    }
-    private void Bounds_ToStringChanged(object sender, EventArgs e) {
-      if (Bounds.Columns != 2 || Bounds.Rows < 1)
-        Bounds = new DoubleMatrix(1, 2);
-      ParameterizeOperators();
-      UpdateStrategyVectorBounds();
-    }
-    private void Bounds_ItemChanged(object sender, EventArgs<int, int> e) {
-      if (e.Value2 == 0 && Bounds[e.Value, 1] <= Bounds[e.Value, 0])
-        Bounds[e.Value, 1] = Bounds[e.Value, 0] + 0.1;
-      if (e.Value2 == 1 && Bounds[e.Value, 0] >= Bounds[e.Value, 1])
-        Bounds[e.Value, 0] = Bounds[e.Value, 1] - 0.1;
-      ParameterizeOperators();
-      UpdateStrategyVectorBounds();
-    }
-    private void MoveGenerator_AdditiveMoveParameter_ActualNameChanged(object sender, EventArgs e) {
-      string name = ((ILookupParameter<AdditiveMove>)sender).ActualName;
-      foreach (IAdditiveRealVectorMoveOperator op in Operators.OfType<IAdditiveRealVectorMoveOperator>()) {
-        op.AdditiveMoveParameter.ActualName = name;
-      }
-    }
-    private void SphereEvaluator_Parameter_ValueChanged(object sender, EventArgs e) {
-      SphereEvaluator eval = (Evaluator as SphereEvaluator);
-      if (eval != null) {
-        foreach (ISphereMoveEvaluator op in Operators.OfType<ISphereMoveEvaluator>()) {
-          op.C = eval.C;
-          op.Alpha = eval.Alpha;
-        }
-      }
-    }
-    private void RastriginEvaluator_Parameter_ValueChanged(object sender, EventArgs e) {
-      RastriginEvaluator eval = (Evaluator as RastriginEvaluator);
-      if (eval != null) {
-        foreach (IRastriginMoveEvaluator op in Operators.OfType<IRastriginMoveEvaluator>()) {
-          op.A = eval.A;
-        }
-      }
-    }
-    private void strategyVectorCreator_BoundsParameter_ValueChanged(object sender, EventArgs e) {
-      strategyVectorManipulator.BoundsParameter.Value = (DoubleMatrix)strategyVectorCreator.BoundsParameter.Value.Clone();
-    }
-    private void strategyVectorCreator_StrategyParameterParameter_ActualNameChanged(object sender, EventArgs e) {
-      string name = strategyVectorCreator.StrategyParameterParameter.ActualName;
-      strategyVectorCrossover.ParentsParameter.ActualName = name;
-      strategyVectorCrossover.StrategyParameterParameter.ActualName = name;
-      strategyVectorManipulator.StrategyParameterParameter.ActualName = name;
+    private void ProblemSizeOnValueChanged(object sender, EventArgs eventArgs) {
+      if (ProblemSize < TestFunction.MinimumProblemSize
+        || ProblemSize > TestFunction.MaximumProblemSize)
+        ProblemSize = Math.Min(TestFunction.MaximumProblemSize, Math.Max(TestFunction.MinimumProblemSize, ProblemSize));
+    }
+    private void BoundsParameterOnValueChanged(object sender, EventArgs eventArgs) {
+      Parameterize();
     }
     #endregion
 
     #region Helpers
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      // BackwardsCompatibility3.3
-      #region Backwards compatible code (remove with 3.4)
-      if (Operators.Count == 0) InitializeOperators();
-      #endregion
-      RegisterEventHandlers();
-    }
-
-    private void RegisterEventHandlers() {
-      ProblemSizeParameter.ValueChanged += new EventHandler(ProblemSizeParameter_ValueChanged);
-      ProblemSize.ValueChanged += new EventHandler(ProblemSize_ValueChanged);
-      BoundsParameter.ValueChanged += new EventHandler(BoundsParameter_ValueChanged);
-      Bounds.ToStringChanged += new EventHandler(Bounds_ToStringChanged);
-      Bounds.ItemChanged += new EventHandler<EventArgs<int, int>>(Bounds_ItemChanged);
-      SolutionCreator.RealVectorParameter.ActualNameChanged += new EventHandler(SolutionCreator_RealVectorParameter_ActualNameChanged);
-      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
-      strategyVectorCreator.BoundsParameter.ValueChanged += new EventHandler(strategyVectorCreator_BoundsParameter_ValueChanged);
-      strategyVectorCreator.StrategyParameterParameter.ActualNameChanged += new EventHandler(strategyVectorCreator_StrategyParameterParameter_ActualNameChanged);
-    }
-    private void ParameterizeAnalyzers() {
-      if (BestSingleObjectiveTestFunctionSolutionAnalyzer != null) {
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.ResultsParameter.ActualName = "Results";
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.BestKnownQualityParameter.ActualName = BestKnownQualityParameter.Name;
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.BestKnownSolutionParameter.ActualName = BestKnownSolutionParameter.Name;
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.MaximizationParameter.ActualName = MaximizationParameter.Name;
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.BoundsParameter.ActualName = BoundsParameter.Name;
-      }
-    }
     private void InitializeOperators() {
       Operators.Add(new SingleObjectiveTestFunctionImprovementOperator());
@@ -265,140 +164,45 @@
       Operators.Add(new QualitySimilarityCalculator());
       Operators.Add(new NoSimilarityCalculator());
+      Operators.Add(new AdditiveMoveEvaluator());
 
       Operators.Add(new BestSingleObjectiveTestFunctionSolutionAnalyzer());
       Operators.Add(new PopulationSimilarityAnalyzer(Operators.OfType<ISolutionSimilarityCalculator>()));
-      ParameterizeAnalyzers();
-      Operators.AddRange(ApplicationManager.Manager.GetInstances<IRealVectorOperator>().Cast<IOperator>());
-      Operators.Add(strategyVectorCreator);
-      Operators.Add(strategyVectorCrossover);
-      Operators.Add(strategyVectorManipulator);
-      UpdateMoveEvaluators();
-      ParameterizeOperators();
-      InitializeMoveGenerators();
-    }
-    private void InitializeMoveGenerators() {
-      foreach (IAdditiveRealVectorMoveOperator op in Operators.OfType<IAdditiveRealVectorMoveOperator>()) {
-        if (op is IMoveGenerator) {
-          op.AdditiveMoveParameter.ActualNameChanged += new EventHandler(MoveGenerator_AdditiveMoveParameter_ActualNameChanged);
-        }
-      }
-    }
-    private void UpdateMoveEvaluators() {
-      foreach (ISingleObjectiveTestFunctionMoveEvaluator op in Operators.OfType<ISingleObjectiveTestFunctionMoveEvaluator>().ToList())
-        Operators.Remove(op);
-      foreach (ISingleObjectiveTestFunctionMoveEvaluator op in ApplicationManager.Manager.GetInstances<ISingleObjectiveTestFunctionMoveEvaluator>())
-        if (op.EvaluatorType == Evaluator.GetType()) {
-          Operators.Add(op);
-          #region Synchronize evaluator specific parameters with the parameters of the corresponding move evaluators
-          if (op is ISphereMoveEvaluator) {
-            SphereEvaluator e = (Evaluator as SphereEvaluator);
-            e.AlphaParameter.ValueChanged += new EventHandler(SphereEvaluator_Parameter_ValueChanged);
-            e.CParameter.ValueChanged += new EventHandler(SphereEvaluator_Parameter_ValueChanged);
-            ISphereMoveEvaluator em = (op as ISphereMoveEvaluator);
-            em.C = e.C;
-            em.Alpha = e.Alpha;
-          } else if (op is IRastriginMoveEvaluator) {
-            RastriginEvaluator e = (Evaluator as RastriginEvaluator);
-            e.AParameter.ValueChanged += new EventHandler(RastriginEvaluator_Parameter_ValueChanged);
-            IRastriginMoveEvaluator em = (op as IRastriginMoveEvaluator);
-            em.A = e.A;
-          }
-          #endregion
-        }
-      ParameterizeOperators();
-      OnOperatorsChanged();
-    }
-    private void ParameterizeSolutionCreator() {
-      SolutionCreator.LengthParameter.Value = new IntValue(ProblemSize.Value);
-      SolutionCreator.LengthParameter.Hidden = true;
-      SolutionCreator.BoundsParameter.ActualName = BoundsParameter.Name;
-      SolutionCreator.BoundsParameter.Hidden = true;
-    }
-    private void ParameterizeEvaluator() {
-      Evaluator.PointParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-      Evaluator.PointParameter.Hidden = true;
-      try {
-        BestKnownSolutionParameter.Value = Evaluator.GetBestKnownSolution(ProblemSize.Value);
-      }
-      catch (ArgumentException e) {
-        ErrorHandling.ShowErrorDialog(e);
-        ProblemSize.Value = Evaluator.MinimumProblemSize;
-      }
-    }
-    private void ParameterizeOperators() {
-      foreach (var op in Operators.OfType<IRealVectorCrossover>()) {
-        op.ParentsParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        op.ParentsParameter.Hidden = true;
-        op.ChildParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        op.ChildParameter.Hidden = true;
-        op.BoundsParameter.ActualName = BoundsParameter.Name;
-        op.BoundsParameter.Hidden = true;
-      }
-      foreach (var op in Operators.OfType<IRealVectorManipulator>()) {
-        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        op.RealVectorParameter.Hidden = true;
-        op.BoundsParameter.ActualName = BoundsParameter.Name;
-        op.BoundsParameter.Hidden = true;
-      }
-      foreach (var op in Operators.OfType<IRealVectorMoveOperator>()) {
-        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        op.RealVectorParameter.Hidden = true;
-      }
-      foreach (var op in Operators.OfType<IRealVectorMoveGenerator>()) {
-        op.BoundsParameter.ActualName = BoundsParameter.Name;
-        op.BoundsParameter.Hidden = true;
+      Parameterize();
+    }
+
+    private void Parameterize() {
+      var operators = new List<IItem>();
+      if (BestSingleObjectiveTestFunctionSolutionAnalyzer != null) {
+        operators.Add(BestSingleObjectiveTestFunctionSolutionAnalyzer);
+        BestSingleObjectiveTestFunctionSolutionAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+        BestSingleObjectiveTestFunctionSolutionAnalyzer.BestKnownQualityParameter.ActualName = BestKnownQualityParameter.Name;
+        BestSingleObjectiveTestFunctionSolutionAnalyzer.BestKnownSolutionParameter.ActualName = BestKnownSolutionParameter.Name;
+        BestSingleObjectiveTestFunctionSolutionAnalyzer.MaximizationParameter.ActualName = MaximizationParameter.Name;
+        BestSingleObjectiveTestFunctionSolutionAnalyzer.TestFunctionParameter.ActualName = TestFunctionParameter.Name;
       }
       foreach (var op in Operators.OfType<ISingleObjectiveTestFunctionAdditiveMoveEvaluator>()) {
+        operators.Add(op);
         op.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
         op.QualityParameter.Hidden = true;
-        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        op.RealVectorParameter.Hidden = true;
-      }
-      foreach (var op in Operators.OfType<IRealVectorParticleCreator>()) {
-        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        op.RealVectorParameter.Hidden = true;
-        op.BoundsParameter.ActualName = BoundsParameter.Name;
-        op.BoundsParameter.Hidden = true;
-        op.ProblemSizeParameter.ActualName = ProblemSizeParameter.Name;
-        op.ProblemSizeParameter.Hidden = true;
-      }
-      foreach (var op in Operators.OfType<IRealVectorParticleUpdater>()) {
-        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        op.RealVectorParameter.Hidden = true;
-        op.BoundsParameter.ActualName = BoundsParameter.Name;
-        op.BoundsParameter.Hidden = true;
+        foreach (var movOp in Encoding.Operators.OfType<IRealVectorAdditiveMoveQualityOperator>())
+          movOp.MoveQualityParameter.ActualName = op.MoveQualityParameter.ActualName;
       }
       foreach (var op in Operators.OfType<IRealVectorSwarmUpdater>()) {
-        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        op.RealVectorParameter.Hidden = true;
         op.MaximizationParameter.ActualName = MaximizationParameter.Name;
         op.MaximizationParameter.Hidden = true;
       }
-      foreach (var op in Operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>()) {
-        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        op.RealVectorParameter.Hidden = true;
-      }
       foreach (var op in Operators.OfType<ISingleObjectiveImprovementOperator>()) {
-        op.SolutionParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
+        operators.Add(op);
+        op.SolutionParameter.ActualName = Encoding.Name;
         op.SolutionParameter.Hidden = true;
       }
-      foreach (var op in Operators.OfType<ISingleObjectivePathRelinker>()) {
-        op.ParentsParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        op.ParentsParameter.Hidden = true;
-      }
-      foreach (var op in Operators.OfType<ISolutionSimilarityCalculator>()) {
-        op.SolutionVariableName = SolutionCreator.RealVectorParameter.ActualName;
+      foreach (var op in Operators.OfType<ITestFunctionSolutionSimilarityCalculator>()) {
+        operators.Add(op);
+        op.SolutionVariableName = Encoding.Name;
         op.QualityVariableName = Evaluator.QualityParameter.ActualName;
-        var calc = op as SingleObjectiveTestFunctionSimilarityCalculator;
-        if (calc != null) calc.Bounds = Bounds;
-      }
-    }
-    private void UpdateStrategyVectorBounds() {
-      var strategyBounds = (DoubleMatrix)Bounds.Clone();
-      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;
+        op.Bounds = Bounds;
+      }
+
+      if (operators.Count > 0) Encoding.ConfigureOperators(operators);
     }
     #endregion
@@ -407,5 +211,5 @@
       Name = data.Name;
       Description = data.Description;
-      Evaluator = data.Evaluator;
+      TestFunction = data.TestFunction;
     }
   }
Index: branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionSolution.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionSolution.cs	(revision 13401)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionSolution.cs	(revision 13403)
@@ -97,10 +97,10 @@
 
     [Storable]
-    private ISingleObjectiveTestFunctionProblemEvaluator evaluator;
-    public ISingleObjectiveTestFunctionProblemEvaluator Evaluator {
-      get { return evaluator; }
-      set {
-        if (evaluator != value) {
-          evaluator = value;
+    private ISingleObjectiveTestFunction testFunction;
+    public ISingleObjectiveTestFunction TestFunction {
+      get { return testFunction; }
+      set {
+        if (testFunction != value) {
+          testFunction = value;
           OnEvaluatorChanged();
         }
@@ -130,14 +130,14 @@
       bestQuality = cloner.Clone(original.bestQuality);
       population = cloner.Clone(original.population);
-      evaluator = cloner.Clone(original.evaluator);
+      testFunction = cloner.Clone(original.testFunction);
       bounds = cloner.Clone(original.bounds);
       Initialize();
     }
     public SingleObjectiveTestFunctionSolution() : base() { }
-    public SingleObjectiveTestFunctionSolution(RealVector realVector, DoubleValue quality, ISingleObjectiveTestFunctionProblemEvaluator evaluator)
+    public SingleObjectiveTestFunctionSolution(RealVector realVector, DoubleValue quality, ISingleObjectiveTestFunction testFunction)
       : base() {
       this.bestRealVector = realVector;
       this.bestQuality = quality;
-      this.evaluator = evaluator;
+      this.testFunction = testFunction;
       Initialize();
     }
