Index: branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/HeuristicLab.Algorithms.ScatterSearch-3.3.csproj
===================================================================
--- branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/HeuristicLab.Algorithms.ScatterSearch-3.3.csproj	(revision 7724)
+++ branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/HeuristicLab.Algorithms.ScatterSearch-3.3.csproj	(revision 7727)
@@ -92,4 +92,5 @@
     <Compile Include="PopulationRebuildMethod.cs" />
     <Compile Include="ScatterSearch.cs" />
+    <Compile Include="ScatterSearchImprovementOperator.cs" />
     <Compile Include="ScatterSearchMainLoop.cs" />
     <Compile Include="SolutionCombinationMethod.cs" />
Index: branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearch.cs
===================================================================
--- branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearch.cs	(revision 7724)
+++ branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearch.cs	(revision 7727)
@@ -23,5 +23,4 @@
 using System.Collections.Generic;
 using System.Linq;
-using HeuristicLab.Algorithms.LocalSearch;
 using HeuristicLab.Analysis;
 using HeuristicLab.Common;
@@ -60,14 +59,17 @@
       get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
     }
+    private ValueParameter<ILocalImprovementOperator> ImproverParameter {
+      get { return (ValueParameter<ILocalImprovementOperator>)Parameters["Improver"]; }
+    }
     private ValueParameter<IntValue> MaximumIterationsParameter {
       get { return (ValueParameter<IntValue>)Parameters["MaximumIterations"]; }
     }
-    public ConstrainedValueParameter<ISingleObjectiveMoveEvaluator> MoveEvaluatorParameter {
+    private ConstrainedValueParameter<ISingleObjectiveMoveEvaluator> MoveEvaluatorParameter {
       get { return (ConstrainedValueParameter<ISingleObjectiveMoveEvaluator>)Parameters["MoveEvaluator"]; }
     }
-    public ConstrainedValueParameter<IMoveGenerator> MoveGeneratorParameter {
+    private ConstrainedValueParameter<IMoveGenerator> MoveGeneratorParameter {
       get { return (ConstrainedValueParameter<IMoveGenerator>)Parameters["MoveGenerator"]; }
     }
-    public ConstrainedValueParameter<IMoveMaker> MoveMakerParameter {
+    private ConstrainedValueParameter<IMoveMaker> MoveMakerParameter {
       get { return (ConstrainedValueParameter<IMoveMaker>)Parameters["MoveMaker"]; }
     }
@@ -106,4 +108,8 @@
       set { AnalyzerParameter.Value = value; }
     }
+    public ILocalImprovementOperator Improver {
+      get { return ImproverParameter.Value; }
+      set { ImproverParameter.Value = value; }
+    }
     public IntValue MaximumIterations {
       get { return MaximumIterationsParameter.Value; }
@@ -148,5 +154,5 @@
 
     [Storable]
-    private BestAverageWorstQualityAnalyzer moveQualityAnalyzer;
+    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
     #endregion
 
@@ -159,5 +165,5 @@
     private ScatterSearch(ScatterSearch original, Cloner cloner)
       : base(original, cloner) {
-      moveQualityAnalyzer = cloner.Clone(original.moveQualityAnalyzer);
+      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
       Initialize();
     }
@@ -169,9 +175,10 @@
       #region Create parameters
       Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze the solution and moves.", new MultiAnalyzer()));
-      Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(5)));
+      Parameters.Add(new ValueParameter<ILocalImprovementOperator>("Improver", "The operator used to improve solutions.", new ScatterSearchImprovementOperator()));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed.", new IntValue(1000)));
       Parameters.Add(new ConstrainedValueParameter<ISingleObjectiveMoveEvaluator>("MoveEvaluator", "The operator used to evaluate a move."));
       Parameters.Add(new ConstrainedValueParameter<IMoveGenerator>("MoveGenerator", "The operator used to generate moves to the neighborhood of the current solution."));
       Parameters.Add(new ConstrainedValueParameter<IMoveMaker>("MoveMaker", "The operator used to perform a move."));
-      Parameters.Add(new ValueParameter<IntValue>("NumberOfHighQualitySolutions", "The number of high quality solutions that should be added to the reference set.", new IntValue(6)));
+      Parameters.Add(new ValueParameter<IntValue>("NumberOfHighQualitySolutions", "The number of high quality solutions that should be added to the reference set.", new IntValue(5)));
       Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population.", new IntValue(30)));
       Parameters.Add(new ValueParameter<IntValue>("ReferenceSetSize", "The size of the reference set.", new IntValue(10)));
@@ -185,5 +192,6 @@
       SolutionsCreator solutionsCreator = new SolutionsCreator();
       UniformSubScopesProcessor uniformSubScopesProcessor = new UniformSubScopesProcessor();
-      LocalSearchImprovementOperator localImprovementOperator = new LocalSearchImprovementOperator();
+      Placeholder solutionEvaluator = new Placeholder();
+      Placeholder solutionImprover = new Placeholder();
       BestSelector bestSelector = new BestSelector();
       VariableCreator variableCreator = new VariableCreator();
@@ -203,11 +211,14 @@
       solutionsCreator.Successor = uniformSubScopesProcessor;
 
-      uniformSubScopesProcessor.Operator = localImprovementOperator;
+      uniformSubScopesProcessor.Operator = solutionImprover;
       uniformSubScopesProcessor.Successor = bestSelector;
 
-      localImprovementOperator.Name = "ImprovementMethod";
-      localImprovementOperator.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
-      localImprovementOperator.SampleSizeParameter.ActualName = SampleSizeParameter.Name;
-      localImprovementOperator.Successor = null;
+      solutionImprover.Name = "SolutionImprover";
+      solutionImprover.OperatorParameter.ActualName = "Improver";
+      solutionImprover.Successor = solutionEvaluator;
+
+      solutionEvaluator.Name = "SolutionEvaluator";
+      solutionEvaluator.OperatorParameter.ActualName = "Evaluator";
+      solutionEvaluator.Successor = null;
 
       bestSelector.NumberOfSelectedSubScopesParameter.ActualName = NumberOfHighQualitySolutionsParameter.Name;
@@ -233,5 +244,5 @@
       #endregion
 
-      moveQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
       ParameterizeAnalyzers();
       UpdateAnalyzers();
@@ -318,5 +329,4 @@
       ParameterizeMoveEvaluators();
       ParameterizeMoveMakers();
-      ParameterizeAnalyzers();
     }
     #endregion
