Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Analyzers/BestSingleObjectiveTestFunctionSolutionAnalyzer.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Analyzers/BestSingleObjectiveTestFunctionSolutionAnalyzer.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Analyzers/BestSingleObjectiveTestFunctionSolutionAnalyzer.cs	(revision 9875)
@@ -0,0 +1,158 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// An operator for analyzing the best solution for a SingleObjectiveTestFunction problem.
+  /// </summary>
+  [Item("BestSingleObjectiveTestFunctionSolutionAnalyzer", "An operator for analyzing the best solution for a SingleObjectiveTestFunction problem.")]
+  [StorableClass]
+  class BestSingleObjectiveTestFunctionSolutionAnalyzer : SingleSuccessorOperator, IBestSingleObjectiveTestFunctionSolutionAnalyzer, IAnalyzer {
+    public virtual bool EnabledByDefault {
+      get { return true; }
+    }
+
+    public LookupParameter<BoolValue> MaximizationParameter {
+      get { return (LookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ScopeTreeLookupParameter<RealVector> RealVectorParameter {
+      get { return (ScopeTreeLookupParameter<RealVector>)Parameters["RealVector"]; }
+    }
+    ILookupParameter IBestSingleObjectiveTestFunctionSolutionAnalyzer.RealVectorParameter {
+      get { return RealVectorParameter; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    ILookupParameter IBestSingleObjectiveTestFunctionSolutionAnalyzer.QualityParameter {
+      get { return QualityParameter; }
+    }
+    public ILookupParameter<SingleObjectiveTestFunctionSolution> BestSolutionParameter {
+      get { return (ILookupParameter<SingleObjectiveTestFunctionSolution>)Parameters["BestSolution"]; }
+    }
+    public ILookupParameter<RealVector> BestKnownSolutionParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["BestKnownSolution"]; }
+    }
+    public ILookupParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
+    }
+    public IValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+    public IValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator> EvaluatorParameter {
+      get { return (IValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator>)Parameters["Evaluator"]; }
+    }
+    public ILookupParameter<DoubleMatrix> BoundsParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
+
+    [StorableConstructor]
+    protected BestSingleObjectiveTestFunctionSolutionAnalyzer(bool deserializing) : base(deserializing) { }
+    protected BestSingleObjectiveTestFunctionSolutionAnalyzer(BestSingleObjectiveTestFunctionSolutionAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public BestSingleObjectiveTestFunctionSolutionAnalyzer()
+      : 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<DoubleValue>("Quality", "The qualities of the SingleObjectiveTestFunction solutions which should be visualized."));
+      Parameters.Add(new LookupParameter<SingleObjectiveTestFunctionSolution>("BestSolution", "The best SingleObjectiveTestFunction solution."));
+      Parameters.Add(new LookupParameter<RealVector>("BestKnownSolution", "The best known solution."));
+      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."));
+
+      MaximizationParameter.Hidden = true;
+      RealVectorParameter.Hidden = true;
+      QualityParameter.Hidden = true;
+      BestSolutionParameter.Hidden = true;
+      BestKnownSolutionParameter.Hidden = true;
+      BestKnownQualityParameter.Hidden = true;
+      ResultsParameter.Hidden = true;
+      EvaluatorParameter.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."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BestSingleObjectiveTestFunctionSolutionAnalyzer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemArray<RealVector> realVectors = RealVectorParameter.ActualValue;
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
+      bool max = MaximizationParameter.ActualValue.Value;
+      DoubleValue bestKnownQuality = BestKnownQualityParameter.ActualValue;
+      SingleObjectiveTestFunctionSolution solution = BestSolutionParameter.ActualValue;
+
+      int i = -1;
+      if (!max) i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
+      else i = qualities.Select((x, index) => new { index, x.Value }).OrderByDescending(x => x.Value).First().index;
+
+      if (bestKnownQuality == null ||
+          max && qualities[i].Value > bestKnownQuality.Value
+          || !max && qualities[i].Value < bestKnownQuality.Value) {
+        BestKnownQualityParameter.ActualValue = new DoubleValue(qualities[i].Value);
+        BestKnownSolutionParameter.ActualValue = (RealVector)realVectors[i].Clone();
+        if (solution != null)
+          solution.BestKnownRealVector = BestKnownSolutionParameter.ActualValue;
+      }
+
+      if (solution == null) {
+        ResultCollection results = ResultsParameter.ActualValue;
+        solution = new SingleObjectiveTestFunctionSolution(realVectors[i], qualities[i], EvaluatorParameter.ActualValue);
+        solution.Population = realVectors[i].Length == 2 ? realVectors : null;
+        solution.BestKnownRealVector = BestKnownSolutionParameter.ActualValue;
+        solution.Bounds = BoundsParameter.ActualValue;
+        BestSolutionParameter.ActualValue = solution;
+        results.Add(new Result("Best Solution", solution));
+      } else {
+        if (max && qualities[i].Value > solution.BestQuality.Value
+          || !max && qualities[i].Value < solution.BestQuality.Value) {
+          solution.BestRealVector = realVectors[i];
+          solution.BestQuality = qualities[i];
+        }
+        solution.Population = realVectors[i].Length == 2 ? realVectors : null;
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/AckleyEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/AckleyEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/AckleyEvaluator.cs	(revision 9875)
@@ -0,0 +1,115 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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("AckleyEvaluator", "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 AckleyEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    /// <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 AckleyEvaluator(bool deserializing) : base(deserializing) { }
+    protected AckleyEvaluator(AckleyEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public AckleyEvaluator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AckleyEvaluator(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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/BealeEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/BealeEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/BealeEvaluator.cs	(revision 9875)
@@ -0,0 +1,104 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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("BealeEvaluator", "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 BealeEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    /// <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 BealeEvaluator(bool deserializing) : base(deserializing) { }
+    protected BealeEvaluator(BealeEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public BealeEvaluator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BealeEvaluator(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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/BoothEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/BoothEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/BoothEvaluator.cs	(revision 9875)
@@ -0,0 +1,100 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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("BoothEvaluator", "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 BoothEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    /// <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 BoothEvaluator(bool deserializing) : base(deserializing) { }
+    protected BoothEvaluator(BoothEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public BoothEvaluator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BoothEvaluator(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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/GriewankEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/GriewankEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/GriewankEvaluator.cs	(revision 9875)
@@ -0,0 +1,149 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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("GriewankEvaluator", "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 GriewankEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    /// <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 GriewankEvaluator(bool deserializing) : base(deserializing) { }
+    protected GriewankEvaluator(GriewankEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public GriewankEvaluator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GriewankEvaluator(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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/LevyEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/LevyEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/LevyEvaluator.cs	(revision 9875)
@@ -0,0 +1,117 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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("LevyEvaluator", "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 LevyEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    /// <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 LevyEvaluator(bool deserializing) : base(deserializing) { }
+    protected LevyEvaluator(LevyEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public LevyEvaluator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LevyEvaluator(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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/MatyasEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/MatyasEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/MatyasEvaluator.cs	(revision 9875)
@@ -0,0 +1,99 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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("MatyasEvaluator", "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 MatyasEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    /// <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 MatyasEvaluator(bool deserializing) : base(deserializing) { }
+    protected MatyasEvaluator(MatyasEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public MatyasEvaluator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MatyasEvaluator(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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/MultinormalEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/MultinormalEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/MultinormalEvaluator.cs	(revision 9875)
@@ -0,0 +1,179 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;
+
+namespace HeuristicLab.Problems.TestFunctions.Evaluators {
+  [Item("MultinormalFunction", "Evaluates a random multinormal function on a given point.")]
+  [StorableClass]
+  public class MultinormalEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+
+    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; }
+    }
+    private static System.Random Random = new System.Random();
+
+    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 MultinormalEvaluator(bool deserializing) : base(deserializing) { }
+    protected MultinormalEvaluator(MultinormalEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public MultinormalEvaluator() {
+      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 LookupParameter<IRandom>("Random", "Random number generator"));
+      centers = new ItemList<RealVector>();
+      s_2s = new RealVector();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultinormalEvaluator(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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/RandomEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/RandomEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/RandomEvaluator.cs	(revision 9875)
@@ -0,0 +1,92 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// A function that returns a random variable in [0;1) independent of the inputs.
+  /// </summary
+  [Item("RandomEvaluator", "Returns a random value in [0;1) that is independent of the inputs.")]
+  [StorableClass]
+  public class RandomEvaluator : SingleObjectiveTestFunctionProblemEvaluator, IStochasticOperator {
+    /// <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 ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    [StorableConstructor]
+    protected RandomEvaluator(bool deserializing) : base(deserializing) { }
+    protected RandomEvaluator(RandomEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public RandomEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RandomEvaluator(this, cloner);
+    }
+
+    public override RealVector GetBestKnownSolution(int dimension) {
+      return new RealVector(dimension);
+    }
+
+    public override double Evaluate(RealVector point) {
+      return ExecutionContext == null ? new System.Random().NextDouble() : RandomParameter.ActualValue.NextDouble();
+    }
+  }
+}
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/RastriginEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/RastriginEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/RastriginEvaluator.cs	(revision 9875)
@@ -0,0 +1,125 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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("RastriginEvaluator", "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 RastriginEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    /// <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 RastriginEvaluator(bool deserializing) : base(deserializing) { }
+    protected RastriginEvaluator(RastriginEvaluator original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of the RastriginEvaluator with one parameter (<c>A</c>).
+    /// </summary>
+    public RastriginEvaluator()
+      : 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 RastriginEvaluator(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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/RosenbrockEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/RosenbrockEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/RosenbrockEvaluator.cs	(revision 9875)
@@ -0,0 +1,111 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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("RosenbrockEvaluator", @"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 RosenbrockEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    /// <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 RosenbrockEvaluator(bool deserializing) : base(deserializing) { }
+    protected RosenbrockEvaluator(RosenbrockEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public RosenbrockEvaluator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RosenbrockEvaluator(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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SchwefelEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SchwefelEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SchwefelEvaluator.cs	(revision 9875)
@@ -0,0 +1,102 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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("SchwefelEvaluator", "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 SchwefelEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    /// <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 SchwefelEvaluator(bool deserializing) : base(deserializing) { }
+    protected SchwefelEvaluator(SchwefelEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public SchwefelEvaluator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SchwefelEvaluator(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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SingleObjectiveTestFunctionProblemEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SingleObjectiveTestFunctionProblemEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SingleObjectiveTestFunctionProblemEvaluator.cs	(revision 9875)
@@ -0,0 +1,107 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// Base class for a test function evaluator.
+  /// </summary>
+  [Item("Evaluator", "Base calls for single objective test function evaluators.")]
+  [StorableClass]
+  public abstract class SingleObjectiveTestFunctionProblemEvaluator : SingleSuccessorOperator, ISingleObjectiveTestFunctionProblemEvaluator {
+    /// <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; }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<RealVector> PointParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["Point"]; }
+    }
+
+    [StorableConstructor]
+    protected SingleObjectiveTestFunctionProblemEvaluator(bool deserializing) : base(deserializing) { }
+    protected SingleObjectiveTestFunctionProblemEvaluator(SingleObjectiveTestFunctionProblemEvaluator original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="SingleObjectiveTestFunctionEvaluator"/> with two parameters
+    /// (<c>Quality</c> and <c>Point</c>).
+    /// </summary>
+    public SingleObjectiveTestFunctionProblemEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "Result of the evaluation of a solution."));
+      Parameters.Add(new LookupParameter<RealVector>("Point", "The point at which the function should be evaluated."));
+    }
+
+    public override IOperation Apply() {
+      RealVector point = PointParameter.ActualValue;
+      double quality = Evaluate(point);
+      QualityParameter.ActualValue = new DoubleValue(quality);
+      return base.Apply();
+    }
+
+    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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SphereEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SphereEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SphereEvaluator.cs	(revision 9875)
@@ -0,0 +1,138 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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("SphereEvaluator", "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 SphereEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    /// <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 SphereEvaluator(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 SphereEvaluator(bool deserializing) : base(deserializing) { }
+    protected SphereEvaluator(SphereEvaluator 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 SphereEvaluator()
+      : 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SumSquaresEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SumSquaresEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/SumSquaresEvaluator.cs	(revision 9875)
@@ -0,0 +1,102 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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("SumSquaresEvaluator", "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 SumSquaresEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    /// <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 SumSquaresEvaluator(bool deserializing) : base(deserializing) { }
+    protected SumSquaresEvaluator(SumSquaresEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public SumSquaresEvaluator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SumSquaresEvaluator(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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/ZakharovEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/ZakharovEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Evaluators/ZakharovEvaluator.cs	(revision 9875)
@@ -0,0 +1,106 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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("ZakharovEvaluator", "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 ZakharovEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    /// <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 ZakharovEvaluator(bool deserializing) : base(deserializing) { }
+    protected ZakharovEvaluator(ZakharovEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public ZakharovEvaluator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ZakharovEvaluator(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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/HeuristicLab.Problems.TestFunctions-3.3.csproj
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/HeuristicLab.Problems.TestFunctions-3.3.csproj	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/HeuristicLab.Problems.TestFunctions-3.3.csproj	(revision 9875)
@@ -0,0 +1,271 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{88B9B0E3-344E-4196-82A3-0F9732506FE8}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Problems.TestFunctions</RootNamespace>
+    <AssemblyName>HeuristicLab.Problems.TestFunctions-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
+    <FileAlignment>512</FileAlignment>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <UpgradeBackupLocation />
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Xml.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data.DataSetExtensions">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Evaluators\RandomEvaluator.cs" />
+    <Compile Include="Improvers\SingleObjectiveTestFunctionImprovementOperator.cs" />
+    <Compile Include="MoveEvaluators\RandomAdditiveMoveEvaluator.cs" />
+    <Compile Include="PathRelinkers\SingleObjectiveTestFunctionPathRelinker.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Analyzers\BestSingleObjectiveTestFunctionSolutionAnalyzer.cs">
+      <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="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\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" />
+    <Compile Include="SingleObjectiveTestFunctionProblem.cs" />
+    <None Include="HeuristicLab.snk" />
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Analysis\3.3\HeuristicLab.Analysis-3.3.csproj">
+      <Project>{887425B4-4348-49ED-A457-B7D2C26DDBF9}</Project>
+      <Name>HeuristicLab.Analysis-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common.Resources\3.3\HeuristicLab.Common.Resources-3.3.csproj">
+      <Project>{0E27A536-1C4A-4624-A65E-DC4F4F23E3E1}</Project>
+      <Name>HeuristicLab.Common.Resources-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
+      <Project>{A9AD58B9-3EF9-4CC1-97E5-8D909039FF5C}</Project>
+      <Name>HeuristicLab.Common-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
+      <Project>{BBAB9DF5-5EF3-4BA8-ADE9-B36E82114937}</Project>
+      <Name>HeuristicLab.Data-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.RealVectorEncoding\3.3\HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj">
+      <Project>{BB6D334A-4BB6-4674-9883-31A6EBB32CAB}</Project>
+      <Name>HeuristicLab.Encodings.RealVectorEncoding-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Operators\3.3\HeuristicLab.Operators-3.3.csproj">
+      <Project>{23DA7FF4-D5B8-41B6-AA96-F0561D24F3EE}</Project>
+      <Name>HeuristicLab.Operators-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization.Operators\3.3\HeuristicLab.Optimization.Operators-3.3.csproj">
+      <Project>{25087811-F74C-4128-BC86-8324271DA13E}</Project>
+      <Name>HeuristicLab.Optimization.Operators-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
+      <Project>{14AB8D24-25BC-400C-A846-4627AA945192}</Project>
+      <Name>HeuristicLab.Optimization-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">
+      <Project>{56F9106A-079F-4C61-92F6-86A84C2D84B7}</Project>
+      <Name>HeuristicLab.Parameters-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
+      <Project>{102BC7D3-0EF9-439C-8F6D-96FF0FDB8E1B}</Project>
+      <Name>HeuristicLab.Persistence-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
+      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
+      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 3.1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <PropertyGroup>
+    <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+</PreBuildEvent>
+    <PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
+export ProjectDir=$(ProjectDir)
+export SolutionDir=$(SolutionDir)
+
+$SolutionDir/PreBuildEvent.sh
+</PreBuildEvent>
+  </PropertyGroup>
+</Project>
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Improvers/SingleObjectiveTestFunctionImprovementOperator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Improvers/SingleObjectiveTestFunctionImprovementOperator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Improvers/SingleObjectiveTestFunctionImprovementOperator.cs	(revision 9875)
@@ -0,0 +1,204 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// An operator that improves test functions solutions.
+  /// </summary>
+  /// <remarks>
+  /// 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.<br />
+  /// The operator uses an implementation of the Nelder-Mead method with adaptive parameters as described in Gao, F. and Han, L. (2010). Implementing the Nelder-Mead simplex algorithm with adaptive parameters. Computational Optimization and Applications, Vol. 51. Springer. and conducts relection, expansion, contraction and reduction on the test functions solution.
+  /// </remarks>
+  [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 {
+    #region Parameter properties
+    public IValueParameter<DoubleValue> AlphaParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["Alpha"]; }
+    }
+    public IValueParameter<DoubleValue> BetaParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["Beta"]; }
+    }
+    public IValueLookupParameter<DoubleMatrix> BoundsParameter {
+      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 IValueParameter<DoubleValue> GammaParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["Gamma"]; }
+    }
+    public IValueLookupParameter<IntValue> ImprovementAttemptsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["ImprovementAttempts"]; }
+    }
+    public IValueLookupParameter<IItem> SolutionParameter {
+      get { return (IValueLookupParameter<IItem>)Parameters["Solution"]; }
+    }
+    #endregion
+
+    #region Properties
+    private DoubleValue Alpha {
+      get { return AlphaParameter.Value; }
+    }
+    private DoubleValue Beta {
+      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
+
+    [StorableConstructor]
+    private SingleObjectiveTestFunctionImprovementOperator(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveTestFunctionImprovementOperator(SingleObjectiveTestFunctionImprovementOperator original, Cloner cloner) : base(original, cloner) { }
+    public SingleObjectiveTestFunctionImprovementOperator()
+      : base() {
+      #region Create parameters
+      Parameters.Add(new ValueParameter<DoubleValue>("Alpha", new DoubleValue(1.0)));
+      Parameters.Add(new ValueParameter<DoubleValue>("Beta", new DoubleValue(2.0)));
+      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."));
+      #endregion
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveTestFunctionImprovementOperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      RealVector bestSol = CurrentScope.Variables[SolutionParameter.ActualName].Value as RealVector;
+      if (bestSol == null)
+        throw new ArgumentException("Cannot improve solution because it has the wrong type.");
+
+      var evaluator = Evaluator;
+
+      double bestSolQuality = evaluator.Evaluate(bestSol);
+
+      // create perturbed solutions
+      RealVector[] simplex = new RealVector[bestSol.Length];
+      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];
+      }
+
+      // improve solutions
+      for (int i = 0; i < ImprovementAttempts.Value; i++) {
+        // order according to their objective function value
+        Array.Sort(simplex, (x, y) => evaluator.Evaluate(x).CompareTo(evaluator.Evaluate(y)));
+
+        // calculate centroid
+        RealVector centroid = new RealVector(bestSol.Length);
+        foreach (var vector in simplex)
+          for (int j = 0; j < centroid.Length; j++)
+            centroid[j] += vector[j];
+        for (int j = 0; j < centroid.Length; j++)
+          centroid[j] /= simplex.Length;
+
+        // reflection
+        RealVector reflectionPoint = new RealVector(bestSol.Length);
+        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]))
+          simplex[simplex.Length - 1] = reflectionPoint;
+
+        // expansion
+        if (reflectionPointQuality < evaluator.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;
+        }
+
+        // contraction
+        if (evaluator.Evaluate(simplex[simplex.Length - 2]) <= reflectionPointQuality
+            && reflectionPointQuality < evaluator.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) {
+            simplex[simplex.Length - 1] = outsideContractionPoint;
+            if (evaluator.Evaluate(reflectionPoint) >= evaluator.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;
+            }
+          }
+        }
+
+        // reduction
+        for (int j = 1; j < simplex.Length; j++)
+          for (int k = 0; k < simplex[j].Length; k++)
+            simplex[j][k] = simplex[0][k] + Delta.Value * (simplex[j][k] - simplex[0][k]);
+      }
+
+      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];
+      }
+
+      CurrentScope.Variables[SolutionParameter.ActualName].Value = simplex[0];
+      CurrentScope.Variables.Add(new Variable("LocalEvaluatedSolutions", ImprovementAttempts));
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IBestSingleObjectiveTestFunctionSolutionAnalyzer.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IBestSingleObjectiveTestFunctionSolutionAnalyzer.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IBestSingleObjectiveTestFunctionSolutionAnalyzer.cs	(revision 9875)
@@ -0,0 +1,35 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// 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 {
+    ILookupParameter RealVectorParameter { get; }
+    ILookupParameter QualityParameter { get; }
+    ILookupParameter<SingleObjectiveTestFunctionSolution> BestSolutionParameter { get; }
+    IValueLookupParameter<ResultCollection> ResultsParameter { get; }
+  }
+}
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IRastriginMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IRastriginMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IRastriginMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,28 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,27 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  public interface ISingleObjectiveTestFunctionAdditiveMoveEvaluator : ISingleObjectiveTestFunctionMoveEvaluator, IAdditiveRealVectorMoveOperator {
+  }
+}
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Optimization;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  public interface ISingleObjectiveTestFunctionMoveEvaluator : ISingleObjectiveMoveEvaluator, IMoveOperator {
+    Type EvaluatorType { get; }
+  }
+}
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionProblemEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionProblemEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionProblemEvaluator.cs	(revision 9875)
@@ -0,0 +1,44 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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; }
+
+    ILookupParameter<RealVector> PointParameter { get; }
+
+    double Evaluate2D(double x, double y);
+    double Evaluate(RealVector point);
+    RealVector GetBestKnownSolution(int dimension);
+  }
+}
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionProblemSolutionsVisualizer.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionProblemSolutionsVisualizer.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionProblemSolutionsVisualizer.cs	(revision 9875)
@@ -0,0 +1,33 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// An interface which represents an operator for visualizing solutions of single objective test functions.
+  /// </summary>
+  public interface ISingleObjectiveTestFunctionProblemSolutionsVisualizer : IAnalyzer {
+    ILookupParameter<RealVector> PointParameter { get; }
+  }
+}
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISphereMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISphereMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISphereMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/AckleyAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/AckleyAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/AckleyAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/AdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/AdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/AdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,76 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("AdditiveMoveEvaluator", "Base class for evaluating an additive move.")]
+  [StorableClass]
+  public abstract class AdditiveMoveEvaluator : SingleSuccessorOperator, ISingleObjectiveTestFunctionAdditiveMoveEvaluator {
+
+    public abstract Type EvaluatorType { get; }
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<RealVector> RealVectorParameter {
+      get { return (ILookupParameter<RealVector>)Parameters["Point"]; }
+    }
+    public ILookupParameter<AdditiveMove> AdditiveMoveParameter {
+      get { return (ILookupParameter<AdditiveMove>)Parameters["AdditiveMove"]; }
+    }
+
+    [StorableConstructor]
+    protected AdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected AdditiveMoveEvaluator(AdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    protected AdditiveMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of a test function solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The evaluated quality of a move on a test function solution."));
+      Parameters.Add(new LookupParameter<RealVector>("Point", "The point to evaluate the move on."));
+      Parameters.Add(new LookupParameter<AdditiveMove>("AdditiveMove", "The move to evaluate."));
+    }
+
+    public override IOperation Apply() {
+      double mq = Evaluate(QualityParameter.ActualValue.Value, RealVectorParameter.ActualValue, AdditiveMoveParameter.ActualValue);
+      DoubleValue moveQuality = MoveQualityParameter.ActualValue;
+      if (moveQuality == null) {
+        MoveQualityParameter.ActualValue = new DoubleValue(mq);
+      } else moveQuality.Value = mq;
+      return base.Apply();
+    }
+
+    protected abstract double Evaluate(double quality, RealVector point, AdditiveMove move);
+  }
+}
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/BealeAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/BealeAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/BealeAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/BoothAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/BoothAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/BoothAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/GriewankAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/GriewankAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/GriewankAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/LevyAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/LevyAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/LevyAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/MatyasAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/MatyasAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/MatyasAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/MultinormalAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/MultinormalAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/MultinormalAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,61 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RandomAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RandomAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RandomAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,56 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RastriginAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RastriginAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RastriginAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,66 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RealVectorAdditiveMoveWrapper.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RealVectorAdditiveMoveWrapper.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RealVectorAdditiveMoveWrapper.cs	(revision 9875)
@@ -0,0 +1,76 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RosenbrockAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RosenbrockAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/RosenbrockAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SchwefelAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SchwefelAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SchwefelAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SphereAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SphereAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SphereAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,81 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SumSquaresAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SumSquaresAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/SumSquaresAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/ZakharovAdditiveMoveEvaluator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/ZakharovAdditiveMoveEvaluator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/ZakharovAdditiveMoveEvaluator.cs	(revision 9875)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/PathRelinkers/SingleObjectiveTestFunctionPathRelinker.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/PathRelinkers/SingleObjectiveTestFunctionPathRelinker.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/PathRelinkers/SingleObjectiveTestFunctionPathRelinker.cs	(revision 9875)
@@ -0,0 +1,108 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// An operator that relinks paths between test functions solutions.
+  /// </summary>
+  /// <remarks>
+  /// It is based on an implementation described in Duarte, A., Martí, R., and Gortazar, F. (2011). Path Relinking for Large Scale Global Optimization. Soft Computing, Vol. 15.<br />
+  /// The operator incrementally assimilates the initiating solution into the guiding solution by adapting the solution vector's elements.
+  /// </remarks>
+  [Item("SingleObjectiveTestFunctionPathRelinker", "An operator that relinks paths between test functions solutions. It is based on an implementation described in Duarte, A., Martí, R., and Gortazar, F. (2011). Path Relinking for Large Scale Global Optimization. Soft Computing, Vol. 15.")]
+  [StorableClass]
+  public sealed class SingleObjectiveTestFunctionPathRelinker : SingleObjectivePathRelinker {
+    #region Parameter properties
+    public IValueParameter<IntValue> RelinkingIntensityParameter {
+      get { return (IValueParameter<IntValue>)Parameters["RelinkingIntensity"]; }
+    }
+    #endregion
+
+    #region Properties
+    private IntValue RelinkingIntensity {
+      get { return RelinkingIntensityParameter.Value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private SingleObjectiveTestFunctionPathRelinker(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveTestFunctionPathRelinker(SingleObjectiveTestFunctionPathRelinker original, Cloner cloner) : base(original, cloner) { }
+    public SingleObjectiveTestFunctionPathRelinker()
+      : base() {
+      #region Create parameters
+      Parameters.Add(new ValueParameter<IntValue>("RelinkingIntensity", "Determines how strong path relinking should be applied.", new IntValue(10)));
+      #endregion
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveTestFunctionPathRelinker(this, cloner);
+    }
+
+    public static ItemArray<IItem> Apply(IItem initiator, IItem guide, IntValue k, PercentValue n) {
+      if (!(initiator is RealVector) || !(guide is RealVector))
+        throw new ArgumentException("Cannot relink path because one of the provided solutions or both have the wrong type.");
+      if (n.Value <= 0.0)
+        throw new ArgumentException("RelinkingAccuracy must be greater than 0.");
+
+      RealVector v1 = initiator.Clone() as RealVector;
+      RealVector v2 = guide as RealVector;
+
+      if (v1.Length != v2.Length)
+        throw new ArgumentException("The solutions are of different length.");
+
+      IList<RealVector> solutions = new List<RealVector>();
+      for (int i = 0; i < k.Value; i++) {
+        RealVector solution = v1.Clone() as RealVector;
+        for (int j = 0; j < solution.Length; j++)
+          solution[j] = v1[j] + 1 / (k.Value - i) * (v2[j] - v1[j]);
+        solutions.Add(solution);
+      }
+
+      IList<IItem> selection = new List<IItem>();
+      if (solutions.Count > 0) {
+        int noSol = (int)(solutions.Count * n.Value);
+        if (noSol <= 0) noSol++;
+        double stepSize = (double)solutions.Count / (double)noSol;
+        for (int i = 0; i < noSol; i++)
+          selection.Add(solutions.ElementAt((int)((i + 1) * stepSize - stepSize * 0.5)));
+      }
+
+      return new ItemArray<IItem>(selection);
+    }
+
+    protected override ItemArray<IItem> Relink(ItemArray<IItem> parents, PercentValue n) {
+      if (parents.Length != 2)
+        throw new ArgumentException("The number of parents is not equal to 2.");
+      return Apply(parents[0], parents[1], RelinkingIntensity, n);
+    }
+  }
+}
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Plugin.cs.frame
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Plugin.cs.frame	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Plugin.cs.frame	(revision 9875)
@@ -0,0 +1,44 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Problems.TestFunctions plugin
+  /// </summary>
+  [Plugin("HeuristicLab.Problems.TestFunctions", "3.3.8.$WCREV$")]
+  [PluginFile("HeuristicLab.Problems.TestFunctions-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Analysis", "3.3")]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Encodings.RealVectorEncoding", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  public class HeuristicLabProblemsTestFunctionsPlugin : PluginBase {
+  }
+}
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Properties/AssemblyInfo.cs.frame	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/Properties/AssemblyInfo.cs.frame	(revision 9875)
@@ -0,0 +1,55 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Problems.TestFunctions")]
+[assembly: AssemblyDescription("HeuristicLab Test Functions classes")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2013 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("4da1bc61-4f7d-4e4e-af09-a6940ea88a5a")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.8.$WCREV$")]
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/RealVectorToRealVectorEncoder.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/RealVectorToRealVectorEncoder.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/RealVectorToRealVectorEncoder.cs	(revision 9875)
@@ -0,0 +1,54 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/SimilarityCalculators/SingleObjectiveTestFunctionSimilarityCalculator.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/SimilarityCalculators/SingleObjectiveTestFunctionSimilarityCalculator.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/SimilarityCalculators/SingleObjectiveTestFunctionSimilarityCalculator.cs	(revision 9875)
@@ -0,0 +1,86 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Optimization.Operators;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// An operator that performs similarity calculation between two test functions solutions.
+  /// </summary>
+  /// <remarks>
+  /// The operator calculates the similarity based on the euclidean distance of the two solutions in n-dimensional space.
+  /// </remarks>
+  [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 {
+    #region Properties
+    [Storable]
+    public DoubleMatrix Bounds { get; set; }
+    #endregion
+
+    [StorableConstructor]
+    private SingleObjectiveTestFunctionSimilarityCalculator(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveTestFunctionSimilarityCalculator(SingleObjectiveTestFunctionSimilarityCalculator original, Cloner cloner)
+      : base(original, cloner) {
+      this.Bounds = cloner.Clone(original.Bounds);
+    }
+    public SingleObjectiveTestFunctionSimilarityCalculator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveTestFunctionSimilarityCalculator(this, cloner);
+    }
+
+    public static double CalculateSimilarity(RealVector left, RealVector right, DoubleMatrix bounds) {
+      if (left == null || right == null)
+        throw new ArgumentException("Cannot calculate similarity because one of the provided solutions or both are null.");
+      if (bounds == null)
+        throw new ArgumentException("Cannot calculate similarity because no bounds were provided.");
+      if (left.Length != right.Length)
+        throw new ArgumentException("Cannot calculate similarity because the provided solutions have different lengths.");
+      if (left == right) return 1.0;
+
+      double maxSum = 0.0;
+      for (int i = 0; i < left.Length; i++)
+        maxSum += Math.Pow(bounds[0, 0] - bounds[0, 1], 2);
+      double maxDistance = Math.Sqrt(maxSum) / left.Length;
+
+      double sum = 0.0;
+      for (int i = 0; i < left.Length; i++)
+        sum += Math.Pow(left[i] - right[i], 2);
+      double distance = Math.Sqrt(sum) / left.Length;
+
+      return 1.0 - distance / maxDistance;
+    }
+
+    public override double CalculateSolutionSimilarity(IScope leftSolution, IScope rightSolution) {
+      var sol1 = leftSolution.Variables[SolutionVariableName].Value as RealVector;
+      var sol2 = rightSolution.Variables[SolutionVariableName].Value as RealVector;
+
+      return CalculateSimilarity(sol1, sol2, Bounds);
+    }
+  }
+}
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs	(revision 9875)
@@ -0,0 +1,409 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  [Item("Single Objective Test Function", "Test function with real valued inputs and a single objective.")]
+  [StorableClass]
+  [Creatable("Problems")]
+  public sealed class SingleObjectiveTestFunctionProblem : SingleObjectiveHeuristicOptimizationProblem<ISingleObjectiveTestFunctionProblemEvaluator, IRealVectorCreator>, IStorableContent {
+    public string Filename { get; set; }
+
+    [Storable]
+    private StdDevStrategyVectorCreator strategyVectorCreator;
+    [Storable]
+    private StdDevStrategyVectorCrossover strategyVectorCrossover;
+    [Storable]
+    private StdDevStrategyVectorManipulator strategyVectorManipulator;
+
+    #region Parameter Properties
+    public ValueParameter<DoubleMatrix> BoundsParameter {
+      get { return (ValueParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
+    public ValueParameter<IntValue> ProblemSizeParameter {
+      get { return (ValueParameter<IntValue>)Parameters["ProblemSize"]; }
+    }
+    public OptionalValueParameter<RealVector> BestKnownSolutionParameter {
+      get { return (OptionalValueParameter<RealVector>)Parameters["BestKnownSolution"]; }
+    }
+    #endregion
+
+    #region Properties
+    public DoubleMatrix Bounds {
+      get { return BoundsParameter.Value; }
+      set { BoundsParameter.Value = value; }
+    }
+    public IntValue ProblemSize {
+      get { return ProblemSizeParameter.Value; }
+      set { ProblemSizeParameter.Value = value; }
+    }
+    private BestSingleObjectiveTestFunctionSolutionAnalyzer BestSingleObjectiveTestFunctionSolutionAnalyzer {
+      get { return Operators.OfType<BestSingleObjectiveTestFunctionSolutionAnalyzer>().FirstOrDefault(); }
+    }
+    private SingleObjectivePopulationDiversityAnalyzer SingleObjectivePopulationDiversityAnalyzer {
+      get { return Operators.OfType<SingleObjectivePopulationDiversityAnalyzer>().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
+
+    [StorableConstructor]
+    private SingleObjectiveTestFunctionProblem(bool deserializing) : base(deserializing) { }
+    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)));
+      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();
+
+      InitializeOperators();
+      RegisterEventHandlers();
+      UpdateStrategyVectorBounds();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveTestFunctionProblem(this, cloner);
+    }
+
+    #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 OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
+      bool problemSizeChange = ProblemSize.Value < Evaluator.MinimumProblemSize
+        || ProblemSize.Value > Evaluator.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);
+      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;
+    }
+    #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;
+      }
+
+      if (SingleObjectivePopulationDiversityAnalyzer != null) {
+        SingleObjectivePopulationDiversityAnalyzer.MaximizationParameter.ActualName = MaximizationParameter.Name;
+        SingleObjectivePopulationDiversityAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+        SingleObjectivePopulationDiversityAnalyzer.ResultsParameter.ActualName = "Results";
+        SingleObjectivePopulationDiversityAnalyzer.SimilarityCalculator = Operators.OfType<SingleObjectiveTestFunctionSimilarityCalculator>().SingleOrDefault();
+      }
+    }
+    private void InitializeOperators() {
+      Operators.Add(new SingleObjectiveTestFunctionImprovementOperator());
+      Operators.Add(new SingleObjectiveTestFunctionPathRelinker());
+      Operators.Add(new SingleObjectiveTestFunctionSimilarityCalculator());
+
+      Operators.Add(new BestSingleObjectiveTestFunctionSolutionAnalyzer());
+      Operators.Add(new SingleObjectivePopulationDiversityAnalyzer());
+      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;
+      }
+      foreach (var op in Operators.OfType<ISingleObjectiveTestFunctionAdditiveMoveEvaluator>()) {
+        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 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;
+        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<SingleObjectiveTestFunctionSimilarityCalculator>()) {
+        op.SolutionVariableName = SolutionCreator.RealVectorParameter.ActualName;
+        op.QualityVariableName = Evaluator.QualityParameter.ActualName;
+        op.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;
+    }
+    #endregion
+  }
+}
Index: /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionSolution.cs
===================================================================
--- /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionSolution.cs	(revision 9875)
+++ /branches/TestFunctionInstances/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionSolution.cs	(revision 9875)
@@ -0,0 +1,278 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2013 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.Drawing;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.TestFunctions {
+  /// <summary>
+  /// Represents a SingleObjectiveTestFunctionSolution solution.
+  /// </summary>
+  [Item("SingleObjectiveTestFunctionSolution", "Represents a SingleObjectiveTestFunction solution.")]
+  [StorableClass]
+  public class SingleObjectiveTestFunctionSolution : Item {
+    public static new Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Image; }
+    }
+
+    [Storable]
+    private RealVector bestKnownRealVector;
+    public RealVector BestKnownRealVector {
+      get { return bestKnownRealVector; }
+      set {
+        if (bestKnownRealVector != value) {
+          if (bestKnownRealVector != null) DeregisterBestKnownRealVectorEvents();
+          bestKnownRealVector = value;
+          if (bestKnownRealVector != null) RegisterBestKnownRealVectorEvents();
+          OnBestKnownRealVectorChanged();
+        }
+      }
+    }
+
+    [Storable]
+    private RealVector bestRealVector;
+    public RealVector BestRealVector {
+      get { return bestRealVector; }
+      set {
+        if (bestRealVector != value) {
+          if (bestRealVector != null) DeregisterBestRealVectorEvents();
+          bestRealVector = value;
+          if (bestRealVector != null) RegisterBestRealVectorEvents();
+          OnBestRealVectorChanged();
+        }
+      }
+    }
+
+    [Storable]
+    private DoubleValue bestQuality;
+    public DoubleValue BestQuality {
+      get { return bestQuality; }
+      set {
+        if (bestQuality != value) {
+          if (bestQuality != null) DeregisterQualityEvents();
+          bestQuality = value;
+          if (bestQuality != null) RegisterQualityEvents();
+          OnQualityChanged();
+        }
+      }
+    }
+
+    [Storable]
+    private ItemArray<RealVector> population;
+    public ItemArray<RealVector> Population {
+      get { return population; }
+      set {
+        if (population != value) {
+          if (population != null) DeregisterPopulationEvents();
+          population = value;
+          if (population != null) RegisterPopulationEvents();
+          OnPopulationChanged();
+        }
+      }
+    }
+
+    [Storable]
+    private ISingleObjectiveTestFunctionProblemEvaluator evaluator;
+    public ISingleObjectiveTestFunctionProblemEvaluator Evaluator {
+      get { return evaluator; }
+      set {
+        if (evaluator != value) {
+          evaluator = value;
+          OnEvaluatorChanged();
+        }
+      }
+    }
+
+    [Storable]
+    private DoubleMatrix bounds;
+    public DoubleMatrix Bounds {
+      get { return bounds; }
+      set {
+        if (bounds != value) {
+          if (bounds != null) DeregisterBoundsEvents();
+          bounds = value;
+          if (bounds != null) RegisterBoundsEvents();
+          OnBoundsChanged();
+        }
+      }
+    }
+
+    [StorableConstructor]
+    protected SingleObjectiveTestFunctionSolution(bool deserializing) : base(deserializing) { }
+    protected SingleObjectiveTestFunctionSolution(SingleObjectiveTestFunctionSolution original, Cloner cloner)
+      : base(original, cloner) {
+      bestKnownRealVector = cloner.Clone(original.bestKnownRealVector);
+      bestRealVector = cloner.Clone(original.bestRealVector);
+      bestQuality = cloner.Clone(original.bestQuality);
+      population = cloner.Clone(original.population);
+      evaluator = cloner.Clone(original.evaluator);
+      bounds = cloner.Clone(original.bounds);
+      Initialize();
+    }
+    public SingleObjectiveTestFunctionSolution() : base() { }
+    public SingleObjectiveTestFunctionSolution(RealVector realVector, DoubleValue quality, ISingleObjectiveTestFunctionProblemEvaluator evaluator)
+      : base() {
+      this.bestRealVector = realVector;
+      this.bestQuality = quality;
+      this.evaluator = evaluator;
+      Initialize();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+
+    private void Initialize() {
+      if (bestKnownRealVector != null) RegisterBestKnownRealVectorEvents();
+      if (bestRealVector != null) RegisterBestRealVectorEvents();
+      if (bestQuality != null) RegisterQualityEvents();
+      if (population != null) RegisterPopulationEvents();
+      if (bounds != null) RegisterBoundsEvents();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveTestFunctionSolution(this, cloner);
+    }
+
+    #region Events
+    public event EventHandler BestKnownRealVectorChanged;
+    private void OnBestKnownRealVectorChanged() {
+      var changed = BestKnownRealVectorChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+
+    public event EventHandler BestRealVectorChanged;
+    private void OnBestRealVectorChanged() {
+      var changed = BestRealVectorChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+
+    public event EventHandler QualityChanged;
+    private void OnQualityChanged() {
+      var changed = QualityChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+
+    public event EventHandler PopulationChanged;
+    private void OnPopulationChanged() {
+      var changed = PopulationChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+
+    public event EventHandler EvaluatorChanged;
+    private void OnEvaluatorChanged() {
+      var changed = EvaluatorChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+
+    public event EventHandler BoundsChanged;
+    private void OnBoundsChanged() {
+      var changed = BoundsChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+
+    private void RegisterBestKnownRealVectorEvents() {
+      BestKnownRealVector.ItemChanged += new EventHandler<EventArgs<int>>(BestKnownRealVector_ItemChanged);
+      BestKnownRealVector.Reset += new EventHandler(BestKnownRealVector_Reset);
+    }
+    private void DeregisterBestKnownRealVectorEvents() {
+      BestKnownRealVector.ItemChanged -= new EventHandler<EventArgs<int>>(BestKnownRealVector_ItemChanged);
+      BestKnownRealVector.Reset -= new EventHandler(BestKnownRealVector_Reset);
+    }
+    private void RegisterBestRealVectorEvents() {
+      BestRealVector.ItemChanged += new EventHandler<EventArgs<int>>(BestRealVector_ItemChanged);
+      BestRealVector.Reset += new EventHandler(BestRealVector_Reset);
+    }
+    private void DeregisterBestRealVectorEvents() {
+      BestRealVector.ItemChanged -= new EventHandler<EventArgs<int>>(BestRealVector_ItemChanged);
+      BestRealVector.Reset -= new EventHandler(BestRealVector_Reset);
+    }
+    private void RegisterQualityEvents() {
+      BestQuality.ValueChanged += new EventHandler(Quality_ValueChanged);
+    }
+    private void DeregisterQualityEvents() {
+      BestQuality.ValueChanged -= new EventHandler(Quality_ValueChanged);
+    }
+    private void RegisterPopulationEvents() {
+      Population.CollectionReset += new CollectionItemsChangedEventHandler<IndexedItem<RealVector>>(Population_CollectionReset);
+      Population.ItemsMoved += new CollectionItemsChangedEventHandler<IndexedItem<RealVector>>(Population_ItemsMoved);
+      Population.ItemsReplaced += new CollectionItemsChangedEventHandler<IndexedItem<RealVector>>(Population_ItemsReplaced);
+    }
+    private void DeregisterPopulationEvents() {
+      Population.CollectionReset -= new CollectionItemsChangedEventHandler<IndexedItem<RealVector>>(Population_CollectionReset);
+      Population.ItemsMoved -= new CollectionItemsChangedEventHandler<IndexedItem<RealVector>>(Population_ItemsMoved);
+      Population.ItemsReplaced -= new CollectionItemsChangedEventHandler<IndexedItem<RealVector>>(Population_ItemsReplaced);
+    }
+    private void RegisterBoundsEvents() {
+      Bounds.ItemChanged += new EventHandler<EventArgs<int, int>>(Bounds_ItemChanged);
+      Bounds.Reset += new EventHandler(Bounds_Reset);
+    }
+    private void DeregisterBoundsEvents() {
+      Bounds.ItemChanged -= new EventHandler<EventArgs<int, int>>(Bounds_ItemChanged);
+      Bounds.Reset -= new EventHandler(Bounds_Reset);
+    }
+
+    private void BestKnownRealVector_ItemChanged(object sender, EventArgs<int> e) {
+      OnBestKnownRealVectorChanged();
+    }
+    private void BestKnownRealVector_Reset(object sender, EventArgs e) {
+      OnBestKnownRealVectorChanged();
+    }
+    private void BestRealVector_ItemChanged(object sender, EventArgs<int> e) {
+      OnBestRealVectorChanged();
+    }
+    private void BestRealVector_Reset(object sender, EventArgs e) {
+      OnBestRealVectorChanged();
+    }
+    private void Quality_ValueChanged(object sender, EventArgs e) {
+      OnQualityChanged();
+    }
+    private void Population_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<RealVector>> e) {
+      OnPopulationChanged();
+    }
+    private void Population_ItemsMoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<RealVector>> e) {
+      OnPopulationChanged();
+    }
+    private void Population_CollectionReset(object sender, CollectionItemsChangedEventArgs<IndexedItem<RealVector>> e) {
+      OnPopulationChanged();
+    }
+    private void Bounds_ItemChanged(object sender, EventArgs<int, int> e) {
+      OnBoundsChanged();
+    }
+    private void Bounds_Reset(object sender, EventArgs e) {
+      OnBoundsChanged();
+    }
+    #endregion
+  }
+}
