Changeset 13403 for branches

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj

-                      r11961
+                      r13403
   <ItemGroup>
     <Compile Include="Creators\NormalDistributedRealVectorCreator.cs" />
+    <Compile Include="Interfaces\IRealVectorAdditiveMoveQualityOperator.cs" />
+    <Compile Include="Interfaces\IRealVectorBoundedOperator.cs" />
     <Compile Include="Interfaces\IRealVectorMultiNeighborhoodShakingOperator.cs" />
+    <Compile Include="Interfaces\IRealVectorSolutionsOperator.cs" />
+    <Compile Include="Interfaces\IRealVectorSolutionOperator.cs" />
     <Compile Include="ParticleOperators\RealVectorParticleCreator.cs" />
     <Compile Include="Crossovers\BlendAlphaBetaCrossover.cs" />
 …
     <Compile Include="Interfaces\IRealVectorStdDevStrategyParameterManipulator.cs" />
     <Compile Include="Interfaces\IRealVectorStdDevStrategyParameterOperator.cs" />
     <Compile Include="Interfaces\IAdditiveRealVectorMoveOperator.cs" />
+    <Compile Include="Interfaces\IRealVectorAdditiveMoveOperator.cs" />
     <Compile Include="Interfaces\IRealVectorBoundsChecker.cs" />
     <Compile Include="Interfaces\IRealVectorMoveGenerator.cs" />

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorAdditiveMoveOperator.cs