@@ -397,5 +407,5 @@
         }
       }
-      Analyzer.Operators.Add(moveQualityAnalyzer, moveQualityAnalyzer.EnabledByDefault);
+      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
     }
     private void ClearMoveParameters() {
@@ -450,18 +460,17 @@
     }
     private void ParameterizeAnalyzers() {
-      moveQualityAnalyzer.ResultsParameter.ActualName = "Results";
-      moveQualityAnalyzer.ResultsParameter.Hidden = true;
-      if (Problem != null) {
-        moveQualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
-        moveQualityAnalyzer.MaximizationParameter.Hidden = true;
+      qualityAnalyzer.ResultsParameter.ActualName = "Results";
+      qualityAnalyzer.ResultsParameter.Hidden = true;
+      if (Problem != null) {
+        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+        qualityAnalyzer.MaximizationParameter.Hidden = true;
         if (MoveEvaluator != null) {
-          moveQualityAnalyzer.QualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
-          moveQualityAnalyzer.QualityParameter.Hidden = true;
-        } else moveQualityAnalyzer.QualityParameter.Hidden = false;
-        moveQualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
-        moveQualityAnalyzer.BestKnownQualityParameter.Hidden = true;
+          qualityAnalyzer.QualityParameter.Hidden = true;
+        } else qualityAnalyzer.QualityParameter.Hidden = false;
+        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+        qualityAnalyzer.BestKnownQualityParameter.Hidden = true;
       } else {
-        moveQualityAnalyzer.MaximizationParameter.Hidden = false;
-        moveQualityAnalyzer.BestKnownQualityParameter.Hidden = false;
+        qualityAnalyzer.MaximizationParameter.Hidden = false;
+        qualityAnalyzer.BestKnownQualityParameter.Hidden = false;
       }
     }
Index: branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearchImprovementOperator.cs
===================================================================
--- branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearchImprovementOperator.cs	(revision 7727)
+++ branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearchImprovementOperator.cs	(revision 7727)
@@ -0,0 +1,167 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.Knapsack;
+
+namespace HeuristicLab.Algorithms.ScatterSearch {
+  /// <summary>
+  /// An operator that improves knapsack solutions.
+  /// </summary>
+  [Item("ScatterSearchImprovementOperator", "An operator that improves knapsack solutions.")]
+  [StorableClass]
+  public sealed class ScatterSearchImprovementOperator : SingleSuccessorOperator, ILocalImprovementOperator {
+
+    #region Problem properties
+    public Type ProblemType {
+      get { return typeof(KnapsackProblem); }
+    }
+    [Storable]
+    private KnapsackProblem problem;
+    public IProblem Problem {
+      get { return problem; }
+      set { problem = (KnapsackProblem)value; }
+    }
+    #endregion
+
+    #region Parameter properties
+    public ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+    public ILookupParameter<IntArray> ValuesParameter {
+      get { return (ILookupParameter<IntArray>)Parameters["Values"]; }
+    }
+    public ILookupParameter<IntArray> WeightsParameter {
+      get { return (ILookupParameter<IntArray>)Parameters["Weights"]; }
+    }
+    public ILookupParameter<IntValue> KnapsackCapacityParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["KnapsackCapacity"]; }
+    }
+    #region ILocalImprovementOperator Parameters
+    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
+    }
+    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
+    }
+    public ILookupParameter<ResultCollection> ResultsParameter {
+      get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+    #endregion
+    #endregion
+
+    #region Properties
+    public IScope CurrentScope {
+      get { return CurrentScopeParameter.ActualValue; }
+    }
+    public IntArray Values {
+      get { return ValuesParameter.ActualValue; }
+      set { ValuesParameter.ActualValue = value; }
+    }
+    public IntArray Weights {
+      get { return WeightsParameter.ActualValue; }
+      set { WeightsParameter.ActualValue = value; }
+    }
+    public IntValue KnapsackCapacity {
+      get { return KnapsackCapacityParameter.ActualValue; }
+      set { KnapsackCapacityParameter.ActualValue = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private ScatterSearchImprovementOperator(bool deserializing) : base(deserializing) { }
+    private ScatterSearchImprovementOperator(ScatterSearchImprovementOperator original, Cloner cloner)
+      : base(original, cloner) {
+      this.problem = cloner.Clone(original.problem);
+    }
+    public ScatterSearchImprovementOperator()
+      : base() {
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope."));
+      Parameters.Add(new LookupParameter<IntArray>("Values", "The values of the items."));
+      Parameters.Add(new LookupParameter<IntArray>("Weights", "The weights of the items."));
+      Parameters.Add(new LookupParameter<IntValue>("KnapsackCapacity", "The size of the knapsack."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ScatterSearchImprovementOperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      BinaryVector sol = CurrentScope.Variables["KnapsackSolution"].Value as BinaryVector;
+
+      // calculate value-to-weight ratio
+      double[] ratio = new double[Values.Length];
+      for (int i = 0; i < ratio.Length; i++) {
+        ratio[i] = (double)Values[i] / (double)Weights[i];
+      }
+
+      // calculate order for ratio
+      int[] order = new int[ratio.Length];
+      ratio.Select((x, index) => new { Value = x, ValueIndex = index })
+           .OrderBy(x => x.Value)
+           .Select((x, index) => new { ValueIndex = x.ValueIndex, ItemIndex = index }).ToList()
+           .ForEach(x => order[x.ItemIndex] = x.ValueIndex);
+
+      int j = sol.Length - 1;
+      while (!IsFeasible(sol) && j >= 0) {
+        sol[order[j--]] = false;
+      }
+
+      // calculate weight
+      int lhs = 0;
+      for (int i = 0; i < sol.Length; i++) {
+        if (sol[i]) lhs += Weights[i];
+      }
+
+      // improve solution
+      bool feasible = true; j = 0;
+      while (feasible && j < sol.Length) {
+        while (sol[order[j]]) j++;
+        if (lhs + Weights[order[j]] <= KnapsackCapacity.Value) {
+          sol[order[j]] = true;
+          lhs += Weights[order[j]];
+        } else {
+          feasible = false;
+        }
+      }
+
+      CurrentScope.Variables["KnapsackSolution"].Value = sol;
+
+      return base.Apply();
+    }
+
+    private bool IsFeasible(BinaryVector sol) {
+      int sum = 0;
+      for (int i = 0; i < sol.Length; i++)
+        if (sol[i]) sum += Weights[i];
+      return sum <= KnapsackCapacity.Value;
+    }
+  }
+}
Index: branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearchMainLoop.cs
===================================================================
--- branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearchMainLoop.cs	(revision 7724)
+++ branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearchMainLoop.cs	(revision 7727)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Algorithms.LocalSearch;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -74,12 +73,18 @@
       get { return (LookupParameter<VariableCollection>)Parameters["Results"]; }
     }
-    internal LookupParameter<IOperator> MoveEvaluatorParameter {
-      get { return (LookupParameter<IOperator>)Parameters["MoveEvaluator"]; }
-    }
-    internal LookupParameter<IOperator> MoveGeneratorParameter {
-      get { return (LookupParameter<IOperator>)Parameters["MoveGenerator"]; }
-    }
-    internal LookupParameter<IOperator> MoveMakerParameter {
-      get { return (LookupParameter<IOperator>)Parameters["MoveMaker"]; }
+    internal LookupParameter<ISingleObjectiveMoveEvaluator> MoveEvaluatorParameter {
+      get { return (LookupParameter<ISingleObjectiveMoveEvaluator>)Parameters["MoveEvaluator"]; }
+    }
+    internal LookupParameter<IMoveGenerator> MoveGeneratorParameter {
+      get { return (LookupParameter<IMoveGenerator>)Parameters["MoveGenerator"]; }
+    }
+    internal LookupParameter<IMoveMaker> MoveMakerParameter {
+      get { return (LookupParameter<IMoveMaker>)Parameters["MoveMaker"]; }
+    }
+    internal LookupParameter<IOperator> ImproverParameter {
+      get { return (LookupParameter<IOperator>)Parameters["Improver"]; }
+    }
+    internal LookupParameter<IOperator> EvaluatorParameter {
+      get { return (LookupParameter<IOperator>)Parameters["Evaluator"]; }
     }
     internal LookupParameter<IMultiAnalyzer> AnalyzerParameter {
@@ -137,15 +142,23 @@
       set { ResultsParameter.ActualValue = value; }
     }
-    public IOperator MoveEvaluator {
+    public ISingleObjectiveMoveEvaluator MoveEvaluator {
       get { return MoveEvaluatorParameter.ActualValue; }
       set { MoveEvaluatorParameter.ActualValue = value; }
     }
-    public IOperator MoveGenerator {
+    public IMoveGenerator MoveGenerator {
       get { return MoveGeneratorParameter.ActualValue; }
       set { MoveGeneratorParameter.ActualValue = value; }
     }
-    public IOperator MoveMaker {
+    public IMoveMaker MoveMaker {
       get { return MoveMakerParameter.ActualValue; }
       set { MoveMakerParameter.ActualValue = value; }
+    }
+    public IOperator Improver {
+      get { return ImproverParameter.ActualValue; }
+      set { ImproverParameter.ActualValue = value; }
+    }
+    public IOperator Evaluator {
+      get { return EvaluatorParameter.ActualValue; }
+      set { EvaluatorParameter.ActualValue = value; }
     }
     public IMultiAnalyzer Analyzer {
@@ -178,10 +191,10 @@
       Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
       Parameters.Add(new LookupParameter<IOperator>("SolutionCreator", "The operator which is used to create new solutions."));
-      Parameters.Add(new LookupParameter<IOperator>("Evaluator", "The operator which is used to evaluate new solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
-      Parameters.Add(new LookupParameter<IOperator>("Improver", "The operator which is used to improve new solutions. This operator is executed in parallelm, if an engine is used which supports parallelization."));
+      Parameters.Add(new LookupParameter<IOperator>("Evaluator", "The operator which is used to evaluate new solutions."));
       Parameters.Add(new LookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
-      Parameters.Add(new LookupParameter<IOperator>("MoveGenerator", "The operator that generates the moves."));
-      Parameters.Add(new LookupParameter<IOperator>("MoveMaker", "The operator that performs a move and updates the quality."));
-      Parameters.Add(new LookupParameter<IOperator>("MoveEvaluator", "The operator that evaluates a move."));
+      Parameters.Add(new LookupParameter<ISingleObjectiveMoveEvaluator>("MoveEvaluator", "The operator used to evaluate a move."));
+      Parameters.Add(new LookupParameter<IMoveGenerator>("MoveGenerator", "The operator that generates the moves."));
+      Parameters.Add(new LookupParameter<IMoveMaker>("MoveMaker", "The operator that performs a move and updates the quality."));
+      Parameters.Add(new LookupParameter<IOperator>("Improver", "The operator used to improve solutions."));
       Parameters.Add(new LookupParameter<IMultiAnalyzer>("Analyzer", "The operator used to analyze the solution and moves."));
       #endregion
@@ -195,8 +208,9 @@
       ConditionalBranch terminateBranch = new ConditionalBranch();
       IntCounter interationsCounter = new IntCounter();
-      LocalSearchImprovementOperator localImprovementOperator = new LocalSearchImprovementOperator();
       Placeholder analyzer = new Placeholder();
-      Placeholder solutionImprover = new Placeholder();
-      Placeholder solutionEvaluator = new Placeholder();
+      Placeholder solutionEvaluator1 = new Placeholder();
+      Placeholder solutionEvaluator2 = new Placeholder();
+      Placeholder solutionImprover1 = new Placeholder();
+      Placeholder solutionImprover2 = new Placeholder();
       PopulationRebuildMethod populationRebuildMethod = new PopulationRebuildMethod();
       ResultsCollector resultsCollector = new ResultsCollector();
@@ -236,8 +250,11 @@
       iterationsChecker.Successor = terminateBranch;
 
-      localImprovementOperator.Name = "ImprovementMethod";
-      localImprovementOperator.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
-      localImprovementOperator.SampleSizeParameter.ActualName = SampleSizeParameter.Name;
-      localImprovementOperator.Successor = null;
+      solutionImprover2.Name = "SolutionImprover";
+      solutionImprover2.OperatorParameter.ActualName = "Improver";
+      solutionImprover2.Successor = solutionEvaluator2;
+
+      solutionEvaluator2.Name = "SolutionEvaluator";
+      solutionEvaluator2.OperatorParameter.ActualName = "Evaluator";
+      solutionEvaluator2.Successor = null;
 
       newSolutionsBranch.Name = "NewSolutionChecker";
@@ -261,11 +278,11 @@
       analyzer.OperatorParameter.ActualName = "Analyzer";
 
-      solutionImprover.Name = "SolutionImprover";
-      solutionImprover.OperatorParameter.ActualName = "LocalImprovementOperator";
-      solutionImprover.Successor = solutionEvaluator;
-
-      solutionEvaluator.Name = "SolutionEvaluator";
-      solutionEvaluator.OperatorParameter.ActualName = "Evaluator";
-      solutionEvaluator.Successor = null;
+      solutionImprover1.Name = "SolutionImprover";
+      solutionImprover1.OperatorParameter.ActualName = "Improver";
+      solutionImprover1.Successor = solutionEvaluator1;
+
+      solutionEvaluator1.Name = "SolutionEvaluator";
+      solutionEvaluator1.OperatorParameter.ActualName = "Evaluator";
+      solutionEvaluator1.Successor = null;
 
       populationRebuildMethod.Successor = subScopesProcessor3;
@@ -308,9 +325,9 @@
 
       uniformSubScopesProcessor2.DepthParameter.Value = new IntValue(1);
-      uniformSubScopesProcessor2.Operator = solutionImprover;
+      uniformSubScopesProcessor2.Operator = solutionImprover1;
       uniformSubScopesProcessor2.Successor = null;
 
       uniformSubScopesProcessor3.DepthParameter.Value = new IntValue(1);
-      uniformSubScopesProcessor3.Operator = localImprovementOperator;
+      uniformSubScopesProcessor3.Operator = solutionImprover2;
       uniformSubScopesProcessor3.Successor = null;
       #endregion