r13402	r13403
23	23
24	24	namespace HeuristicLab.Encodings.RealVectorEncoding {
25		public interface I~~AdditiveRealVector~~MoveOperator : IRealVectorMoveOperator {
	25	public interface IRealVectorAdditiveMoveOperator : IRealVectorMoveOperator {
26	26	ILookupParameter<AdditiveMove> AdditiveMoveParameter { get; }
27	27	}

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorAdditiveMoveQualityOperator.cs

-                      r13393
+                      r13403
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 namespace HeuristicLab.Encodings.RealVectorEncoding {
   public interface IAdditiveRealVectorMoveOperator : IRealVectorMoveOperator {
     ILookupParameter<AdditiveMove> AdditiveMoveParameter { get; }
+  public interface IRealVectorAdditiveMoveQualityOperator : IRealVectorAdditiveMoveOperator {
+    ILookupParameter<DoubleValue> MoveQualityParameter { get; }
+  }
+}

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorCreator.cs

-                      r13361
+                      r13403
   /// An interface which represents an operator for creating vectors of real-valued data.
   /// </summary>
   public interface IRealVectorCreator : IRealVectorOperator, ISolutionCreator<RealVector> {
+  public interface IRealVectorCreator : IRealVectorSolutionOperator, IRealVectorBoundedOperator, ISolutionCreator<RealVector> {
     IValueLookupParameter<IntValue> LengthParameter { get; }
-    IValueLookupParameter<DoubleMatrix> BoundsParameter { get; }
-    ILookupParameter<RealVector> RealVectorParameter { get; }
+  }
+}

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorCrossover.cs

-                      r12012
+                      r13403
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 …
   /// An interface which represents an operator for crossing vectors of real-valued data.
   /// </summary>
   public interface IRealVectorCrossover : IRealVectorOperator, ICrossover {
+  public interface IRealVectorCrossover : IRealVectorBoundedOperator, ICrossover {
     ILookupParameter<ItemArray<RealVector>> ParentsParameter { get; }
     ILookupParameter<RealVector> ChildParameter { get; }
-    IValueLookupParameter<DoubleMatrix> BoundsParameter { get; }
+  }
+}

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorManipulator.cs

-                      r12012
+                      r13403
 #endregion
-using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 …
   /// An interface which represents an operator for manipulating vectors of real-valued data.
   /// </summary>
+  public interface IRealVectorManipulator : IRealVectorOperator, IManipulator {
+    ILookupParameter<RealVector> RealVectorParameter { get; }
+    IValueLookupParameter<DoubleMatrix> BoundsParameter { get; }
+  public interface IRealVectorManipulator : IRealVectorSolutionOperator, IRealVectorBoundedOperator, IManipulator {
+  }
+}

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorMoveGenerator.cs

-                      r12012
+                      r13403
 #endregion
-using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 namespace HeuristicLab.Encodings.RealVectorEncoding {
+  public interface IRealVectorMoveGenerator : IRealVectorMoveOperator, IMoveGenerator {
+    IValueLookupParameter<DoubleMatrix> BoundsParameter { get; }
+  public interface IRealVectorMoveGenerator : IRealVectorMoveOperator, IRealVectorBoundedOperator, IMoveGenerator {
+  }
+}

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorMoveOperator.cs

-                      r12012
+                      r13403
 #endregion
-using HeuristicLab.Core;
 using HeuristicLab.Optimization;
 namespace HeuristicLab.Encodings.RealVectorEncoding {
+  public interface IRealVectorMoveOperator : IRealVectorOperator, IMoveOperator {
+    ILookupParameter<RealVector> RealVectorParameter { get; }
+  public interface IRealVectorMoveOperator : IRealVectorSolutionOperator, IMoveOperator {
+  }
+}

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorMultiNeighborhoodShakingOperator.cs

-                      r12012
+                      r13403
 #endregion
-using HeuristicLab.Core;
-using HeuristicLab.Data;
 namespace HeuristicLab.Encodings.RealVectorEncoding {
+  public interface IRealVectorMultiNeighborhoodShakingOperator : IRealVectorOperator {
+    ILookupParameter<RealVector> RealVectorParameter { get; }
+    IValueLookupParameter<DoubleMatrix> BoundsParameter { get; }
+  public interface IRealVectorMultiNeighborhoodShakingOperator : IRealVectorSolutionOperator, IRealVectorBoundedOperator {
+  }
+}

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorParticleCreator.cs

-                      r12012
+                      r13403
 #endregion
-using HeuristicLab.Optimization;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Optimization;
 namespace HeuristicLab.Encodings.RealVectorEncoding {
   public interface IRealVectorParticleCreator : IParticleCreator, IRealVectorOperator {
+  public interface IRealVectorParticleCreator : IParticleCreator, IRealVectorSolutionOperator, IRealVectorBoundedOperator {
     ILookupParameter<IntValue> ProblemSizeParameter { get; }
-    ILookupParameter<RealVector> RealVectorParameter { get; }
     ILookupParameter<RealVector> PersonalBestParameter { get; }
-    IValueLookupParameter<DoubleMatrix> BoundsParameter { get; }
     ILookupParameter<RealVector> VelocityParameter { get; }
+  }

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorParticleUpdater.cs

-                      r12012
+                      r13403
 namespace HeuristicLab.Encodings.RealVectorEncoding {
   public interface IRealVectorParticleUpdater : IParticleUpdater, IRealVectorOperator {
+  public interface IRealVectorParticleUpdater : IParticleUpdater, IRealVectorSolutionOperator, IRealVectorBoundedOperator {
     ILookupParameter<RealVector> VelocityParameter { get; }
     ILookupParameter<DoubleMatrix> CurrentVelocityBoundsParameter { get; }
-    ILookupParameter<RealVector> RealVectorParameter { get; }
-    ILookupParameter<DoubleMatrix> BoundsParameter { get; }
     ILookupParameter<RealVector> PersonalBestParameter { get; }
     ILookupParameter<RealVector> NeighborBestParameter { get; }

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorStdDevStrategyParameterCreator.cs

r12012	r13403
25	25
26	26	namespace HeuristicLab.Encodings.RealVectorEncoding {
27		public interface IRealVectorStdDevStrategyParameterCreator : IRealVectorStdDevStrategyParameterOperator, IStrategyParameterCreator {
	27	public interface IRealVectorStdDevStrategyParameterCreator : IRealVectorStdDevStrategyParameterOperator, IStrategyParameterCreator, IRealVectorBoundedOperator {
28	28	ILookupParameter<RealVector> StrategyParameterParameter { get; }
29	29	IValueLookupParameter<IntValue> LengthParameter { get; }
30		~~IValueLookupParameter<DoubleMatrix> BoundsParameter { get; }~~
31	30	}
32	31	}

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorStdDevStrategyParameterManipulator.cs

-                      r12012
+                      r13403
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 namespace HeuristicLab.Encodings.RealVectorEncoding {
   public interface IRealVectorStdDevStrategyParameterManipulator : IRealVectorStdDevStrategyParameterOperator, IStrategyParameterManipulator {
+  public interface IRealVectorStdDevStrategyParameterManipulator : IRealVectorStdDevStrategyParameterOperator, IStrategyParameterManipulator, IRealVectorBoundedOperator {
     ILookupParameter<RealVector> StrategyParameterParameter { get; }
-    IValueLookupParameter<DoubleMatrix> BoundsParameter { get; }
+  }
+}

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorSwarmUpdater.cs

-                      r12012
+                      r13403
 using HeuristicLab.Core;
 using HeuristicLab.Optimization;
+using HeuristicLab.Optimization;
 namespace HeuristicLab.Encodings.RealVectorEncoding {
   public interface IRealVectorSwarmUpdater : ISwarmUpdater, IRealVectorOperator {
+  public interface IRealVectorSwarmUpdater : ISwarmUpdater, IRealVectorSolutionsOperator {
     IScopeTreeLookupParameter<RealVector> NeighborBestParameter { get; }
     IScopeTreeLookupParameter<RealVector> PersonalBestParameter { get; }
-    IScopeTreeLookupParameter<RealVector> RealVectorParameter { get; }
+  }
+}

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/AdditiveMoveGenerator.cs

-                      r12012
+                      r13403
   [Item("AdditiveMoveGenerator", "Base class for all additive move generators.")]
   [StorableClass]
   public abstract class AdditiveMoveGenerator : SingleSuccessorOperator, IAdditiveRealVectorMoveOperator, IMoveGenerator, IStochasticOperator {
+  public abstract class AdditiveMoveGenerator : SingleSuccessorOperator, IRealVectorAdditiveMoveOperator, IMoveGenerator, IStochasticOperator {
     public override bool CanChangeName {
       get { return false; }
 …
     public ILookupParameter<AdditiveMove> AdditiveMoveParameter {
       get { return (LookupParameter<AdditiveMove>)Parameters["AdditiveMove"]; }
+    }
-    protected ScopeParameter CurrentScopeParameter {
-      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
     public IValueLookupParameter<DoubleMatrix> BoundsParameter {
 …
       Parameters.Add(new LookupParameter<RealVector>("RealVector", "The real vector for which moves should be generated."));
       Parameters.Add(new LookupParameter<AdditiveMove>("AdditiveMove", "The moves that should be generated in subscopes."));
-      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
       Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "A 2 column matrix specifying the lower and upper bound for each dimension. If there are less rows than dimension the bounds vector is cycled."));
+    }
 …
         moveScopes[i].Variables.Add(new Variable(AdditiveMoveParameter.ActualName, moves[i]));
+      }
       CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
+      ExecutionContext.Scope.SubScopes.AddRange(moveScopes);
       return base.Apply();
+    }

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/AdditiveMoveMaker.cs

-                      r12012
+                      r13403
   [Item("AdditiveMoveMaker", "Peforms an additive move on a given real vector and updates the quality.")]
   [StorableClass]
   public class AdditiveMoveMaker : SingleSuccessorOperator, IAdditiveRealVectorMoveOperator, IMoveMaker, ISingleObjectiveOperator {
+  public class AdditiveMoveMaker : SingleSuccessorOperator, IRealVectorAdditiveMoveQualityOperator, IMoveMaker, ISingleObjectiveOperator {
     public override bool CanChangeName {
       get { return false; }
 …
+    }
+    public static void Apply(RealVector realVector, AdditiveMove move) {
+      realVector[move.Dimension] += move.MoveDistance;
+    }
     public override IOperation Apply() {
+      AdditiveMove move = AdditiveMoveParameter.ActualValue;
+      RealVector realVector = RealVectorParameter.ActualValue;
+      DoubleValue moveQuality = MoveQualityParameter.ActualValue;
+      DoubleValue quality = QualityParameter.ActualValue;
+      Apply(RealVectorParameter.ActualValue, AdditiveMoveParameter.ActualValue);
+      var moveQuality = MoveQualityParameter.ActualValue;
+      var quality = QualityParameter.ActualValue;
-      realVector[move.Dimension] += move.MoveDistance;
       quality.Value = moveQuality.Value;

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/AdditiveMoveTabuChecker.cs

r12012	r13403
32	32	[Item("AdditiveMoveTabuChecker", "Prevents falling back into ranges that have been moved over before.")]
33	33	[StorableClass]
34		public class AdditiveMoveTabuChecker : SingleSuccessorOperator, I~~AdditiveRealVectorMove~~Operator, ITabuChecker {
	34	public class AdditiveMoveTabuChecker : SingleSuccessorOperator, IRealVectorAdditiveMoveQualityOperator, ITabuChecker {
35	35	public override bool CanChangeName {
36	36	get { return false; }

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Moves/AdditiveMoveTabuMaker.cs

r12012	r13403
29	29	[Item("AdditiveMoveTabuMaker", "Sets the move tabu.")]
30	30	[StorableClass]
31		public class AdditiveMoveTabuMaker : TabuMaker, I~~AdditiveRealVectorMove~~Operator {
	31	public class AdditiveMoveTabuMaker : TabuMaker, IRealVectorAdditiveMoveQualityOperator {
32	32	public ILookupParameter<AdditiveMove> AdditiveMoveParameter {
33	33	get { return (ILookupParameter<AdditiveMove>)Parameters["AdditiveMove"]; }

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorParticleUpdater.cs

-                      r12012
+                      r13403
       get { return (ILookupParameter<RealVector>)Parameters["RealVector"]; }
+    }
     public ILookupParameter<DoubleMatrix> BoundsParameter {
       get { return (ILookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    public IValueLookupParameter<DoubleMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
     public ILookupParameter<DoubleMatrix> CurrentVelocityBoundsParameter {
 …
       Parameters.Add(new LookupParameter<RealVector>("BestRealVector", "Global best position."));
       Parameters.Add(new LookupParameter<RealVector>("NeighborBest", "Best neighboring solution."));
       Parameters.Add(new LookupParameter<DoubleMatrix>("Bounds", "The lower and upper bounds for each dimension of the position vector for the current problem."));
+      Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The lower and upper bounds for each dimension of the position vector for the current problem."));
       Parameters.Add(new LookupParameter<DoubleMatrix>("CurrentVelocityBounds", "Upper and lower bounds for the particle's velocity vector."));
       Parameters.Add(new LookupParameter<DoubleValue>("CurrentInertia", "The weight for the particle's velocity vector."));

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/ParticleOperators/RealVectorSwarmUpdater.cs

-                      r12012
+                      r13403
       get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["NeighborBestQuality"]; }
+    }
     public IScopeTreeLookupParameter<RealVector> RealVectorParameter {
       get { return (IScopeTreeLookupParameter<RealVector>)Parameters["RealVector"]; }
+    public IScopeTreeLookupParameter<RealVector> RealVectorsParameter {
+      get { return (IScopeTreeLookupParameter<RealVector>)Parameters["RealVectors"]; }
+    }
     public IScopeTreeLookupParameter<RealVector> PersonalBestParameter {
 …
       set { NeighborBestQualityParameter.ActualValue = value; }
+    }
     private ItemArray<RealVector> RealVector {
       get { return RealVectorParameter.ActualValue; }
+    private ItemArray<RealVector> RealVectors {
+      get { return RealVectorsParameter.ActualValue; }
+    }
     private ItemArray<RealVector> PersonalBest {
 …
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("PersonalBestQuality", "Particles' personal best qualities."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("NeighborBestQuality", "Best neighbor particles' qualities."));
       Parameters.Add(new ScopeTreeLookupParameter<RealVector>("RealVector", "Particles' positions."));
+      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("RealVectors", "Particles' positions."));
       Parameters.Add(new ScopeTreeLookupParameter<RealVector>("PersonalBest", "Particles' personal best positions."));
       Parameters.Add(new ScopeTreeLookupParameter<RealVector>("NeighborBest", "Neighborhood (or global in case of totally connected neighborhood) best particle positions."));
 …
         SwarmBestQuality = new DoubleValue();
       SwarmBestQuality.Value = Maximization ? Quality.Max(v => v.Value) : Quality.Min(v => v.Value);
       BestRealVector = (RealVector)RealVector[Quality.FindIndex(v => v.Value == SwarmBestQuality.Value)].Clone();
+      BestRealVector = (RealVector)RealVectors[Quality.FindIndex(v => v.Value == SwarmBestQuality.Value)].Clone();
+    }
 …
         var neighborBestQuality = new ItemArray<DoubleValue>(Neighbors.Length);
         for (int n = 0; n < Neighbors.Length; n++) {
           var pairs = Quality.Zip(RealVector, (q, p) => new { Quality = q, Point = p })
+          var pairs = Quality.Zip(RealVectors, (q, p) => new { Quality = q, Point = p })
             .Where((p, i) => i == n || Neighbors[n].Contains(i));
           var bestNeighbor = Maximization ?
 …
       if (PersonalBestQuality.Length == 0)
         PersonalBestQuality = (ItemArray<DoubleValue>)Quality.Clone();
       for (int i = 0; i < RealVector.Length; i++) {
+      for (int i = 0; i < RealVectors.Length; i++) {
         if (Maximization && Quality[i].Value > PersonalBestQuality[i].Value ||
           !Maximization && Quality[i].Value < PersonalBestQuality[i].Value) {
           PersonalBestQuality[i].Value = Quality[i].Value;
           PersonalBest[i] = RealVector[i];
+          PersonalBest[i] = RealVectors[i];
+        }
+      }

branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorEncoding.cs

-                      r13396
+                      r13403
           typeof (IRealVectorBoundsChecker),
           typeof (IRealVectorMoveOperator),
+          typeof (IRealVectorMoveGenerator)
+          typeof (IRealVectorMoveGenerator),
+          typeof (IRealVectorSolutionOperator),
+          typeof (IRealVectorSolutionsOperator),
+          typeof (IRealVectorBoundedOperator)
       };
+    }
 …
       ConfigureMoveGenerators(operators.OfType<IRealVectorMoveGenerator>());
       ConfigureMoveOperators(operators.OfType<IRealVectorMoveOperator>());
+      ConfigureAdditiveMoveOperator(operators.OfType<IAdditiveRealVectorMoveOperator>());
+      ConfigureAdditiveMoveOperator(operators.OfType<IRealVectorAdditiveMoveOperator>());
+      ConfigureRealVectorSolutionOperators(operators.OfType<IRealVectorSolutionOperator>());
+      ConfigureRealVectorSolutionsOperators(operators.OfType<IRealVectorSolutionsOperator>());
+      ConfigureRealVectorBoundedOperators(operators.OfType<IRealVectorBoundedOperator>());
+    }
 …
     private void ConfigureCreators(IEnumerable<IRealVectorCreator> creators) {
       foreach (var creator in creators) {
-        creator.RealVectorParameter.ActualName = Name;
         creator.LengthParameter.ActualName = LengthParameter.Name;
-        creator.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
 …
         crossover.ChildParameter.ActualName = Name;
         crossover.ParentsParameter.ActualName = Name;
-        crossover.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
     private void ConfigureManipulators(IEnumerable<IRealVectorManipulator> manipulators) {
       foreach (var manipulator in manipulators) {
-        manipulator.RealVectorParameter.ActualName = Name;
-        manipulator.BoundsParameter.ActualName = BoundsParameter.Name;
-        manipulator.BoundsParameter.Hidden = true;
         var sm = manipulator as ISelfAdaptiveManipulator;
         if (sm != null) {
 …
+    }
     private void ConfigureSwarmUpdaters(IEnumerable<IRealVectorSwarmUpdater> swarmUpdaters) {
+      foreach (var su in swarmUpdaters) {
+        su.RealVectorParameter.ActualName = Name;
+      }
+      // swarm updaters don't have additional parameters besides the solution parameter
+    }
     private void ConfigureParticleCreators(IEnumerable<IRealVectorParticleCreator> particleCreators) {
       foreach (var particleCreator in particleCreators) {
-        particleCreator.RealVectorParameter.ActualName = Name;
-        particleCreator.BoundsParameter.ActualName = BoundsParameter.Name;
         particleCreator.ProblemSizeParameter.ActualName = LengthParameter.Name;
+      }
+    }
     private void ConfigureParticleUpdaters(IEnumerable<IRealVectorParticleUpdater> particleUpdaters) {
+      foreach (var particleUpdater in particleUpdaters) {
+        particleUpdater.RealVectorParameter.ActualName = Name;
+        particleUpdater.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+      // particle updaters don't have additional parameters besides solution and bounds parameter
+    }
     private void ConfigureShakingOperators(IEnumerable<IRealVectorMultiNeighborhoodShakingOperator> shakingOperators) {
+      foreach (var shakingOperator in shakingOperators) {
+        shakingOperator.RealVectorParameter.ActualName = Name;
+        shakingOperator.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+      // shaking operators don't have additional parameters besides solution and bounds parameter
+    }
     private void ConfigureBoundsCheckers(IEnumerable<IRealVectorBoundsChecker> boundsCheckers) {
 …
+    }
     private void ConfigureMoveOperators(IEnumerable<IRealVectorMoveOperator> moveOperators) {
+      foreach (var moveOperator in moveOperators)
+        moveOperator.RealVectorParameter.ActualName = Name;
+    }
+      // move operators don't have additional parameters besides the solution parameter
+    }
     private void ConfigureMoveGenerators(IEnumerable<IRealVectorMoveGenerator> moveGenerators) {
+      foreach (var moveGenerator in moveGenerators)
+        moveGenerator.BoundsParameter.ActualName = BoundsParameter.Name;
+    }
+    private void ConfigureAdditiveMoveOperator(IEnumerable<IAdditiveRealVectorMoveOperator> additiveMoveOperators) {
+      // move generators don't have additional parameters besides solution and bounds parameter
+    }
+    private void ConfigureAdditiveMoveOperator(IEnumerable<IRealVectorAdditiveMoveOperator> additiveMoveOperators) {
       foreach (var additiveMoveOperator in additiveMoveOperators) {
         additiveMoveOperator.AdditiveMoveParameter.ActualName = Name + ".AdditiveMove";
+      }
+    }
+    private void ConfigureRealVectorSolutionOperators(IEnumerable<IRealVectorSolutionOperator> solutionOperators) {
+      foreach (var solutionOperator in solutionOperators)
+        solutionOperator.RealVectorParameter.ActualName = Name;
+    }
+    private void ConfigureRealVectorSolutionsOperators(IEnumerable<IRealVectorSolutionsOperator> solutionsOperators) {
+      foreach (var solutionsOperator in solutionsOperators)
+        solutionsOperator.RealVectorsParameter.ActualName = Name;
+    }
+    private void ConfigureRealVectorBoundedOperators(IEnumerable<IRealVectorBoundedOperator> boundedOperators) {
+      foreach (var boundedOperator in boundedOperators) {
+        boundedOperator.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }

branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/IParticleUpdater.cs

-                      r12012
+                      r13403
   /// Interface to represent an operator that updates a particle
   /// </summary>
   public interface IParticleUpdater : IOperator {
+  public interface IParticleUpdater : IStochasticOperator {
     ILookupParameter<DoubleValue> InertiaParameter { get; }
     ILookupParameter<DoubleValue> NeighborBestAttractionParameter { get; }
     ILookupParameter<DoubleValue> PersonalBestAttractionParameter { get; }
-    ILookupParameter<IRandom> RandomParameter { get; }
+  }
+}

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions.Views/3.3/SingleObjectiveTestFunctionSolutionView.cs

-                      r12012
+                      r13403
           pictureBox.Refresh();
           DoubleMatrix bounds = Content.Bounds;
           if (bounds == null) bounds = Content.Evaluator.Bounds;
+          if (bounds == null) bounds = Content.TestFunction.Bounds;
           double xMin = bounds[0, 0], xMax = bounds[0, 1], yMin = bounds[1 % bounds.Rows, 0], yMax = bounds[1 % bounds.Rows, 1];
           double xStep = backgroundImage.Width / (xMax - xMin), yStep = backgroundImage.Height / (yMax - yMin);
 …
       backgroundImage = new Bitmap(pictureBox.Width, pictureBox.Height);
       DoubleMatrix bounds = Content.Bounds;
       if (bounds == null) bounds = Content.Evaluator.Bounds;
+      if (bounds == null) bounds = Content.TestFunction.Bounds;
       double xMin = bounds[0, 0], xMax = bounds[0, 1], yMin = bounds[1 % bounds.Rows, 0], yMax = bounds[1 % bounds.Rows, 1];
       double xStep = (xMax - xMin) / backgroundImage.Width, yStep = (yMax - yMin) / backgroundImage.Height;
 …
       for (int i = 0; i < backgroundImage.Width; i++)
         for (int j = 0; j < backgroundImage.Height; j++) {
           points[j, i] = Content.Evaluator.Evaluate2D(xMin + i * xStep, yMin + j * yStep);
+          points[j, i] = Content.TestFunction.Evaluate2D(xMin + i * xStep, yMin + j * yStep);
           if (points[j, i] < minPoint) minPoint = points[j, i];
           if (points[j, i] > maxPoint) maxPoint = points[j, i];

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Analyzers/BestSingleObjectiveTestFunctionSolutionAnalyzer.cs

-                      r12012
+                      r13403
       get { return (LookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
     public ScopeTreeLookupParameter<RealVector> RealVectorParameter {
       get { return (ScopeTreeLookupParameter<RealVector>)Parameters["RealVector"]; }
+    public IScopeTreeLookupParameter<RealVector> RealVectorsParameter {
+      get { return (IScopeTreeLookupParameter<RealVector>)Parameters["RealVectors"]; }
+    }
+    ILookupParameter IBestSingleObjectiveTestFunctionSolutionAnalyzer.RealVectorParameter {
+      get { return RealVectorParameter; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    ILookupParameter IBestSingleObjectiveTestFunctionSolutionAnalyzer.QualityParameter {
+      get { return QualityParameter; }
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
     public ILookupParameter<SingleObjectiveTestFunctionSolution> BestSolutionParameter {
 …
       get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
     public IValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator> EvaluatorParameter {
       get { return (IValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator>)Parameters["Evaluator"]; }
+    public IValueLookupParameter<ISingleObjectiveTestFunction> TestFunctionParameter {
+      get { return (IValueLookupParameter<ISingleObjectiveTestFunction>)Parameters["TestFunction"]; }
+    }
     public ILookupParameter<DoubleMatrix> BoundsParameter {
       get { return (ILookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    public IValueLookupParameter<DoubleMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
 …
       : base() {
       Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem."));
       Parameters.Add(new ScopeTreeLookupParameter<RealVector>("RealVector", "The SingleObjectiveTestFunction solutions from which the best solution should be visualized."));
+      Parameters.Add(new ScopeTreeLookupParameter<RealVector>("RealVectors", "The SingleObjectiveTestFunction solutions from which the best solution should be visualized."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The qualities of the SingleObjectiveTestFunction solutions which should be visualized."));
       Parameters.Add(new LookupParameter<SingleObjectiveTestFunctionSolution>("BestSolution", "The best SingleObjectiveTestFunction solution."));
 …
       Parameters.Add(new LookupParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution."));
       Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the SingleObjectiveTestFunction solution should be stored."));
       Parameters.Add(new ValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator>("Evaluator", "The evaluator with which the solution is evaluated."));
       Parameters.Add(new LookupParameter<DoubleMatrix>("Bounds", "The bounds of the function."));
+      Parameters.Add(new ValueLookupParameter<ISingleObjectiveTestFunction>("TestFunction", "The evaluator with which the solution is evaluated."));
+      Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The bounds of the function."));
       MaximizationParameter.Hidden = true;
       RealVectorParameter.Hidden = true;
+      RealVectorsParameter.Hidden = true;
       QualityParameter.Hidden = true;
       BestSolutionParameter.Hidden = true;
 …
       BestKnownQualityParameter.Hidden = true;
       ResultsParameter.Hidden = true;
       EvaluatorParameter.Hidden = true;
+      TestFunctionParameter.Hidden = true;
       BoundsParameter.Hidden = true;
+    }
-    /// <summary>
-    /// This method can simply be removed when the plugin version is > 3.3
-    /// </summary>
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      // BackwardsCompatibility3.3
-      // Bounds are introduced in 3.3.0.3894
-      if (!Parameters.ContainsKey("Bounds"))
-        Parameters.Add(new LookupParameter<DoubleMatrix>("Bounds", "The bounds of the function."));
+    }
 …
     public override IOperation Apply() {
       ItemArray<RealVector> realVectors = RealVectorParameter.ActualValue;
+      ItemArray<RealVector> realVectors = RealVectorsParameter.ActualValue;
       ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
       bool max = MaximizationParameter.ActualValue.Value;
 …
         solution = new SingleObjectiveTestFunctionSolution((RealVector)realVectors[i].Clone(),
                                                            (DoubleValue)qualities[i].Clone(),
                                                            EvaluatorParameter.ActualValue);
+                                                           TestFunctionParameter.ActualValue);
         solution.Population = realVectors[i].Length == 2
           ? new ItemArray<RealVector>(realVectors.Select(x => x.Clone()).Cast<RealVector>())

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Ackley.cs

-                      r13393
+                      r13403
   /// 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.")]
+  [Item("Ackley", "Evaluates the Ackley function on a given point. The optimum of this function is 0 at the origin. It is implemented as described in Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg.")]
   [StorableClass]
+  public class AckleyEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    public override string FunctionName { get { return "Ackley"; } }
+  public class Ackley : SingleObjectiveTestFunction {
     /// <summary>
     /// Returns false as the Ackley function is a minimization problem.
 …
     [StorableConstructor]
     protected AckleyEvaluator(bool deserializing) : base(deserializing) { }
     protected AckleyEvaluator(AckleyEvaluator original, Cloner cloner) : base(original, cloner) { }
     public AckleyEvaluator() : base() { }
+    protected Ackley(bool deserializing) : base(deserializing) { }
+    protected Ackley(Ackley original, Cloner cloner) : base(original, cloner) { }
+    public Ackley() : base() { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new AckleyEvaluator(this, cloner);
+      return new Ackley(this, cloner);
+    }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Beale.cs

-                      r13393
+                      r13403
   /// 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.")]
+  [Item("Beale", "Evaluates the Beale function on a given point. The optimum of this function is 0 at (3,0.5). It is implemented as described in Moré, J.J., Garbow, B., and Hillstrom, K. 1981. Testing unconstrained optimization software. ACM Transactions on Mathematical Software 7, pp. 136-140, ACM.")]
   [StorableClass]
+  public class BealeEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    public override string FunctionName { get { return "Beale"; } }
+  public class Beale : SingleObjectiveTestFunction {
     /// <summary>
     /// Returns false as the Beale function is a minimization problem.
 …
     [StorableConstructor]
     protected BealeEvaluator(bool deserializing) : base(deserializing) { }
     protected BealeEvaluator(BealeEvaluator original, Cloner cloner) : base(original, cloner) { }
     public BealeEvaluator() : base() { }
+    protected Beale(bool deserializing) : base(deserializing) { }
+    protected Beale(Beale original, Cloner cloner) : base(original, cloner) { }
+    public Beale() : base() { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new BealeEvaluator(this, cloner);
+      return new Beale(this, cloner);
+    }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Booth.cs

-                      r13393
+                      r13403
   /// 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.")]
+  [Item("Booth", "Evaluates the Booth function on a given point. The optimum of this function is 0 at (1,3). It is implemented as described on http://www-optima.amp.i.kyoto-u.ac.jp/member/student/hedar/Hedar_files/TestGO_files/Page816.htm, last accessed April 12th, 2010.")]
   [StorableClass]
+  public class BoothEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    public override string FunctionName { get { return "Booth"; } }
+  public class Booth : SingleObjectiveTestFunction {
     /// <summary>
     /// Returns false as the Booth function is a minimization problem.
 …
     [StorableConstructor]
     protected BoothEvaluator(bool deserializing) : base(deserializing) { }
     protected BoothEvaluator(BoothEvaluator original, Cloner cloner) : base(original, cloner) { }
     public BoothEvaluator() : base() { }
+    protected Booth(bool deserializing) : base(deserializing) { }
+    protected Booth(Booth original, Cloner cloner) : base(original, cloner) { }
+    public Booth() : base() { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new BoothEvaluator(this, cloner);
+      return new Booth(this, cloner);
+    }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Griewank.cs

-                      r13393
+                      r13403
   /// 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.")]
+  [Item("Griewank", "Evaluates the Griewank function on a given point. The optimum of this function is 0 at the origin. It is introduced by Griewank A.O. 1981 and implemented as described (without the modifications) in Locatelli, M. 2003. A note on the Griewank test function. Journal of Global Optimization 25, pp. 169-174, Springer.")]
   [StorableClass]
+  public class GriewankEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    public override string FunctionName { get { return "Griewank"; } }
+  public class Griewank : SingleObjectiveTestFunction {
     /// <summary>
     /// Returns false as the Griewank function is a minimization problem.
 …
     [StorableConstructor]
     protected GriewankEvaluator(bool deserializing) : base(deserializing) { }
     protected GriewankEvaluator(GriewankEvaluator original, Cloner cloner) : base(original, cloner) { }
     public GriewankEvaluator() : base() { }
+    protected Griewank(bool deserializing) : base(deserializing) { }
+    protected Griewank(Griewank original, Cloner cloner) : base(original, cloner) { }
+    public Griewank() : base() { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new GriewankEvaluator(this, cloner);
+      return new Griewank(this, cloner);
+    }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Levy.cs

-                      r13393
+                      r13403
   /// 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.")]
+  [Item("Levy", "Evaluates the Levy function on a given point. The optimum of this function is 0 at (1,1,...,1). It is implemented as described on http://www-optima.amp.i.kyoto-u.ac.jp/member/student/hedar/Hedar_files/TestGO_files/Page2056.htm, last accessed April 12th, 2010.")]
   [StorableClass]
+  public class LevyEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    public override string FunctionName { get { return "Levy"; } }
+  public class Levy : SingleObjectiveTestFunction {
     /// <summary>
     /// Returns false as the Levy function is a minimization problem.
 …
     [StorableConstructor]
     protected LevyEvaluator(bool deserializing) : base(deserializing) { }
     protected LevyEvaluator(LevyEvaluator original, Cloner cloner) : base(original, cloner) { }
     public LevyEvaluator() : base() { }
+    protected Levy(bool deserializing) : base(deserializing) { }
+    protected Levy(Levy original, Cloner cloner) : base(original, cloner) { }
+    public Levy() : base() { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new LevyEvaluator(this, cloner);
+      return new Levy(this, cloner);
+    }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Matyas.cs

-                      r13393
+                      r13403
   /// 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.")]
+  [Item("Matyas", "Evaluates the Matyas function on a given point. The optimum of this function is 0 at the origin. It is implemented as described on http://www-optima.amp.i.kyoto-u.ac.jp/member/student/hedar/Hedar_files/TestGO_files/Page2213.htm, last accessed April 12th, 2010.")]
   [StorableClass]
+  public class MatyasEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    public override string FunctionName { get { return "Matyas"; } }
+  public class Matyas : SingleObjectiveTestFunction {
     /// <summary>
     /// Returns false as the Matyas function is a minimization problem.
 …
     [StorableConstructor]
     protected MatyasEvaluator(bool deserializing) : base(deserializing) { }
     protected MatyasEvaluator(MatyasEvaluator original, Cloner cloner) : base(original, cloner) { }
     public MatyasEvaluator() : base() { }
+    protected Matyas(bool deserializing) : base(deserializing) { }
+    protected Matyas(Matyas original, Cloner cloner) : base(original, cloner) { }
+    public Matyas() : base() { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new MatyasEvaluator(this, cloner);
+      return new Matyas(this, cloner);
+    }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Multinormal.cs

-                      r13393
+                      r13403
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 namespace HeuristicLab.Problems.TestFunctions.Evaluators {
   [Item("MultinormalFunction", "Evaluates a random multinormal function on a given point.")]
+  [Item("Multinormal", "Evaluates a random multinormal function on a given point.")]
   [StorableClass]
+  public class MultinormalEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    public override string FunctionName { get { return "Multinormal"; } }
+  public class Multinormal : SingleObjectiveTestFunction {
     private ItemList<RealVector> centers {
 …
       set { Parameters["s^2s"].ActualValue = value; }
+    }
+    private static System.Random Random = new System.Random();
+    public IRandom Random {
+      get { return ((ValueParameter<IRandom>)Parameters["Random"]).Value; }
+      set { ((ValueParameter<IRandom>)Parameters["Random"]).Value = value; }
+    }
     private Dictionary<int, List<RealVector>> stdCenters;
 …
     [StorableConstructor]
     protected MultinormalEvaluator(bool deserializing) : base(deserializing) { }
     protected MultinormalEvaluator(MultinormalEvaluator original, Cloner cloner) : base(original, cloner) { }
     public MultinormalEvaluator() {
+    protected Multinormal(bool deserializing) : base(deserializing) { }
+    protected Multinormal(Multinormal original, Cloner cloner) : base(original, cloner) { }
+    public Multinormal() {
       Parameters.Add(new ValueParameter<ItemList<RealVector>>("Centers", "Centers of normal distributions"));
       Parameters.Add(new ValueParameter<RealVector>("s^2s", "sigma^2 of normal distributions"));
       Parameters.Add(new LookupParameter<IRandom>("Random", "Random number generator"));
+      Parameters.Add(new ValueParameter<IRandom>("Random", "The random number generator that will make random instances", new MersenneTwister(0)));
       centers = new ItemList<RealVector>();
       s_2s = new RealVector();
 …
     public override IDeepCloneable Clone(Cloner cloner) {
       return new MultinormalEvaluator(this, cloner);
+      return new Multinormal(this, cloner);
+    }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Random.cs

-                      r13393
+                      r13403
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.RealVectorEncoding;
-using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
 namespace HeuristicLab.Problems.TestFunctions {
 …
   /// 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.")]
+  [Item("Random", "Returns a random value in [0;1) that is independent of the inputs.")]
   [StorableClass]
+  public class RandomEvaluator : SingleObjectiveTestFunctionProblemEvaluator, IStochasticOperator {
+    public override string FunctionName { get { return "Random"; } }
+  public class Random : SingleObjectiveTestFunction {
     /// <summary>
     /// It does not really matter.
 …
+    }
     public ILookupParameter<IRandom> RandomParameter {
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    public IValueParameter<IRandom> RandomParameter {
+      get { return (IValueParameter<IRandom>)Parameters["Random"]; }
+    }
     [StorableConstructor]
     protected RandomEvaluator(bool deserializing) : base(deserializing) { }
     protected RandomEvaluator(RandomEvaluator original, Cloner cloner) : base(original, cloner) { }
     public RandomEvaluator()
+    protected Random(bool deserializing) : base(deserializing) { }
+    protected Random(Random original, Cloner cloner) : base(original, cloner) { }
+    public Random()
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new ValueParameter<IRandom>("Random", "The random number generator to use.", new MersenneTwister(0)));
+    }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new RandomEvaluator(this, cloner);
+      return new Random(this, cloner);
+    }
     public override RealVector GetBestKnownSolution(int dimension) {
       return new RealVector(dimension);
+      return null;
+    }
     public override double Evaluate(RealVector point) {
       return ExecutionContext == null ? new System.Random().NextDouble() : RandomParameter.ActualValue.NextDouble();
+      return RandomParameter.Value.NextDouble();
+    }
+  }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Rastrigin.cs

-                      r13393
+                      r13403
   /// 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.")]
+  [Item("Rastrigin", "Evaluates the generalized Rastrigin function y = Sum((x_i)^2 + A * (1 - Cos(2pi*x_i))) on a given point. The optimum of this function is 0 at the origin. It is implemented as described in Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg.")]
   [StorableClass]
+  public class RastriginEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    public override string FunctionName { get { return "Rastrigin"; } }
+  public class Rastrigin : SingleObjectiveTestFunction {
     /// <summary>
     /// Returns false as the Rastrigin function is a minimization problem.
 …
     [StorableConstructor]
     protected RastriginEvaluator(bool deserializing) : base(deserializing) { }
     protected RastriginEvaluator(RastriginEvaluator original, Cloner cloner) : base(original, cloner) { }
+    protected Rastrigin(bool deserializing) : base(deserializing) { }
+    protected Rastrigin(Rastrigin original, Cloner cloner) : base(original, cloner) { }
     /// <summary>
     /// Initializes a new instance of the RastriginEvaluator with one parameter (<c>A</c>).
     /// </summary>
     public RastriginEvaluator()
+    public Rastrigin()
       : base() {
       Parameters.Add(new ValueParameter<DoubleValue>("A", "The parameter A is a parameter of the objective function y = Sum((x_i)^2 + A * (1 - Cos(2pi*x_i))). Default is A = 10.", new DoubleValue(10)));
 …
     public override IDeepCloneable Clone(Cloner cloner) {
       return new RastriginEvaluator(this, cloner);
+      return new Rastrigin(this, cloner);
+    }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Rosenbrock.cs

-                      r13393
+                      r13403
   /// 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.
+  [Item("Rosenbrock", @"The Rosenbrock function features a flat valley in which the global optimum is located.
 For 2 and 3 dimensions the single minimum of this function is 0 at (1,1,...,1), for 4 to 30 dimensions there is an additional local minimum close to (-1,1,...,1).
 It is unknown how many local minima there are for dimensions greater than 30.
 It is implemented as generalized Rosenbrock function for which the 2 dimensional function is a special case, as for example given in Shang, Y.-W. and Qiu, Y.-H. 2006. A Note on the Extended Rosenbrock Function. Evolutionary Computation 14, pp. 119-126, MIT Press.")]
   [StorableClass]
+  public class RosenbrockEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    public override string FunctionName { get { return "Rosenbrock"; } }
+  public class Rosenbrock : SingleObjectiveTestFunction {
     /// <summary>
     /// Returns false as the Rosenbrock function is a minimization problem.
 …
     [StorableConstructor]
     protected RosenbrockEvaluator(bool deserializing) : base(deserializing) { }
     protected RosenbrockEvaluator(RosenbrockEvaluator original, Cloner cloner) : base(original, cloner) { }
     public RosenbrockEvaluator() : base() { }
+    protected Rosenbrock(bool deserializing) : base(deserializing) { }
+    protected Rosenbrock(Rosenbrock original, Cloner cloner) : base(original, cloner) { }
+    public Rosenbrock() : base() { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new RosenbrockEvaluator(this, cloner);
+      return new Rosenbrock(this, cloner);
+    }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Schwefel.cs

-                      r13393
+                      r13403
   /// 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.")]
+  [Item("Schwefel", "Evaluates the Schwefel function (sine root) on a given point. In the given bounds [-500;500] the optimum of this function is close to 0 at (420.968746453712,420.968746453712,...,420.968746453712). It is implemented as described in Affenzeller, M. and Wagner, S. 2005. Offspring Selection: A New Self-Adaptive Selection Scheme for Genetic Algorithms.  Ribeiro, B., Albrecht, R. F., Dobnikar, A., Pearson, D. W., and Steele, N. C. (eds.). Adaptive and Natural Computing Algorithms, pp. 218-221, Springer.")]
   [StorableClass]
+  public class SchwefelEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    public override string FunctionName { get { return "Schwefel"; } }
+  public class Schwefel : SingleObjectiveTestFunction {
     /// <summary>
     /// Returns false as the Schwefel (sine root) function is a minimization problem.
 …
     [StorableConstructor]
     protected SchwefelEvaluator(bool deserializing) : base(deserializing) { }
     protected SchwefelEvaluator(SchwefelEvaluator original, Cloner cloner) : base(original, cloner) { }
     public SchwefelEvaluator() : base() { }
+    protected Schwefel(bool deserializing) : base(deserializing) { }
+    protected Schwefel(Schwefel original, Cloner cloner) : base(original, cloner) { }
+    public Schwefel() : base() { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new SchwefelEvaluator(this, cloner);
+      return new Schwefel(this, cloner);
+    }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/SingleObjectiveTestFunction.cs

-                      r13393
+                      r13403
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.RealVectorEncoding;
-using HeuristicLab.Operators;
-using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 …
   /// Base class for a test function evaluator.
   /// </summary>
   [Item("Evaluator", "Base calls for single objective test function evaluators.")]
+  [Item("Single-Objective Function", "Base class for single objective functions.")]
   [StorableClass]
+  public abstract class SingleObjectiveTestFunctionProblemEvaluator : InstrumentedOperator, ISingleObjectiveTestFunctionProblemEvaluator {
+    /// <summary>
+    /// The name of the function
+    /// </summary>
+    public abstract string FunctionName { get; }
+  public abstract class SingleObjectiveTestFunction : ParameterizedNamedItem, ISingleObjectiveTestFunction {
     /// <summary>
     /// These operators should not change their name through the GUI
 …
     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 InstrumentedApply() {
+      RealVector point = PointParameter.ActualValue;
+      double quality = Evaluate(point);
+      QualityParameter.ActualValue = new DoubleValue(quality);
+      return base.InstrumentedApply();
+    }
+    protected SingleObjectiveTestFunction(bool deserializing) : base(deserializing) { }
+    protected SingleObjectiveTestFunction(SingleObjectiveTestFunction original, Cloner cloner) : base(original, cloner) { }
+    protected SingleObjectiveTestFunction() : base() { }
     public virtual double Evaluate2D(double x, double y) {

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Sphere.cs

-                      r13393
+                      r13403
   /// 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.")]
+  [Item("Sphere", "Evaluates the Sphere function y = C * ||X||^Alpha on a given point. The optimum of this function is 0 at the origin. It is implemented as described in Beyer, H.-G. and Schwefel, H.-P. 2002. Evolution Strategies - A Comprehensive Introduction Natural Computing, 1, pp. 3-52.")]
   [StorableClass]
+  public class SphereEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    public override string FunctionName { get { return "Sphere"; } }
+  public class Sphere : SingleObjectiveTestFunction {
     /// <summary>
     /// Returns false as the Sphere function is a minimization problem.
 …
     public override IDeepCloneable Clone(Cloner cloner) {
       return new SphereEvaluator(this, cloner);
+      return new Sphere(this, cloner);
+    }
 …
     [StorableConstructor]
     protected SphereEvaluator(bool deserializing) : base(deserializing) { }
     protected SphereEvaluator(SphereEvaluator original, Cloner cloner) : base(original, cloner) { }
+    protected Sphere(bool deserializing) : base(deserializing) { }
+    protected Sphere(Sphere original, Cloner cloner) : base(original, cloner) { }
     /// <summary>
     /// Initializes a new instance of the SphereEvaluator with two parameters (<c>C</c> and <c>Alpha</c>).
     /// </summary>
     public SphereEvaluator()
+    public Sphere()
       : base() {
       Parameters.Add(new ValueParameter<DoubleValue>("C", "The parameter C modifies the steepness of the objective function y = C * ||X||^Alpha. Default is C = 1.", new DoubleValue(1)));

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/SumSquares.cs

-                      r13393
+                      r13403
   /// 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.")]
+  [Item("SumSquares", "Evaluates the sum squares function on a given point. The optimum of this function is 0 at the origin. The Sum Squares function is defined as sum(i * x_i * x_i) for i = 1..n.")]
   [StorableClass]
+  public class SumSquaresEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    public override string FunctionName { get { return "SumSquares"; } }
+  public class SumSquares : SingleObjectiveTestFunction {
     /// <summary>
     /// Returns false as the Sum Squares function is a minimization problem.
 …
     [StorableConstructor]
     protected SumSquaresEvaluator(bool deserializing) : base(deserializing) { }
     protected SumSquaresEvaluator(SumSquaresEvaluator original, Cloner cloner) : base(original, cloner) { }
     public SumSquaresEvaluator() : base() { }
+    protected SumSquares(bool deserializing) : base(deserializing) { }
+    protected SumSquares(SumSquares original, Cloner cloner) : base(original, cloner) { }
+    public SumSquares() : base() { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new SumSquaresEvaluator(this, cloner);
+      return new SumSquares(this, cloner);
+    }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Functions/Zakharov.cs

-                      r13393
+                      r13403
   /// 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.")]
+  [Item("Zakharov", "Evaluates the Zakharov function on a given point. The optimum of this function is 0 at the origin. It is implemented as described in Hedar, A. & Fukushima, M. 2004. Heuristic pattern search and its hybridization with simulated annealing for nonlinear global optimization. Optimization Methods and Software 19, pp. 291-308, Taylor & Francis.")]
   [StorableClass]
+  public class ZakharovEvaluator : SingleObjectiveTestFunctionProblemEvaluator {
+    public override string FunctionName { get { return "Zakharov"; } }
+  public class Zakharov : SingleObjectiveTestFunction {
     /// <summary>
     /// Returns false as the Zakharov function is a minimization problem.
 …
     [StorableConstructor]
     protected ZakharovEvaluator(bool deserializing) : base(deserializing) { }
     protected ZakharovEvaluator(ZakharovEvaluator original, Cloner cloner) : base(original, cloner) { }
     public ZakharovEvaluator() : base() { }
+    protected Zakharov(bool deserializing) : base(deserializing) { }
+    protected Zakharov(Zakharov original, Cloner cloner) : base(original, cloner) { }
+    public Zakharov() : base() { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new ZakharovEvaluator(this, cloner);
+      return new Zakharov(this, cloner);
+    }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/HeuristicLab.Problems.TestFunctions-3.3.csproj

-                      r11623
+                      r13403
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Evaluators\RandomEvaluator.cs" />
+    <Compile Include="Functions\Random.cs" />
     <Compile Include="Improvers\SingleObjectiveTestFunctionImprovementOperator.cs" />
     <Compile Include="Instances\SOTFData.cs" />
     <Compile Include="Instances\SOTFDataDescriptor.cs" />
     <Compile Include="Instances\SOTFInstanceProvider.cs" />
+    <Compile Include="MoveEvaluators\RandomAdditiveMoveEvaluator.cs" />
+    <Compile Include="Interfaces\ITestFunctionSolutionSimilarityCalculator.cs" />
+    <Compile Include="Interfaces\ISingleObjectiveTestFuntionImprovementOperator.cs" />
     <Compile Include="PathRelinkers\SingleObjectiveTestFunctionPathRelinker.cs" />
     <Compile Include="Plugin.cs" />
 …
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="Evaluators\AckleyEvaluator.cs" />
     <Compile Include="Evaluators\BealeEvaluator.cs" />
     <Compile Include="Evaluators\BoothEvaluator.cs" />
     <Compile Include="Evaluators\GriewankEvaluator.cs" />
     <Compile Include="Evaluators\LevyEvaluator.cs" />
     <Compile Include="Evaluators\MatyasEvaluator.cs" />
     <Compile Include="Evaluators\MultinormalEvaluator.cs" />
     <Compile Include="Evaluators\RastriginEvaluator.cs" />
     <Compile Include="Evaluators\RosenbrockEvaluator.cs" />
     <Compile Include="Evaluators\SchwefelEvaluator.cs" />
     <Compile Include="Evaluators\SingleObjectiveTestFunctionProblemEvaluator.cs" />
     <Compile Include="Evaluators\SphereEvaluator.cs" />
     <Compile Include="Evaluators\SumSquaresEvaluator.cs" />
     <Compile Include="Evaluators\ZakharovEvaluator.cs" />
+    <Compile Include="Functions\Ackley.cs" />
+    <Compile Include="Functions\Beale.cs" />
+    <Compile Include="Functions\Booth.cs" />
+    <Compile Include="Functions\Griewank.cs" />
+    <Compile Include="Functions\Levy.cs" />
+    <Compile Include="Functions\Matyas.cs" />
+    <Compile Include="Functions\Multinormal.cs" />
+    <Compile Include="Functions\Rastrigin.cs" />
+    <Compile Include="Functions\Rosenbrock.cs" />
+    <Compile Include="Functions\Schwefel.cs" />
+    <Compile Include="Functions\SingleObjectiveTestFunction.cs" />
+    <Compile Include="Functions\Sphere.cs" />
+    <Compile Include="Functions\SumSquares.cs" />
+    <Compile Include="Functions\Zakharov.cs" />
     <Compile Include="Interfaces\IBestSingleObjectiveTestFunctionSolutionAnalyzer.cs" />
-    <Compile Include="Interfaces\IRastriginMoveEvaluator.cs" />
     <Compile Include="Interfaces\ISingleObjectiveTestFunctionAdditiveMoveEvaluator.cs" />
     <Compile Include="Interfaces\ISingleObjectiveTestFunctionMoveEvaluator.cs" />
     <Compile Include="Interfaces\ISingleObjectiveTestFunctionProblemEvaluator.cs" />
+    <Compile Include="Interfaces\ISingleObjectiveTestFunction.cs" />
     <Compile Include="Interfaces\ISingleObjectiveTestFunctionProblemSolutionsVisualizer.cs" />
-    <Compile Include="Interfaces\ISphereMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\AckleyAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\BealeAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\BoothAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\MultinormalAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\GriewankAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\ZakharovAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\SumSquaresAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\SphereAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\SchwefelAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\MatyasAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\RosenbrockAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\RastriginAdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\LevyAdditiveMoveEvaluator.cs" />
     <Compile Include="MoveEvaluators\AdditiveMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\RealVectorAdditiveMoveWrapper.cs" />
-    <Compile Include="RealVectorToRealVectorEncoder.cs" />
     <Compile Include="SimilarityCalculators\SingleObjectiveTestFunctionSimilarityCalculator.cs" />
     <Compile Include="SingleObjectiveTestFunctionSolution.cs" />
 …
       <Project>{3540e29e-4793-49e7-8ee2-fea7f61c3994}</Project>
       <Name>HeuristicLab.Problems.Instances-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Random\3.3\HeuristicLab.Random-3.3.csproj">
+      <Project>{f4539fb6-4708-40c9-be64-0a1390aea197}</Project>
+      <Name>HeuristicLab.Random-3.3</Name>
       <Private>False</Private>
     </ProjectReference>

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Improvers/SingleObjectiveTestFunctionImprovementOperator.cs

-                      r12012
+                      r13403
 using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 …
   [Item("SingleObjectiveTestFunctionImprovementOperator", "An operator that improves test functions solutions. It is implemented as described in Laguna, M. and Martí, R. (2003). Scatter Search: Methodology and Implementations in C. Operations Research/Computer Science Interfaces Series, Vol. 24. Springer.")]
   [StorableClass]
   public sealed class SingleObjectiveTestFunctionImprovementOperator : SingleSuccessorOperator, ISingleObjectiveImprovementOperator {
+  public sealed class SingleObjectiveTestFunctionImprovementOperator : SingleSuccessorOperator, ISingleObjectiveTestFunctionImprovementOperator {
     #region Parameter properties
     public IValueParameter<DoubleValue> AlphaParameter {
 …
       get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
-    public ScopeParameter CurrentScopeParameter {
-      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
     public IValueParameter<DoubleValue> DeltaParameter {
       get { return (IValueParameter<DoubleValue>)Parameters["Delta"]; }
+    }
     public IValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator> EvaluatorParameter {
       get { return (IValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator>)Parameters["Evaluator"]; }
+    public IValueLookupParameter<ISingleObjectiveTestFunction> TestFunctionParameter {
+      get { return (IValueLookupParameter<ISingleObjectiveTestFunction>)Parameters["TestFunction"]; }
+    }
     public IValueParameter<DoubleValue> GammaParameter {
 …
       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
 …
       Parameters.Add(new ValueParameter<DoubleValue>("Alpha", new DoubleValue(1.0)));
       Parameters.Add(new ValueParameter<DoubleValue>("Beta", new DoubleValue(2.0)));
+      Parameters.Add(new ValueParameter<DoubleValue>("Delta", new DoubleValue(0.5)));
+      Parameters.Add(new ValueParameter<DoubleValue>("Gamma", new DoubleValue(0.5)));
+      Parameters.Add(new ValueLookupParameter<ISingleObjectiveTestFunction>("TestFunction", "The operator used to evaluate solutions."));
       Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "The lower and upper bounds in each dimension."));
-      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope that contains the solution to be improved."));
-      Parameters.Add(new ValueParameter<DoubleValue>("Delta", new DoubleValue(0.5)));
-      Parameters.Add(new ValueLookupParameter<ISingleObjectiveTestFunctionProblemEvaluator>("Evaluator", "The operator used to evaluate solutions."));
-      Parameters.Add(new ValueParameter<DoubleValue>("Gamma", new DoubleValue(0.5)));
       Parameters.Add(new ValueLookupParameter<IntValue>("ImprovementAttempts", "The number of improvement attempts the operator should perform.", new IntValue(100)));
       Parameters.Add(new ValueLookupParameter<IItem>("Solution", "The solution to be improved. This parameter is used for name translation only."));
+      Parameters.Add(new ValueLookupParameter<IItem>("Solution", "The solution to be improved. This parameter is used for name translation only.")); // TODO: Problematic, this cannot be wired! IImprovementOperators need to be generic
       #endregion
+    }
 …
     public override IOperation Apply() {
       RealVector bestSol = CurrentScope.Variables[SolutionParameter.ActualName].Value as RealVector;
+      RealVector bestSol = ExecutionContext.Scope.Variables[SolutionParameter.ActualName].Value as RealVector;
       if (bestSol == null)
         throw new ArgumentException("Cannot improve solution because it has the wrong type.");
+      var evaluator = Evaluator;
+      var bounds = BoundsParameter.ActualValue;
+      var function = TestFunctionParameter.ActualValue;
+      var maxIterations = ImprovementAttemptsParameter.ActualValue.Value;
       double bestSolQuality = evaluator.Evaluate(bestSol);
+      double bestSolQuality = function.Evaluate(bestSol);
       // create perturbed solutions
 …
       for (int i = 0; i < simplex.Length; i++) {
         simplex[i] = bestSol.Clone() as RealVector;
         simplex[i][i] += 0.1 * (Bounds[0, 1] - Bounds[0, 0]);
         if (simplex[i][i] > Bounds[0, 1]) simplex[i][i] = Bounds[0, 1];
         if (simplex[i][i] < Bounds[0, 0]) simplex[i][i] = Bounds[0, 0];
+        simplex[i][i] += 0.1 * (bounds[0, 1] - bounds[0, 0]);
+        if (simplex[i][i] > bounds[0, 1]) simplex[i][i] = bounds[0, 1];
+        if (simplex[i][i] < bounds[0, 0]) simplex[i][i] = bounds[0, 0];
+      }
       // improve solutions
       for (int i = 0; i < ImprovementAttempts.Value; i++) {
+      for (int i = 0; i < maxIterations; i++) {
         // order according to their objective function value
         Array.Sort(simplex, (x, y) => evaluator.Evaluate(x).CompareTo(evaluator.Evaluate(y)));
+        Array.Sort(simplex, (x, y) => function.Evaluate(x).CompareTo(function.Evaluate(y)));
         // calculate centroid
 …
         for (int j = 0; j < reflectionPoint.Length; j++)
           reflectionPoint[j] = centroid[j] + Alpha.Value * (centroid[j] - simplex[simplex.Length - 1][j]);
         double reflectionPointQuality = evaluator.Evaluate(reflectionPoint);
         if (evaluator.Evaluate(simplex[0]) <= reflectionPointQuality
             && reflectionPointQuality < evaluator.Evaluate(simplex[simplex.Length - 2]))
+        double reflectionPointQuality = function.Evaluate(reflectionPoint);
+        if (function.Evaluate(simplex[0]) <= reflectionPointQuality
+            && reflectionPointQuality < function.Evaluate(simplex[simplex.Length - 2]))
           simplex[simplex.Length - 1] = reflectionPoint;
         // expansion
         if (reflectionPointQuality < evaluator.Evaluate(simplex[0])) {
+        if (reflectionPointQuality < function.Evaluate(simplex[0])) {
           RealVector expansionPoint = new RealVector(bestSol.Length);
           for (int j = 0; j < expansionPoint.Length; j++)
             expansionPoint[j] = centroid[j] + Beta.Value * (reflectionPoint[j] - centroid[j]);
           simplex[simplex.Length - 1] = evaluator.Evaluate(expansionPoint) < reflectionPointQuality ? expansionPoint : reflectionPoint;
+          simplex[simplex.Length - 1] = function.Evaluate(expansionPoint) < reflectionPointQuality ? expansionPoint : reflectionPoint;
+        }
         // contraction
         if (evaluator.Evaluate(simplex[simplex.Length - 2]) <= reflectionPointQuality
             && reflectionPointQuality < evaluator.Evaluate(simplex[simplex.Length - 1])) {
+        if (function.Evaluate(simplex[simplex.Length - 2]) <= reflectionPointQuality
+            && reflectionPointQuality < function.Evaluate(simplex[simplex.Length - 1])) {
           RealVector outsideContractionPoint = new RealVector(bestSol.Length);
           for (int j = 0; j < outsideContractionPoint.Length; j++)
             outsideContractionPoint[j] = centroid[j] + Gamma.Value * (reflectionPoint[j] - centroid[j]);
           if (evaluator.Evaluate(outsideContractionPoint) <= reflectionPointQuality) {
+          if (function.Evaluate(outsideContractionPoint) <= reflectionPointQuality) {
             simplex[simplex.Length - 1] = outsideContractionPoint;
             if (evaluator.Evaluate(reflectionPoint) >= evaluator.Evaluate(simplex[simplex.Length - 1])) {
+            if (function.Evaluate(reflectionPoint) >= function.Evaluate(simplex[simplex.Length - 1])) {
               RealVector insideContractionPoint = new RealVector(bestSol.Length);
               for (int j = 0; j < insideContractionPoint.Length; j++)
                 insideContractionPoint[j] = centroid[j] - Gamma.Value * (reflectionPoint[j] - centroid[j]);
               if (evaluator.Evaluate(insideContractionPoint) < evaluator.Evaluate(simplex[simplex.Length - 1])) simplex[simplex.Length - 1] = insideContractionPoint;
+              if (function.Evaluate(insideContractionPoint) < function.Evaluate(simplex[simplex.Length - 1])) simplex[simplex.Length - 1] = insideContractionPoint;
+            }
+          }
 …
       for (int i = 0; i < simplex[0].Length; i++) {
         if (simplex[0][i] > Bounds[0, 1]) simplex[0][i] = Bounds[0, 1];
         if (simplex[0][i] < Bounds[0, 0]) simplex[0][i] = Bounds[0, 0];
+        if (simplex[0][i] > bounds[0, 1]) simplex[0][i] = bounds[0, 1];
+        if (simplex[0][i] < bounds[0, 0]) simplex[0][i] = bounds[0, 0];
+      }
       CurrentScope.Variables[SolutionParameter.ActualName].Value = simplex[0];
       CurrentScope.Variables.Add(new Variable("LocalEvaluatedSolutions", ImprovementAttempts));
+      ExecutionContext.Scope.Variables[SolutionParameter.ActualName].Value = simplex[0];
+      ExecutionContext.Scope.Variables.Add(new Variable("LocalEvaluatedSolutions", new IntValue(maxIterations)));
       return base.Apply();

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Instances/SOTFData.cs

r12012	r13403
39	39	/// The operator used for evaluations
40	40	/// </summary>
41		public ISingleObjectiveTestFunction~~ProblemEvaluator Evaluator~~ { get; set; }
	41	public ISingleObjectiveTestFunction TestFunction { get; set; }
42	42	}
43	43	}

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Instances/SOTFDataDescriptor.cs

-                      r12012
+                      r13403
 namespace HeuristicLab.Problems.TestFunctions {
   internal class SOTFDataDescriptor : IDataDescriptor {
     public string Name { get { return Evaluator.FunctionName + " Function"; } }
+    public string Name { get { return TestFunction.ItemName + " Function"; } }
     public string Description {
       get { return Evaluator.Description; }
+      get { return TestFunction.Description; }
+    }
     internal ISingleObjectiveTestFunctionProblemEvaluator Evaluator { get; set; }
+    internal ISingleObjectiveTestFunction TestFunction { get; set; }
     public SOTFDataDescriptor(ISingleObjectiveTestFunctionProblemEvaluator evaluator) {
       Evaluator = evaluator;
+    public SOTFDataDescriptor(ISingleObjectiveTestFunction testFunction) {
+      TestFunction = testFunction;
+    }
+  }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Instances/SOTFInstanceProvider.cs

-                      r12012
+                      r13403
     public override IEnumerable<IDataDescriptor> GetDataDescriptors() {
       var evaluators = ApplicationManager.Manager.GetInstances<ISingleObjectiveTestFunctionProblemEvaluator>()
+      var evaluators = ApplicationManager.Manager.GetInstances<ISingleObjectiveTestFunction>()
                                                  .OrderBy(x => x.Name);
       return evaluators.Select(x => new SOTFDataDescriptor(x));
 …
         Name = descriptor.Name,
         Description = descriptor.Description,
         Evaluator = descriptor.Evaluator
+        TestFunction = descriptor.TestFunction
       };
+    }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/IBestSingleObjectiveTestFunctionSolutionAnalyzer.cs

-                      r12012
+                      r13403
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
 using HeuristicLab.Optimization;
 …
   /// An interface which represents operators for analyzing the best solution of single objective TestFunction Problems given in real vector representation.
   /// </summary>
   public interface IBestSingleObjectiveTestFunctionSolutionAnalyzer : IAnalyzer, ISingleObjectiveOperator {
     ILookupParameter RealVectorParameter { get; }
     ILookupParameter QualityParameter { get; }
+  public interface IBestSingleObjectiveTestFunctionSolutionAnalyzer : IAnalyzer, ISingleObjectiveOperator,
+    IRealVectorSolutionsOperator, IRealVectorBoundedOperator {
+    IScopeTreeLookupParameter<DoubleValue> QualityParameter { get; }
     ILookupParameter<SingleObjectiveTestFunctionSolution> BestSolutionParameter { get; }
     IValueLookupParameter<ResultCollection> ResultsParameter { get; }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunction.cs

-                      r13393
+                      r13403
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.RealVectorEncoding;
-using HeuristicLab.Optimization;
 namespace HeuristicLab.Problems.TestFunctions {
 …
   /// An interface which represents an evaluation operator for single objective test functions.
   /// </summary>
   public interface ISingleObjectiveTestFunctionProblemEvaluator : ISingleObjectiveEvaluator {
+  public interface ISingleObjectiveTestFunction : INamedItem {
     bool Maximization { get; }
     DoubleMatrix Bounds { get; }
 …
     int MinimumProblemSize { get; }
     int MaximumProblemSize { get; }
-    string FunctionName { get; }
-    ILookupParameter<RealVector> PointParameter { get; }
     double Evaluate2D(double x, double y);

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionAdditiveMoveEvaluator.cs

r12012	r13403
23	23
24	24	namespace HeuristicLab.Problems.TestFunctions {
25		public interface ISingleObjectiveTestFunctionAdditiveMoveEvaluator : ISingleObjectiveTestFunctionMoveEvaluator, I~~AdditiveRealVector~~MoveOperator {
	25	public interface ISingleObjectiveTestFunctionAdditiveMoveEvaluator : ISingleObjectiveTestFunctionMoveEvaluator, IRealVectorAdditiveMoveOperator {
26	26	}
27	27	}

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/Interfaces/ISingleObjectiveTestFunctionMoveEvaluator.cs

r12012	r13403
20	20	#endregion
21	21
22		~~using System;~~
23	22	using HeuristicLab.Optimization;
24	23
25	24	namespace HeuristicLab.Problems.TestFunctions {
26	25	public interface ISingleObjectiveTestFunctionMoveEvaluator : ISingleObjectiveMoveEvaluator, IMoveOperator {
27		~~Type EvaluatorType { get; }~~
28	26	}
29	27	}

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/MoveEvaluators/AdditiveMoveEvaluator.cs

-                      r12012
+                      r13403
 #endregion
-using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 …
   [Item("AdditiveMoveEvaluator", "Base class for evaluating an additive move.")]
   [StorableClass]
   public abstract class AdditiveMoveEvaluator : SingleSuccessorOperator, ISingleObjectiveTestFunctionAdditiveMoveEvaluator {
+  public class AdditiveMoveEvaluator : SingleSuccessorOperator, ISingleObjectiveTestFunctionAdditiveMoveEvaluator {
-    public abstract Type EvaluatorType { get; }
     public override bool CanChangeName {
       get { return false; }
 …
       get { return (ILookupParameter<AdditiveMove>)Parameters["AdditiveMove"]; }
+    }
+    public ILookupParameter<ISingleObjectiveTestFunction> TestFunctionParameter {
+      get { return (ILookupParameter<ISingleObjectiveTestFunction>)Parameters["TestFunction"]; }
+    }
     [StorableConstructor]
     protected AdditiveMoveEvaluator(bool deserializing) : base(deserializing) { }
     protected AdditiveMoveEvaluator(AdditiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
     protected AdditiveMoveEvaluator()
+    public AdditiveMoveEvaluator()
       : base() {
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of a test function solution."));
 …
       Parameters.Add(new LookupParameter<RealVector>("Point", "The point to evaluate the move on."));
       Parameters.Add(new LookupParameter<AdditiveMove>("AdditiveMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<ISingleObjectiveTestFunction>("TestFunction", "The test function that is used."));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AdditiveMoveEvaluator(this, cloner);
+    }
     public override IOperation Apply() {
+      double mq = Evaluate(QualityParameter.ActualValue.Value, RealVectorParameter.ActualValue, AdditiveMoveParameter.ActualValue);
+      DoubleValue moveQuality = MoveQualityParameter.ActualValue;
+      var function = TestFunctionParameter.ActualValue;
+      var move = AdditiveMoveParameter.ActualValue;
+      var vector = RealVectorParameter.ActualValue;
+      var clone = (RealVector)vector.Clone();
+      AdditiveMoveMaker.Apply(clone, move);
+      var mq = function.Evaluate(clone);
+      var moveQuality = MoveQualityParameter.ActualValue;
       if (moveQuality == null) {
         MoveQualityParameter.ActualValue = new DoubleValue(mq);
 …
       return base.Apply();
+    }
-    protected abstract double Evaluate(double quality, RealVector point, AdditiveMove move);
+  }
+}

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SimilarityCalculators/SingleObjectiveTestFunctionSimilarityCalculator.cs

r12070	r13403
37	37	[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.")]
38	38	[StorableClass]
39		public sealed class SingleObjectiveTestFunctionSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {
	39	public sealed class SingleObjectiveTestFunctionSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator, ITestFunctionSolutionSimilarityCalculator {
40	40	protected override bool IsCommutative { get { return true; } }
41	41

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs

-                      r13361
+                      r13403
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Problems.Instances;
 …
   [Creatable(CreatableAttribute.Categories.Problems, Priority = 90)]
   public sealed class SingleObjectiveTestFunctionProblem :
+    SingleObjectiveHeuristicOptimizationProblem<ISingleObjectiveTestFunctionProblemEvaluator, IRealVectorCreator>,
+    ISingleObjectiveProblem<RealVectorEncoding, RealVector>, IStorableContent, IProblemInstanceConsumer<SOTFData> {
+    public string Filename { get; set; }
+    [Storable]
+    private StdDevStrategyVectorCreator strategyVectorCreator;
+    [Storable]
+    private StdDevStrategyVectorCrossover strategyVectorCrossover;
+    [Storable]
+    private StdDevStrategyVectorManipulator strategyVectorManipulator;
+    SingleObjectiveProblem<RealVectorEncoding, RealVector>,
+    IProblemInstanceConsumer<SOTFData> {
+    public override bool Maximization {
+      get { return Parameters.ContainsKey("TestFunction") && TestFunction.Maximization; }
+    }
     #region Parameter Properties
     public ValueParameter<DoubleMatrix> BoundsParameter {
       get { return (ValueParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
     public ValueParameter<IntValue> ProblemSizeParameter {
       get { return (ValueParameter<IntValue>)Parameters["ProblemSize"]; }
+    private IFixedValueParameter<IntValue> ProblemSizeParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["ProblemSize"]; }
+    }
+    private IValueParameter<DoubleMatrix> BoundsParameter {
+      get { return (IValueParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
     public OptionalValueParameter<RealVector> BestKnownSolutionParameter {
       get { return (OptionalValueParameter<RealVector>)Parameters["BestKnownSolution"]; }
+    }
+    public IValueParameter<ISingleObjectiveTestFunction> TestFunctionParameter {
+      get { return (IValueParameter<ISingleObjectiveTestFunction>)Parameters["TestFunction"]; }
+    }
     #endregion
     #region Properties
+    public int ProblemSize {
+      get { return ProblemSizeParameter.Value.Value; }
+      set { ProblemSizeParameter.Value.Value = value; }
+    }
     public DoubleMatrix Bounds {
       get { return BoundsParameter.Value; }
       set { BoundsParameter.Value = value; }
+    }
+    public IntValue ProblemSize {
+      get { return ProblemSizeParameter.Value; }
+      set { ProblemSizeParameter.Value = value; }
+    }
+    public ISingleObjectiveTestFunction TestFunction {
+      get { return TestFunctionParameter.Value; }
+      set { TestFunctionParameter.Value = value; }
+    }
     private BestSingleObjectiveTestFunctionSolutionAnalyzer BestSingleObjectiveTestFunctionSolutionAnalyzer {
       get { return Operators.OfType<BestSingleObjectiveTestFunctionSolutionAnalyzer>().FirstOrDefault(); }
+    }
-    #endregion
-    // BackwardsCompatibility3.3
-    #region Backwards compatible code, remove with 3.4
-    [Obsolete]
-    [Storable(Name = "operators")]
-    private IEnumerable<IOperator> oldOperators {
-      get { return null; }
-      set {
-        if (value != null && value.Any())
-          Operators.AddRange(value);
+      }
+    }
     #endregion
 …
     private SingleObjectiveTestFunctionProblem(SingleObjectiveTestFunctionProblem original, Cloner cloner)
       : base(original, cloner) {
-      strategyVectorCreator = cloner.Clone(original.strategyVectorCreator);
-      strategyVectorCrossover = cloner.Clone(original.strategyVectorCrossover);
-      strategyVectorManipulator = cloner.Clone(original.strategyVectorManipulator);
       RegisterEventHandlers();
+    }
     public SingleObjectiveTestFunctionProblem()
       : base(new AckleyEvaluator(), new UniformRandomRealVectorCreator()) {
       Parameters.Add(new ValueParameter<DoubleMatrix>("Bounds", "The lower and upper bounds in each dimension.", Evaluator.Bounds));
       Parameters.Add(new ValueParameter<IntValue>("ProblemSize", "The dimension of the problem.", new IntValue(2)));
+      : base(new RealVectorEncoding("Point")) {
+      Parameters.Add(new FixedValueParameter<IntValue>("ProblemSize", "The dimensionality of the problem instance (number of variables in the function).", new IntValue(2)));
+      Parameters.Add(new ValueParameter<DoubleMatrix>("Bounds", "The bounds of the solution given as either one line for all variables or a line for each variable. The first column specifies lower bound, the second upper bound.", new DoubleMatrix(new double[,] { { -100, 100 } })));
       Parameters.Add(new OptionalValueParameter<RealVector>("BestKnownSolution", "The best known solution for this test function instance."));
+      Maximization.Value = Evaluator.Maximization;
+      BestKnownQuality = new DoubleValue(Evaluator.BestKnownQuality);
+      strategyVectorCreator = new StdDevStrategyVectorCreator();
+      strategyVectorCreator.LengthParameter.ActualName = ProblemSizeParameter.Name;
+      strategyVectorCrossover = new StdDevStrategyVectorCrossover();
+      strategyVectorManipulator = new StdDevStrategyVectorManipulator();
+      strategyVectorManipulator.LearningRateParameter.Value = new DoubleValue(0.5);
+      strategyVectorManipulator.GeneralLearningRateParameter.Value = new DoubleValue(0.5);
+      SolutionCreator.RealVectorParameter.ActualName = "Point";
+      ParameterizeSolutionCreator();
+      ParameterizeEvaluator();
+      Parameters.Add(new ValueParameter<ISingleObjectiveTestFunction>("TestFunction", "The function that is to be optimized.", new Ackley()));
+      Encoding.LengthParameter = ProblemSizeParameter;
+      Encoding.BoundsParameter = BoundsParameter;
+      BestKnownQuality = TestFunction.BestKnownQuality;
       InitializeOperators();
       RegisterEventHandlers();
-      UpdateStrategyVectorBounds();
+    }
 …
+    }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+    private void RegisterEventHandlers() {
+      Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+      TestFunctionParameter.ValueChanged += TestFunctionParameterOnValueChanged;
+      ProblemSizeParameter.Value.ValueChanged += ProblemSizeOnValueChanged;
+      BoundsParameter.ValueChanged += BoundsParameterOnValueChanged;
+    }
+    public override double Evaluate(RealVector individual, IRandom random) {
+      return TestFunction.Evaluate(individual);
+    }
     #region Events
+    protected override void OnSolutionCreatorChanged() {
+      base.OnSolutionCreatorChanged();
+      ParameterizeSolutionCreator();
+      ParameterizeAnalyzers();
+      SolutionCreator.RealVectorParameter.ActualNameChanged += new EventHandler(SolutionCreator_RealVectorParameter_ActualNameChanged);
+      SolutionCreator_RealVectorParameter_ActualNameChanged(null, EventArgs.Empty);
+    protected override void OnEncodingChanged() {
+      base.OnEncodingChanged();
+      Parameterize();
+    }
     protected override void OnEvaluatorChanged() {
       base.OnEvaluatorChanged();
+      bool problemSizeChange = ProblemSize.Value < Evaluator.MinimumProblemSize
+        || ProblemSize.Value > Evaluator.MaximumProblemSize;
+      Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+      Parameterize();
+    }
+    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+      Parameterize();
+    }
+    private void TestFunctionParameterOnValueChanged(object sender, EventArgs eventArgs) {
+      var problemSizeChange = ProblemSize < TestFunction.MinimumProblemSize
+                              || ProblemSize > TestFunction.MaximumProblemSize;
       if (problemSizeChange) {
+        ProblemSize.Value = Math.Max(Evaluator.MinimumProblemSize, Math.Min(ProblemSize.Value, Evaluator.MaximumProblemSize));
+      } else {
+        ParameterizeEvaluator();
+      }
+      UpdateMoveEvaluators();
+      ParameterizeAnalyzers();
+      Maximization.Value = Evaluator.Maximization;
+      BoundsParameter.Value = Evaluator.Bounds;
+      BestKnownQuality = new DoubleValue(Evaluator.BestKnownQuality);
+      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+      Evaluator_QualityParameter_ActualNameChanged(null, EventArgs.Empty);
+        ProblemSize = Math.Max(TestFunction.MinimumProblemSize, Math.Min(ProblemSize, TestFunction.MaximumProblemSize));
+      }
+      BestKnownQuality = TestFunction.BestKnownQuality;
+      Bounds = (DoubleMatrix)TestFunction.Bounds.Clone();
+      var bestSolution = TestFunction.GetBestKnownSolution(ProblemSize);
+      BestKnownSolutionParameter.Value = bestSolution;
       OnReset();
+    }
+    private void ProblemSizeParameter_ValueChanged(object sender, EventArgs e) {
+      ProblemSize.ValueChanged += new EventHandler(ProblemSize_ValueChanged);
+      ProblemSize_ValueChanged(null, EventArgs.Empty);
+    }
+    private void ProblemSize_ValueChanged(object sender, EventArgs e) {
+      if (ProblemSize.Value < 1) ProblemSize.Value = 1;
+      ParameterizeSolutionCreator();
+      ParameterizeEvaluator();
+      strategyVectorManipulator.GeneralLearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * ProblemSize.Value));
+      strategyVectorManipulator.LearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Math.Sqrt(ProblemSize.Value)));
+      OnReset();
+    }
+    private void SolutionCreator_RealVectorParameter_ActualNameChanged(object sender, EventArgs e) {
+      ParameterizeEvaluator();
+      ParameterizeOperators();
+      ParameterizeAnalyzers();
+    }
+    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+      ParameterizeOperators();
+    }
+    private void BoundsParameter_ValueChanged(object sender, EventArgs e) {
+      Bounds.ToStringChanged += new EventHandler(Bounds_ToStringChanged);
+      Bounds_ToStringChanged(null, EventArgs.Empty);
+    }
+    private void Bounds_ToStringChanged(object sender, EventArgs e) {
+      if (Bounds.Columns != 2 || Bounds.Rows < 1)
+        Bounds = new DoubleMatrix(1, 2);
+      ParameterizeOperators();
+      UpdateStrategyVectorBounds();
+    }
+    private void Bounds_ItemChanged(object sender, EventArgs<int, int> e) {
+      if (e.Value2 == 0 && Bounds[e.Value, 1] <= Bounds[e.Value, 0])
+        Bounds[e.Value, 1] = Bounds[e.Value, 0] + 0.1;
+      if (e.Value2 == 1 && Bounds[e.Value, 0] >= Bounds[e.Value, 1])
+        Bounds[e.Value, 0] = Bounds[e.Value, 1] - 0.1;
+      ParameterizeOperators();
+      UpdateStrategyVectorBounds();
+    }
+    private void MoveGenerator_AdditiveMoveParameter_ActualNameChanged(object sender, EventArgs e) {
+      string name = ((ILookupParameter<AdditiveMove>)sender).ActualName;
+      foreach (IAdditiveRealVectorMoveOperator op in Operators.OfType<IAdditiveRealVectorMoveOperator>()) {
+        op.AdditiveMoveParameter.ActualName = name;
+      }
+    }
+    private void SphereEvaluator_Parameter_ValueChanged(object sender, EventArgs e) {
+      SphereEvaluator eval = (Evaluator as SphereEvaluator);
+      if (eval != null) {
+        foreach (ISphereMoveEvaluator op in Operators.OfType<ISphereMoveEvaluator>()) {
+          op.C = eval.C;
+          op.Alpha = eval.Alpha;
+        }
+      }
+    }
+    private void RastriginEvaluator_Parameter_ValueChanged(object sender, EventArgs e) {
+      RastriginEvaluator eval = (Evaluator as RastriginEvaluator);
+      if (eval != null) {
+        foreach (IRastriginMoveEvaluator op in Operators.OfType<IRastriginMoveEvaluator>()) {
+          op.A = eval.A;
+        }
+      }
+    }
+    private void strategyVectorCreator_BoundsParameter_ValueChanged(object sender, EventArgs e) {
+      strategyVectorManipulator.BoundsParameter.Value = (DoubleMatrix)strategyVectorCreator.BoundsParameter.Value.Clone();
+    }
+    private void strategyVectorCreator_StrategyParameterParameter_ActualNameChanged(object sender, EventArgs e) {
+      string name = strategyVectorCreator.StrategyParameterParameter.ActualName;
+      strategyVectorCrossover.ParentsParameter.ActualName = name;
+      strategyVectorCrossover.StrategyParameterParameter.ActualName = name;
+      strategyVectorManipulator.StrategyParameterParameter.ActualName = name;
+    private void ProblemSizeOnValueChanged(object sender, EventArgs eventArgs) {
+      if (ProblemSize < TestFunction.MinimumProblemSize
+        || ProblemSize > TestFunction.MaximumProblemSize)
+        ProblemSize = Math.Min(TestFunction.MaximumProblemSize, Math.Max(TestFunction.MinimumProblemSize, ProblemSize));
+    }
+    private void BoundsParameterOnValueChanged(object sender, EventArgs eventArgs) {
+      Parameterize();
+    }
     #endregion
     #region Helpers
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      // BackwardsCompatibility3.3
-      #region Backwards compatible code (remove with 3.4)
-      if (Operators.Count == 0) InitializeOperators();
-      #endregion
-      RegisterEventHandlers();
+    }
-    private void RegisterEventHandlers() {
-      ProblemSizeParameter.ValueChanged += new EventHandler(ProblemSizeParameter_ValueChanged);
-      ProblemSize.ValueChanged += new EventHandler(ProblemSize_ValueChanged);
-      BoundsParameter.ValueChanged += new EventHandler(BoundsParameter_ValueChanged);
-      Bounds.ToStringChanged += new EventHandler(Bounds_ToStringChanged);
-      Bounds.ItemChanged += new EventHandler<EventArgs<int, int>>(Bounds_ItemChanged);
-      SolutionCreator.RealVectorParameter.ActualNameChanged += new EventHandler(SolutionCreator_RealVectorParameter_ActualNameChanged);
-      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
-      strategyVectorCreator.BoundsParameter.ValueChanged += new EventHandler(strategyVectorCreator_BoundsParameter_ValueChanged);
-      strategyVectorCreator.StrategyParameterParameter.ActualNameChanged += new EventHandler(strategyVectorCreator_StrategyParameterParameter_ActualNameChanged);
+    }
-    private void ParameterizeAnalyzers() {
-      if (BestSingleObjectiveTestFunctionSolutionAnalyzer != null) {
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.ResultsParameter.ActualName = "Results";
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.BestKnownQualityParameter.ActualName = BestKnownQualityParameter.Name;
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.BestKnownSolutionParameter.ActualName = BestKnownSolutionParameter.Name;
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.MaximizationParameter.ActualName = MaximizationParameter.Name;
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
-        BestSingleObjectiveTestFunctionSolutionAnalyzer.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
     private void InitializeOperators() {
       Operators.Add(new SingleObjectiveTestFunctionImprovementOperator());
 …
       Operators.Add(new QualitySimilarityCalculator());
       Operators.Add(new NoSimilarityCalculator());
+      Operators.Add(new AdditiveMoveEvaluator());
       Operators.Add(new BestSingleObjectiveTestFunctionSolutionAnalyzer());
       Operators.Add(new PopulationSimilarityAnalyzer(Operators.OfType<ISolutionSimilarityCalculator>()));
+      ParameterizeAnalyzers();
+      Operators.AddRange(ApplicationManager.Manager.GetInstances<IRealVectorOperator>().Cast<IOperator>());
+      Operators.Add(strategyVectorCreator);
+      Operators.Add(strategyVectorCrossover);
+      Operators.Add(strategyVectorManipulator);
+      UpdateMoveEvaluators();
+      ParameterizeOperators();
+      InitializeMoveGenerators();
+    }
+    private void InitializeMoveGenerators() {
+      foreach (IAdditiveRealVectorMoveOperator op in Operators.OfType<IAdditiveRealVectorMoveOperator>()) {
+        if (op is IMoveGenerator) {
+          op.AdditiveMoveParameter.ActualNameChanged += new EventHandler(MoveGenerator_AdditiveMoveParameter_ActualNameChanged);
+        }
+      }
+    }
+    private void UpdateMoveEvaluators() {
+      foreach (ISingleObjectiveTestFunctionMoveEvaluator op in Operators.OfType<ISingleObjectiveTestFunctionMoveEvaluator>().ToList())
+        Operators.Remove(op);
+      foreach (ISingleObjectiveTestFunctionMoveEvaluator op in ApplicationManager.Manager.GetInstances<ISingleObjectiveTestFunctionMoveEvaluator>())
+        if (op.EvaluatorType == Evaluator.GetType()) {
+          Operators.Add(op);
+          #region Synchronize evaluator specific parameters with the parameters of the corresponding move evaluators
+          if (op is ISphereMoveEvaluator) {
+            SphereEvaluator e = (Evaluator as SphereEvaluator);
+            e.AlphaParameter.ValueChanged += new EventHandler(SphereEvaluator_Parameter_ValueChanged);
+            e.CParameter.ValueChanged += new EventHandler(SphereEvaluator_Parameter_ValueChanged);
+            ISphereMoveEvaluator em = (op as ISphereMoveEvaluator);
+            em.C = e.C;
+            em.Alpha = e.Alpha;
+          } else if (op is IRastriginMoveEvaluator) {
+            RastriginEvaluator e = (Evaluator as RastriginEvaluator);
+            e.AParameter.ValueChanged += new EventHandler(RastriginEvaluator_Parameter_ValueChanged);
+            IRastriginMoveEvaluator em = (op as IRastriginMoveEvaluator);
+            em.A = e.A;
+          }
+          #endregion
+        }
+      ParameterizeOperators();
+      OnOperatorsChanged();
+    }
+    private void ParameterizeSolutionCreator() {
+      SolutionCreator.LengthParameter.Value = new IntValue(ProblemSize.Value);
+      SolutionCreator.LengthParameter.Hidden = true;
+      SolutionCreator.BoundsParameter.ActualName = BoundsParameter.Name;
+      SolutionCreator.BoundsParameter.Hidden = true;
+    }
+    private void ParameterizeEvaluator() {
+      Evaluator.PointParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
+      Evaluator.PointParameter.Hidden = true;
+      try {
+        BestKnownSolutionParameter.Value = Evaluator.GetBestKnownSolution(ProblemSize.Value);
+      }
+      catch (ArgumentException e) {
+        ErrorHandling.ShowErrorDialog(e);
+        ProblemSize.Value = Evaluator.MinimumProblemSize;
+      }
+    }
+    private void ParameterizeOperators() {
+      foreach (var op in Operators.OfType<IRealVectorCrossover>()) {
+        op.ParentsParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
+        op.ParentsParameter.Hidden = true;
+        op.ChildParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
+        op.ChildParameter.Hidden = true;
+        op.BoundsParameter.ActualName = BoundsParameter.Name;
+        op.BoundsParameter.Hidden = true;
+      }
+      foreach (var op in Operators.OfType<IRealVectorManipulator>()) {
+        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
+        op.RealVectorParameter.Hidden = true;
+        op.BoundsParameter.ActualName = BoundsParameter.Name;
+        op.BoundsParameter.Hidden = true;
+      }
+      foreach (var op in Operators.OfType<IRealVectorMoveOperator>()) {
+        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
+        op.RealVectorParameter.Hidden = true;
+      }
+      foreach (var op in Operators.OfType<IRealVectorMoveGenerator>()) {
+        op.BoundsParameter.ActualName = BoundsParameter.Name;
+        op.BoundsParameter.Hidden = true;
+      Parameterize();
+    }
+    private void Parameterize() {
+      var operators = new List<IItem>();
+      if (BestSingleObjectiveTestFunctionSolutionAnalyzer != null) {
+        operators.Add(BestSingleObjectiveTestFunctionSolutionAnalyzer);
+        BestSingleObjectiveTestFunctionSolutionAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+        BestSingleObjectiveTestFunctionSolutionAnalyzer.BestKnownQualityParameter.ActualName = BestKnownQualityParameter.Name;
+        BestSingleObjectiveTestFunctionSolutionAnalyzer.BestKnownSolutionParameter.ActualName = BestKnownSolutionParameter.Name;
+        BestSingleObjectiveTestFunctionSolutionAnalyzer.MaximizationParameter.ActualName = MaximizationParameter.Name;
+        BestSingleObjectiveTestFunctionSolutionAnalyzer.TestFunctionParameter.ActualName = TestFunctionParameter.Name;
+      }
       foreach (var op in Operators.OfType<ISingleObjectiveTestFunctionAdditiveMoveEvaluator>()) {
+        operators.Add(op);
         op.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
         op.QualityParameter.Hidden = true;
+        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
+        op.RealVectorParameter.Hidden = true;
+      }
+      foreach (var op in Operators.OfType<IRealVectorParticleCreator>()) {
+        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
+        op.RealVectorParameter.Hidden = true;
+        op.BoundsParameter.ActualName = BoundsParameter.Name;
+        op.BoundsParameter.Hidden = true;
+        op.ProblemSizeParameter.ActualName = ProblemSizeParameter.Name;
+        op.ProblemSizeParameter.Hidden = true;
+      }
+      foreach (var op in Operators.OfType<IRealVectorParticleUpdater>()) {
+        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
+        op.RealVectorParameter.Hidden = true;
+        op.BoundsParameter.ActualName = BoundsParameter.Name;
+        op.BoundsParameter.Hidden = true;
+        foreach (var movOp in Encoding.Operators.OfType<IRealVectorAdditiveMoveQualityOperator>())
+          movOp.MoveQualityParameter.ActualName = op.MoveQualityParameter.ActualName;
+      }
       foreach (var op in Operators.OfType<IRealVectorSwarmUpdater>()) {
-        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        op.RealVectorParameter.Hidden = true;
         op.MaximizationParameter.ActualName = MaximizationParameter.Name;
         op.MaximizationParameter.Hidden = true;
+      }
-      foreach (var op in Operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>()) {
-        op.RealVectorParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
-        op.RealVectorParameter.Hidden = true;
+      }
       foreach (var op in Operators.OfType<ISingleObjectiveImprovementOperator>()) {
+        op.SolutionParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
+        operators.Add(op);
+        op.SolutionParameter.ActualName = Encoding.Name;
         op.SolutionParameter.Hidden = true;
+      }
+      foreach (var op in Operators.OfType<ISingleObjectivePathRelinker>()) {
+        op.ParentsParameter.ActualName = SolutionCreator.RealVectorParameter.ActualName;
+        op.ParentsParameter.Hidden = true;
+      }
+      foreach (var op in Operators.OfType<ISolutionSimilarityCalculator>()) {
+        op.SolutionVariableName = SolutionCreator.RealVectorParameter.ActualName;
+      foreach (var op in Operators.OfType<ITestFunctionSolutionSimilarityCalculator>()) {
+        operators.Add(op);
+        op.SolutionVariableName = Encoding.Name;
         op.QualityVariableName = Evaluator.QualityParameter.ActualName;
+        var calc = op as SingleObjectiveTestFunctionSimilarityCalculator;
+        if (calc != null) calc.Bounds = Bounds;
+      }
+    }
+    private void UpdateStrategyVectorBounds() {
+      var strategyBounds = (DoubleMatrix)Bounds.Clone();
+      for (int i = 0; i < strategyBounds.Rows; i++) {
+        if (strategyBounds[i, 0] < 0) strategyBounds[i, 0] = 0;
+        strategyBounds[i, 1] = 0.1 * (Bounds[i, 1] - Bounds[i, 0]);
+      }
+      strategyVectorCreator.BoundsParameter.Value = strategyBounds;
+        op.Bounds = Bounds;
+      }
+      if (operators.Count > 0) Encoding.ConfigureOperators(operators);
+    }
     #endregion
 …
       Name = data.Name;
       Description = data.Description;
       Evaluator = data.Evaluator;
+      TestFunction = data.TestFunction;
+    }
+  }

branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionSolution.cs

-                      r12012
+                      r13403
     [Storable]
     private ISingleObjectiveTestFunctionProblemEvaluator evaluator;
     public ISingleObjectiveTestFunctionProblemEvaluator Evaluator {
       get { return evaluator; }
       set {
         if (evaluator != value) {
           evaluator = value;
+    private ISingleObjectiveTestFunction testFunction;
+    public ISingleObjectiveTestFunction TestFunction {
+      get { return testFunction; }
+      set {
+        if (testFunction != value) {
+          testFunction = value;
           OnEvaluatorChanged();
+        }
 …
       bestQuality = cloner.Clone(original.bestQuality);
       population = cloner.Clone(original.population);
       evaluator = cloner.Clone(original.evaluator);
+      testFunction = cloner.Clone(original.testFunction);
       bounds = cloner.Clone(original.bounds);
       Initialize();
+    }
     public SingleObjectiveTestFunctionSolution() : base() { }
     public SingleObjectiveTestFunctionSolution(RealVector realVector, DoubleValue quality, ISingleObjectiveTestFunctionProblemEvaluator evaluator)
+    public SingleObjectiveTestFunctionSolution(RealVector realVector, DoubleValue quality, ISingleObjectiveTestFunction testFunction)
       : base() {
       this.bestRealVector = realVector;
       this.bestQuality = quality;
       this.evaluator = evaluator;
+      this.testFunction = testFunction;
       Initialize();
+    }

Context Navigation

Legend:

Download in other formats: