Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs	(revision 13404)
@@ -52,5 +52,4 @@
     }
     #endregion
-
 
     public int Length {
@@ -108,4 +107,6 @@
         typeof (IBinaryVectorMoveOperator),
         typeof (IBinaryVectorMultiNeighborhoodShakingOperator),
+        typeof (IBinaryVectorSolutionOperator),
+        typeof (IBinaryVectorSolutionsOperator)
       };
     }
@@ -129,4 +130,6 @@
       ConfigureBitFlipMoveOperators(operators.OfType<IOneBitflipMoveOperator>());
       ConfigureShakingOperators(operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>());
+      ConfigureSolutionOperators(operators.OfType<IBinaryVectorSolutionOperator>());
+      ConfigureSolutionsOperators(operators.OfType<IBinaryVectorSolutionsOperator>());
     }
 
@@ -134,5 +137,4 @@
     private void ConfigureCreators(IEnumerable<IBinaryVectorCreator> creators) {
       foreach (var creator in creators) {
-        creator.BinaryVectorParameter.ActualName = Name;
         creator.LengthParameter.ActualName = LengthParameter.Name;
       }
@@ -145,12 +147,8 @@
     }
     private void ConfigureManipulators(IEnumerable<IBinaryVectorManipulator> manipulators) {
-      foreach (var manipulator in manipulators) {
-        manipulator.BinaryVectorParameter.ActualName = Name;
-      }
+      // binary vector manipulators don't contain additional parameters besides the solution parameter
     }
     private void ConfigureMoveOperators(IEnumerable<IBinaryVectorMoveOperator> moveOperators) {
-      foreach (var moveOperator in moveOperators) {
-        moveOperator.BinaryVectorParameter.ActualName = Name;
-      }
+      // binary vector move operators don't contain additional parameters besides the solution parameter
     }
     private void ConfigureBitFlipMoveOperators(IEnumerable<IOneBitflipMoveOperator> oneBitflipMoveOperators) {
@@ -160,7 +158,13 @@
     }
     private void ConfigureShakingOperators(IEnumerable<IBinaryVectorMultiNeighborhoodShakingOperator> shakingOperators) {
-      foreach (var shakingOperator in shakingOperators) {
-        shakingOperator.BinaryVectorParameter.ActualName = Name;
-      }
+      // binary vector shaking operators don't contain additional parameters besides the solution parameter
+    }
+    private void ConfigureSolutionOperators(IEnumerable<IBinaryVectorSolutionOperator> solutionOperators) {
+      foreach (var solutionOperator in solutionOperators)
+        solutionOperator.BinaryVectorParameter.ActualName = Name;
+    }
+    private void ConfigureSolutionsOperators(IEnumerable<IBinaryVectorSolutionsOperator> solutionsOperators) {
+      foreach (var solutionsOperator in solutionsOperators)
+        solutionsOperator.BinaryVectorsParameter.ActualName = Name;
     }
     #endregion
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/HeuristicLab.Encodings.BinaryVectorEncoding-3.3.csproj
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/HeuristicLab.Encodings.BinaryVectorEncoding-3.3.csproj	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/HeuristicLab.Encodings.BinaryVectorEncoding-3.3.csproj	(revision 13404)
@@ -127,4 +127,7 @@
     <Compile Include="BinaryVector.cs" />
     <Compile Include="Interfaces\IBinaryVectorMultiNeighborhoodShakingOperator.cs" />
+    <Compile Include="Interfaces\IBinaryVectorSolutionsOperator.cs" />
+    <Compile Include="Interfaces\IBinaryVectorSolutionOperator.cs" />
+    <Compile Include="Interfaces\IOneBitflipMoveQualityOperator.cs" />
     <Compile Include="Interfaces\IOneBitflipMoveOperator.cs" />
     <Compile Include="Interfaces\IBinaryVectorCreator.cs" />
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorCreator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorCreator.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorCreator.cs	(revision 13404)
@@ -28,7 +28,6 @@
   /// An interface which represents an operator for creating vectors of bool-valued data.
   /// </summary>
-  public interface IBinaryVectorCreator : IBinaryVectorOperator, ISolutionCreator<BinaryVector> {
+  public interface IBinaryVectorCreator : IBinaryVectorSolutionOperator, ISolutionCreator<BinaryVector> {
     IValueLookupParameter<IntValue> LengthParameter { get; }
-    ILookupParameter<BinaryVector> BinaryVectorParameter { get; }
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorManipulator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorManipulator.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorManipulator.cs	(revision 13404)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Optimization;
 
@@ -27,6 +26,5 @@
   /// An interface which represents an operator for manipulating vectors of bool-valued data.
   /// </summary>
-  public interface IBinaryVectorManipulator : IBinaryVectorOperator, IManipulator {
-    ILookupParameter<BinaryVector> BinaryVectorParameter { get; }
+  public interface IBinaryVectorManipulator : IBinaryVectorSolutionOperator, IManipulator {
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorMoveOperator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorMoveOperator.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorMoveOperator.cs	(revision 13404)
@@ -20,10 +20,8 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Encodings.BinaryVectorEncoding {
-  public interface IBinaryVectorMoveOperator : IBinaryVectorOperator, IMoveOperator {
-    ILookupParameter<BinaryVector> BinaryVectorParameter { get; }
+  public interface IBinaryVectorMoveOperator : IBinaryVectorSolutionOperator, IMoveOperator {
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorMultiNeighborhoodShakingOperator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorMultiNeighborhoodShakingOperator.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorMultiNeighborhoodShakingOperator.cs	(revision 13404)
@@ -20,9 +20,7 @@
 #endregion
 
-using HeuristicLab.Core;
 
 namespace HeuristicLab.Encodings.BinaryVectorEncoding {
-  public interface IBinaryVectorMultiNeighborhoodShakingOperator : IBinaryVectorOperator {
-    ILookupParameter<BinaryVector> BinaryVectorParameter { get; }
+  public interface IBinaryVectorMultiNeighborhoodShakingOperator : IBinaryVectorSolutionOperator {
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorSolutionOperator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorSolutionOperator.cs	(revision 13404)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorSolutionOperator.cs	(revision 13404)
@@ -0,0 +1,28 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Encodings.BinaryVectorEncoding {
+  public interface IBinaryVectorSolutionOperator : IBinaryVectorOperator {
+    ILookupParameter<BinaryVector> BinaryVectorParameter { get; }
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorSolutionsOperator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorSolutionsOperator.cs	(revision 13404)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorSolutionsOperator.cs	(revision 13404)
@@ -0,0 +1,28 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Encodings.BinaryVectorEncoding {
+  public interface IBinaryVectorSolutionsOperator : IBinaryVectorOperator {
+    IScopeTreeLookupParameter<BinaryVector> BinaryVectorsParameter { get; }
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IOneBitflipMoveQualityOperator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IOneBitflipMoveQualityOperator.cs	(revision 13404)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IOneBitflipMoveQualityOperator.cs	(revision 13404)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.BinaryVectorEncoding {
+  public interface IOneBitflipMoveQualityOperator : IOneBitflipMoveOperator {
+    ILookupParameter<DoubleValue> MoveQualityParameter { get; }
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Moves/OneBitflipMove/OneBitflipMoveMaker.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Moves/OneBitflipMove/OneBitflipMoveMaker.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Moves/OneBitflipMove/OneBitflipMoveMaker.cs	(revision 13404)
@@ -31,5 +31,5 @@
   [Item("OneBitflipMoveMaker", "Peforms a one bitflip move on a given BitVector and updates the quality.")]
   [StorableClass]
-  public class OneBitflipMoveMaker : SingleSuccessorOperator, IOneBitflipMoveOperator, IMoveMaker, ISingleObjectiveOperator {
+  public class OneBitflipMoveMaker : SingleSuccessorOperator, IOneBitflipMoveQualityOperator, IMoveMaker, ISingleObjectiveOperator {
     public override bool CanChangeName {
       get { return false; }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Moves/OneBitflipMove/OneBitflipMoveTabuChecker.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Moves/OneBitflipMove/OneBitflipMoveTabuChecker.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Moves/OneBitflipMove/OneBitflipMoveTabuChecker.cs	(revision 13404)
@@ -31,5 +31,5 @@
   [Item("OneBitflipMoveTabuChecker", "Prevents peforming a one bitflip move again.")]
   [StorableClass]
-  public class OneBitflipMoveTabuChecker : SingleSuccessorOperator, IOneBitflipMoveOperator, ITabuChecker {
+  public class OneBitflipMoveTabuChecker : SingleSuccessorOperator, IOneBitflipMoveQualityOperator, ITabuChecker {
     public override bool CanChangeName {
       get { return false; }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Moves/OneBitflipMove/OneBitflipMoveTabuMaker.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Moves/OneBitflipMove/OneBitflipMoveTabuMaker.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Moves/OneBitflipMove/OneBitflipMoveTabuMaker.cs	(revision 13404)
@@ -29,5 +29,5 @@
   [Item("OneBitflipMoveTabuMaker", "Declares a given one bitflip move as tabu, by adding its attributes to the tabu list. It also removes the oldest entry in the tabu list when its size is greater than tenure.")]
   [StorableClass]
-  public class OneBitflipMoveTabuMaker : TabuMaker, IOneBitflipMoveOperator {
+  public class OneBitflipMoveTabuMaker : TabuMaker, IOneBitflipMoveQualityOperator {
     public ILookupParameter<BinaryVector> BinaryVectorParameter {
       get { return (ILookupParameter<BinaryVector>)Parameters["BinaryVector"]; }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 13404)
@@ -28,7 +28,7 @@
     where TSolution : class, ISolution {
     bool Maximization { get; }
-    double Evaluate(TSolution individual, IRandom random);
-    void Analyze(TSolution[] individuals, double[] qualities, ResultCollection results, IRandom random);
-    IEnumerable<TSolution> GetNeighbors(TSolution individual, IRandom random);
+    double Evaluate(TSolution solution, IRandom random);
+    void Analyze(TSolution[] solutions, double[] qualities, ResultCollection results, IRandom random);
+    IEnumerable<TSolution> GetNeighbors(TSolution solution, IRandom random);
     bool IsBetter(double quality, double bestQuality);
   }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs	(revision 13404)
@@ -100,7 +100,7 @@
 
     public abstract bool Maximization { get; }
-    public abstract double Evaluate(TSolution individual, IRandom random);
-    public virtual void Analyze(TSolution[] individuals, double[] qualities, ResultCollection results, IRandom random) { }
-    public virtual IEnumerable<TSolution> GetNeighbors(TSolution individual, IRandom random) {
+    public abstract double Evaluate(TSolution solution, IRandom random);
+    public virtual void Analyze(TSolution[] solutions, double[] qualities, ResultCollection results, IRandom random) { }
+    public virtual IEnumerable<TSolution> GetNeighbors(TSolution solution, IRandom random) {
       return Enumerable.Empty<TSolution>();
     }
Index: /branches/ProblemRefactoring/HeuristicLab.Parameters/3.3/LookupParameter.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Parameters/3.3/LookupParameter.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Parameters/3.3/LookupParameter.cs	(revision 13404)
@@ -85,4 +85,5 @@
       : base(original, cloner) {
       actualName = original.actualName;
+      this.Hidden = original.Hidden;
       cachedActualValues = new Lazy<ThreadLocal<IItem>>(() => { return new ThreadLocal<IItem>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
       executionContexts = new Lazy<ThreadLocal<IExecutionContext>>(() => { return new ThreadLocal<IExecutionContext>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
@@ -91,5 +92,5 @@
       : base("Anonymous", typeof(T)) {
       this.actualName = Name;
-      this.Hidden = true;
+      this.Hidden = false;
       cachedActualValues = new Lazy<ThreadLocal<IItem>>(() => { return new ThreadLocal<IItem>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
       executionContexts = new Lazy<ThreadLocal<IExecutionContext>>(() => { return new ThreadLocal<IExecutionContext>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
@@ -98,5 +99,5 @@
       : base(name, typeof(T)) {
       this.actualName = Name;
-      this.Hidden = true;
+      this.Hidden = false;
       cachedActualValues = new Lazy<ThreadLocal<IItem>>(() => { return new ThreadLocal<IItem>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
       executionContexts = new Lazy<ThreadLocal<IExecutionContext>>(() => { return new ThreadLocal<IExecutionContext>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
@@ -105,5 +106,5 @@
       : base(name, description, typeof(T)) {
       this.actualName = Name;
-      this.Hidden = true;
+      this.Hidden = false;
       cachedActualValues = new Lazy<ThreadLocal<IItem>>(() => { return new ThreadLocal<IItem>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
       executionContexts = new Lazy<ThreadLocal<IExecutionContext>>(() => { return new ThreadLocal<IExecutionContext>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
@@ -112,5 +113,5 @@
       : base(name, description, typeof(T)) {
       this.actualName = string.IsNullOrWhiteSpace(actualName) ? Name : actualName;
-      this.Hidden = true;
+      this.Hidden = false;
       cachedActualValues = new Lazy<ThreadLocal<IItem>>(() => { return new ThreadLocal<IItem>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
       executionContexts = new Lazy<ThreadLocal<IExecutionContext>>(() => { return new ThreadLocal<IExecutionContext>(); }, LazyThreadSafetyMode.ExecutionAndPublication);
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Analyzers/BestKnapsackSolutionAnalyzer.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Analyzers/BestKnapsackSolutionAnalyzer.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Analyzers/BestKnapsackSolutionAnalyzer.cs	(revision 13404)
@@ -36,38 +36,38 @@
   [Item("BestKnapsackSolutionAnalyzer", "An operator for analyzing the best solution for a Knapsack problem.")]
   [StorableClass]
-  public class BestKnapsackSolutionAnalyzer : SingleSuccessorOperator, IAnalyzer, ISingleObjectiveOperator {
+  public class BestKnapsackSolutionAnalyzer : SingleSuccessorOperator, IBinaryVectorSolutionsOperator, IAnalyzer, ISingleObjectiveOperator {
     public virtual bool EnabledByDefault {
       get { return true; }
     }
 
-    public LookupParameter<BoolValue> MaximizationParameter {
-      get { return (LookupParameter<BoolValue>)Parameters["Maximization"]; }
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
-    public ScopeTreeLookupParameter<BinaryVector> BinaryVectorParameter {
-      get { return (ScopeTreeLookupParameter<BinaryVector>)Parameters["BinaryVector"]; }
+    public IScopeTreeLookupParameter<BinaryVector> BinaryVectorsParameter {
+      get { return (IScopeTreeLookupParameter<BinaryVector>)Parameters["BinaryVectors"]; }
     }
-    public LookupParameter<IntValue> KnapsackCapacityParameter {
-      get { return (LookupParameter<IntValue>)Parameters["KnapsackCapacity"]; }
+    public ILookupParameter<IntValue> KnapsackCapacityParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["KnapsackCapacity"]; }
     }
-    public LookupParameter<IntArray> WeightsParameter {
-      get { return (LookupParameter<IntArray>)Parameters["Weights"]; }
+    public ILookupParameter<IntArray> WeightsParameter {
+      get { return (ILookupParameter<IntArray>)Parameters["Weights"]; }
     }
-    public LookupParameter<IntArray> ValuesParameter {
-      get { return (LookupParameter<IntArray>)Parameters["Values"]; }
+    public ILookupParameter<IntArray> ValuesParameter {
+      get { return (ILookupParameter<IntArray>)Parameters["Values"]; }
     }
-    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
-    public LookupParameter<KnapsackSolution> BestSolutionParameter {
-      get { return (LookupParameter<KnapsackSolution>)Parameters["BestSolution"]; }
+    public ILookupParameter<KnapsackSolution> BestSolutionParameter {
+      get { return (ILookupParameter<KnapsackSolution>)Parameters["BestSolution"]; }
     }
-    public ValueLookupParameter<ResultCollection> ResultsParameter {
-      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
+    public IValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
     }
-    public LookupParameter<DoubleValue> BestKnownQualityParameter {
-      get { return (LookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
+    public ILookupParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
     }
-    public LookupParameter<BinaryVector> BestKnownSolutionParameter {
-      get { return (LookupParameter<BinaryVector>)Parameters["BestKnownSolution"]; }
+    public ILookupParameter<BinaryVector> BestKnownSolutionParameter {
+      get { return (ILookupParameter<BinaryVector>)Parameters["BestKnownSolution"]; }
     }
 
@@ -78,5 +78,5 @@
       : base() {
       Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem."));
-      Parameters.Add(new ScopeTreeLookupParameter<BinaryVector>("BinaryVector", "The Knapsack solutions from which the best solution should be visualized."));
+      Parameters.Add(new ScopeTreeLookupParameter<BinaryVector>("BinaryVectors", "The Knapsack solutions from which the best solution should be visualized."));
       Parameters.Add(new LookupParameter<IntValue>("KnapsackCapacity", "Capacity of the Knapsack."));
       Parameters.Add(new LookupParameter<IntArray>("Weights", "The weights of the items."));
@@ -95,14 +95,13 @@
 
     public override IOperation Apply() {
-      ItemArray<BinaryVector> binaryVectors = BinaryVectorParameter.ActualValue;
-      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
-      ResultCollection results = ResultsParameter.ActualValue;
-      bool max = MaximizationParameter.ActualValue.Value;
-      DoubleValue bestKnownQuality = BestKnownQualityParameter.ActualValue;
+      var binaryVectors = BinaryVectorsParameter.ActualValue;
+      var qualities = QualityParameter.ActualValue;
+      var results = ResultsParameter.ActualValue;
+      var max = MaximizationParameter.ActualValue.Value;
+      var bestKnownQuality = BestKnownQualityParameter.ActualValue;
 
       int i = -1;
-      if (!max)
-        i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
-      else i = qualities.Select((x, index) => new { index, x.Value }).OrderByDescending(x => x.Value).First().index;
+      i = !max ? qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index
+               : qualities.Select((x, index) => new { index, x.Value }).OrderByDescending(x => x.Value).First().index;
 
       if (bestKnownQuality == null ||
@@ -113,5 +112,5 @@
       }
 
-      KnapsackSolution solution = BestSolutionParameter.ActualValue;
+      var solution = BestSolutionParameter.ActualValue;
       if (solution == null) {
         solution = new KnapsackSolution((BinaryVector)binaryVectors[i].Clone(), new DoubleValue(qualities[i].Value),
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/HeuristicLab.Problems.Knapsack-3.3.csproj
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/HeuristicLab.Problems.Knapsack-3.3.csproj	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/HeuristicLab.Problems.Knapsack-3.3.csproj	(revision 13404)
@@ -114,7 +114,7 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Evaluators\KnapsackEvaluator.cs" />
     <Compile Include="Improvers\KnapsackImprovementOperator.cs" />
     <Compile Include="Interfaces\IKnapsackEvaluator.cs" />
+    <Compile Include="Interfaces\IKnapsackBitflipMoveEvaluator.cs" />
     <Compile Include="Interfaces\IKnapsackMoveEvaluator.cs" />
     <Compile Include="KnapsackProblem.cs" />
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Improvers/KnapsackImprovementOperator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Improvers/KnapsackImprovementOperator.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Improvers/KnapsackImprovementOperator.cs	(revision 13404)
@@ -125,8 +125,13 @@
       int evaluatedSolutions = 0;
       int j = sol.Length - 1;
-      while (KnapsackEvaluator.Apply(sol, KnapsackCapacity, Penalty, Weights, Values)
-                              .SumWeights.Value > KnapsackCapacity.Value && j >= 0) {
+      var totalWeight = 0.0;
+      for (var i = 0; i < sol.Length; i++) {
+        if (sol[i]) totalWeight += Weights[i];
+      }
+      evaluatedSolutions++;
+
+      while (totalWeight > KnapsackCapacity.Value && j >= 0) {
+        totalWeight -= Weights[order[j]];
         sol[order[j--]] = false;
-        evaluatedSolutions++;
       }
 
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Interfaces/IKnapsackBitflipMoveEvaluator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Interfaces/IKnapsackBitflipMoveEvaluator.cs	(revision 13404)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Interfaces/IKnapsackBitflipMoveEvaluator.cs	(revision 13404)
@@ -0,0 +1,26 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+
+namespace HeuristicLab.Problems.Knapsack {
+  public interface IKnapsackOneBitflipMoveEvaluator : IKnapsackMoveEvaluator, IOneBitflipMoveOperator { }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Interfaces/IKnapsackMoveEvaluator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Interfaces/IKnapsackMoveEvaluator.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/Interfaces/IKnapsackMoveEvaluator.cs	(revision 13404)
@@ -27,5 +27,4 @@
   public interface IKnapsackMoveEvaluator : ISingleObjectiveMoveEvaluator, IMoveOperator {
     ILookupParameter<IntValue> KnapsackCapacityParameter { get; }
-    ILookupParameter<DoubleValue> PenaltyParameter { get; }
     ILookupParameter<IntArray> WeightsParameter { get; }
     ILookupParameter<IntArray> ValuesParameter { get; }
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/KnapsackProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/KnapsackProblem.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/KnapsackProblem.cs	(revision 13404)
@@ -32,5 +32,4 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.Problems.Knapsack {
@@ -38,7 +37,6 @@
   [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 200)]
   [StorableClass]
-  public sealed class KnapsackProblem : SingleObjectiveHeuristicOptimizationProblem<IKnapsackEvaluator, IBinaryVectorCreator>,
-    ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector>, IStorableContent {
-    public string Filename { get; set; }
+  public sealed class KnapsackProblem : SingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> {
+    public override bool Maximization { get { return true; } }
 
     #region Parameter Properties
@@ -52,7 +50,4 @@
       get { return (ValueParameter<IntArray>)Parameters["Values"]; }
     }
-    public ValueParameter<DoubleValue> PenaltyParameter {
-      get { return (ValueParameter<DoubleValue>)Parameters["Penalty"]; }
-    }
     public OptionalValueParameter<BinaryVector> BestKnownSolutionParameter {
       get { return (OptionalValueParameter<BinaryVector>)Parameters["BestKnownSolution"]; }
@@ -61,7 +56,7 @@
 
     #region Properties
-    public IntValue KnapsackCapacity {
-      get { return KnapsackCapacityParameter.Value; }
-      set { KnapsackCapacityParameter.Value = value; }
+    public int KnapsackCapacity {
+      get { return KnapsackCapacityParameter.Value.Value; }
+      set { KnapsackCapacityParameter.Value.Value = value; }
     }
     public IntArray Weights {
@@ -73,8 +68,4 @@
       set { ValuesParameter.Value = value; }
     }
-    public DoubleValue Penalty {
-      get { return PenaltyParameter.Value; }
-      set { PenaltyParameter.Value = value; }
-    }
     public BinaryVector BestKnownSolution {
       get { return BestKnownSolutionParameter.Value; }
@@ -83,17 +74,4 @@
     private BestKnapsackSolutionAnalyzer BestKnapsackSolutionAnalyzer {
       get { return Operators.OfType<BestKnapsackSolutionAnalyzer>().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
@@ -105,147 +83,102 @@
       RegisterEventHandlers();
     }
+    public KnapsackProblem()
+      : base(new BinaryVectorEncoding("Selection")) {
+      Parameters.Add(new ValueParameter<IntValue>("KnapsackCapacity", "Capacity of the Knapsack.", new IntValue(1)));
+      Parameters.Add(new ValueParameter<IntArray>("Weights", "The weights of the items.", new IntArray(5)));
+      Parameters.Add(new ValueParameter<IntArray>("Values", "The values of the items.", new IntArray(5)));
+      Parameters.Add(new OptionalValueParameter<BinaryVector>("BestKnownSolution", "The best known solution of this Knapsack instance."));
+
+      InitializeRandomKnapsackInstance();
+
+      InitializeOperators();
+      RegisterEventHandlers();
+    }
+
+    public override double Evaluate(BinaryVector solution, IRandom random) {
+      var totalWeight = 0.0;
+      var totalValue = 0.0;
+      for (var i = 0; i < solution.Length; i++) {
+        if (!solution[i]) continue;
+        totalWeight += Weights[i];
+        totalValue += Values[i];
+      }
+      return totalWeight > KnapsackCapacity ? KnapsackCapacity - totalWeight : totalValue;
+    }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new KnapsackProblem(this, cloner);
     }
-    public KnapsackProblem()
-      : base(new KnapsackEvaluator(), new RandomBinaryVectorCreator()) {
-      Parameters.Add(new ValueParameter<IntValue>("KnapsackCapacity", "Capacity of the Knapsack.", new IntValue(0)));
-      Parameters.Add(new ValueParameter<IntArray>("Weights", "The weights of the items.", new IntArray(5)));
-      Parameters.Add(new ValueParameter<IntArray>("Values", "The values of the items.", new IntArray(5)));
-      Parameters.Add(new ValueParameter<DoubleValue>("Penalty", "The penalty value for each unit of overweight.", new DoubleValue(1)));
-      Parameters.Add(new OptionalValueParameter<BinaryVector>("BestKnownSolution", "The best known solution of this Knapsack instance."));
-
-      Maximization.Value = true;
-      MaximizationParameter.Hidden = true;
-
-      SolutionCreator.BinaryVectorParameter.ActualName = "KnapsackSolution";
-
-      InitializeRandomKnapsackInstance();
-
-      ParameterizeSolutionCreator();
-      ParameterizeEvaluator();
-
-      InitializeOperators();
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
       RegisterEventHandlers();
     }
 
+    private void RegisterEventHandlers() {
+      Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+      KnapsackCapacityParameter.ValueChanged += KnapsackCapacityParameter_ValueChanged;
+      WeightsParameter.ValueChanged += WeightsParameter_ValueChanged;
+      WeightsParameter.Value.Reset += WeightsValue_Reset;
+      ValuesParameter.ValueChanged += ValuesParameter_ValueChanged;
+      ValuesParameter.Value.Reset += ValuesValue_Reset;
+      // TODO: There is no even to detect if the parameter itself was changed
+      Encoding.LengthParameter.ValueChanged += Encoding_LengthParameter_ValueChanged;
+    }
+
     #region Events
+    protected override void OnEncodingChanged() {
+      base.OnEncodingChanged();
+      Parameterize();
+    }
     protected override void OnSolutionCreatorChanged() {
       base.OnSolutionCreatorChanged();
-      SolutionCreator.BinaryVectorParameter.ActualNameChanged += new EventHandler(SolutionCreator_BinaryVectorParameter_ActualNameChanged);
-      ParameterizeSolutionCreator();
-      ParameterizeEvaluator();
-      ParameterizeAnalyzer();
-      ParameterizeOperators();
+      Parameterize();
     }
     protected override void OnEvaluatorChanged() {
       base.OnEvaluatorChanged();
-      ParameterizeEvaluator();
-      ParameterizeAnalyzer();
-    }
-    private void SolutionCreator_BinaryVectorParameter_ActualNameChanged(object sender, EventArgs e) {
-      ParameterizeEvaluator();
-      ParameterizeAnalyzer();
-      ParameterizeOperators();
+      Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+      Parameterize();
+    }
+    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+      Parameterize();
     }
     private void KnapsackCapacityParameter_ValueChanged(object sender, EventArgs e) {
-      ParameterizeEvaluator();
-      ParameterizeAnalyzer();
+      Parameterize();
     }
     private void WeightsParameter_ValueChanged(object sender, EventArgs e) {
-      ParameterizeEvaluator();
-      ParameterizeAnalyzer();
-      ParameterizeSolutionCreator();
-
-      WeightsParameter.Value.Reset += new EventHandler(WeightsValue_Reset);
+      Parameterize();
+      WeightsParameter.Value.Reset += WeightsValue_Reset;
     }
     private void WeightsValue_Reset(object sender, EventArgs e) {
-      ParameterizeSolutionCreator();
-
-      if (WeightsParameter.Value != null && ValuesParameter.Value != null)
-        ((IStringConvertibleArray)ValuesParameter.Value).Length = WeightsParameter.Value.Length;
+      if (WeightsParameter.Value != null && ValuesParameter.Value != null) {
+        ((IStringConvertibleArray)ValuesParameter.Value).Length = Weights.Length;
+        Encoding.Length = Weights.Length;
+      }
+      Parameterize();
     }
     private void ValuesParameter_ValueChanged(object sender, EventArgs e) {
-      ParameterizeEvaluator();
-      ParameterizeAnalyzer();
-      ParameterizeSolutionCreator();
-
-      ValuesParameter.Value.Reset += new EventHandler(ValuesValue_Reset);
+      Parameterize();
+      ValuesParameter.Value.Reset += ValuesValue_Reset;
     }
     private void ValuesValue_Reset(object sender, EventArgs e) {
-      ParameterizeSolutionCreator();
-
-      if (WeightsParameter.Value != null && ValuesParameter.Value != null)
-        ((IStringConvertibleArray)WeightsParameter.Value).Length = ValuesParameter.Value.Length;
-    }
-    private void PenaltyParameter_ValueChanged(object sender, EventArgs e) {
-      ParameterizeEvaluator();
-    }
-    private void OneBitflipMoveParameter_ActualNameChanged(object sender, EventArgs e) {
-      string name = ((ILookupParameter<OneBitflipMove>)sender).ActualName;
-      foreach (IOneBitflipMoveOperator op in Operators.OfType<IOneBitflipMoveOperator>()) {
-        op.OneBitflipMoveParameter.ActualName = name;
-      }
+      if (WeightsParameter.Value != null && ValuesParameter.Value != null) {
+        ((IStringConvertibleArray)WeightsParameter.Value).Length = Values.Length;
+        Encoding.Length = Values.Length;
+      }
+      Parameterize();
+    }
+    private void Encoding_LengthParameter_ValueChanged(object sender, EventArgs e) {
+      if (Weights.Length != Encoding.Length) {
+        ((IStringConvertibleArray)WeightsParameter.Value).Length = Encoding.Length;
+      }
+      if (Values.Length != Encoding.Length) {
+        ((IStringConvertibleArray)ValuesParameter.Value).Length = Encoding.Length;
+      }
+      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() {
-      SolutionCreator.BinaryVectorParameter.ActualNameChanged += new EventHandler(SolutionCreator_BinaryVectorParameter_ActualNameChanged);
-      KnapsackCapacityParameter.ValueChanged += new EventHandler(KnapsackCapacityParameter_ValueChanged);
-      WeightsParameter.ValueChanged += new EventHandler(WeightsParameter_ValueChanged);
-      WeightsParameter.Value.Reset += new EventHandler(WeightsValue_Reset);
-      ValuesParameter.ValueChanged += new EventHandler(ValuesParameter_ValueChanged);
-      ValuesParameter.Value.Reset += new EventHandler(ValuesValue_Reset);
-      PenaltyParameter.ValueChanged += new EventHandler(PenaltyParameter_ValueChanged);
-    }
-    private void ParameterizeSolutionCreator() {
-      if (SolutionCreator.LengthParameter.Value == null ||
-        SolutionCreator.LengthParameter.Value.Value != WeightsParameter.Value.Length)
-        SolutionCreator.LengthParameter.Value = new IntValue(WeightsParameter.Value.Length);
-    }
-    private void ParameterizeEvaluator() {
-      if (Evaluator is KnapsackEvaluator) {
-        KnapsackEvaluator knapsackEvaluator =
-          (KnapsackEvaluator)Evaluator;
-        knapsackEvaluator.BinaryVectorParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
-        knapsackEvaluator.BinaryVectorParameter.Hidden = true;
-        knapsackEvaluator.KnapsackCapacityParameter.ActualName = KnapsackCapacityParameter.Name;
-        knapsackEvaluator.KnapsackCapacityParameter.Hidden = true;
-        knapsackEvaluator.WeightsParameter.ActualName = WeightsParameter.Name;
-        knapsackEvaluator.WeightsParameter.Hidden = true;
-        knapsackEvaluator.ValuesParameter.ActualName = ValuesParameter.Name;
-        knapsackEvaluator.ValuesParameter.Hidden = true;
-        knapsackEvaluator.PenaltyParameter.ActualName = PenaltyParameter.Name;
-        knapsackEvaluator.PenaltyParameter.Hidden = true;
-      }
-    }
-    private void ParameterizeAnalyzer() {
-      if (BestKnapsackSolutionAnalyzer != null) {
-        BestKnapsackSolutionAnalyzer.MaximizationParameter.ActualName = MaximizationParameter.Name;
-        BestKnapsackSolutionAnalyzer.MaximizationParameter.Hidden = true;
-        BestKnapsackSolutionAnalyzer.BestKnownQualityParameter.ActualName = BestKnownQualityParameter.Name;
-        BestKnapsackSolutionAnalyzer.BestKnownQualityParameter.Hidden = true;
-        BestKnapsackSolutionAnalyzer.BestKnownSolutionParameter.ActualName = BestKnownSolutionParameter.Name;
-        BestKnapsackSolutionAnalyzer.BestKnownSolutionParameter.Hidden = true;
-        BestKnapsackSolutionAnalyzer.BinaryVectorParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
-        BestKnapsackSolutionAnalyzer.BinaryVectorParameter.Hidden = true;
-        BestKnapsackSolutionAnalyzer.KnapsackCapacityParameter.ActualName = KnapsackCapacityParameter.Name;
-        BestKnapsackSolutionAnalyzer.KnapsackCapacityParameter.Hidden = true;
-        BestKnapsackSolutionAnalyzer.WeightsParameter.ActualName = WeightsParameter.Name;
-        BestKnapsackSolutionAnalyzer.WeightsParameter.Hidden = true;
-        BestKnapsackSolutionAnalyzer.ValuesParameter.ActualName = ValuesParameter.Name;
-        BestKnapsackSolutionAnalyzer.ValuesParameter.Hidden = true;
-      }
-    }
     private void InitializeOperators() {
       Operators.Add(new KnapsackImprovementOperator());
@@ -258,68 +191,66 @@
       Operators.Add(new BestKnapsackSolutionAnalyzer());
       Operators.Add(new PopulationSimilarityAnalyzer(Operators.OfType<ISolutionSimilarityCalculator>()));
-      ParameterizeAnalyzer();
-      foreach (IBinaryVectorOperator op in ApplicationManager.Manager.GetInstances<IBinaryVectorOperator>()) {
-        if (!(op is ISingleObjectiveMoveEvaluator) || (op is IKnapsackMoveEvaluator)) {
-          Operators.Add(op);
-        }
-      }
-      ParameterizeOperators();
-      InitializeMoveGenerators();
-    }
-    private void InitializeMoveGenerators() {
-      foreach (IOneBitflipMoveOperator op in Operators.OfType<IOneBitflipMoveOperator>()) {
-        if (op is IMoveGenerator) {
-          op.OneBitflipMoveParameter.ActualNameChanged += new EventHandler(OneBitflipMoveParameter_ActualNameChanged);
-        }
-      }
-    }
-    private void ParameterizeOperators() {
-      foreach (IBinaryVectorCrossover op in Operators.OfType<IBinaryVectorCrossover>()) {
-        op.ParentsParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
-        op.ParentsParameter.Hidden = true;
-        op.ChildParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
-        op.ChildParameter.Hidden = true;
-      }
-      foreach (IBinaryVectorManipulator op in Operators.OfType<IBinaryVectorManipulator>()) {
-        op.BinaryVectorParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
-        op.BinaryVectorParameter.Hidden = true;
-      }
-      foreach (IBinaryVectorMoveOperator op in Operators.OfType<IBinaryVectorMoveOperator>()) {
-        op.BinaryVectorParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
-        op.BinaryVectorParameter.Hidden = true;
-      }
-      foreach (IKnapsackMoveEvaluator op in Operators.OfType<IKnapsackMoveEvaluator>()) {
+
+      Parameterize();
+    }
+    private void Parameterize() {
+      var operators = new List<IItem>();
+
+      if (BestKnapsackSolutionAnalyzer != null) {
+        operators.Add(BestKnapsackSolutionAnalyzer);
+        BestKnapsackSolutionAnalyzer.MaximizationParameter.ActualName = MaximizationParameter.Name;
+        BestKnapsackSolutionAnalyzer.MaximizationParameter.Hidden = true;
+        BestKnapsackSolutionAnalyzer.BestKnownQualityParameter.ActualName = BestKnownQualityParameter.Name;
+        BestKnapsackSolutionAnalyzer.BestKnownQualityParameter.Hidden = true;
+        BestKnapsackSolutionAnalyzer.BestKnownSolutionParameter.ActualName = BestKnownSolutionParameter.Name;
+        BestKnapsackSolutionAnalyzer.BestKnownSolutionParameter.Hidden = true;
+        BestKnapsackSolutionAnalyzer.KnapsackCapacityParameter.ActualName = KnapsackCapacityParameter.Name;
+        BestKnapsackSolutionAnalyzer.KnapsackCapacityParameter.Hidden = true;
+        BestKnapsackSolutionAnalyzer.WeightsParameter.ActualName = WeightsParameter.Name;
+        BestKnapsackSolutionAnalyzer.WeightsParameter.Hidden = true;
+        BestKnapsackSolutionAnalyzer.ValuesParameter.ActualName = ValuesParameter.Name;
+        BestKnapsackSolutionAnalyzer.ValuesParameter.Hidden = true;
+      }
+      foreach (var op in Operators.OfType<IKnapsackMoveEvaluator>()) {
+        operators.Add(op);
         op.KnapsackCapacityParameter.ActualName = KnapsackCapacityParameter.Name;
         op.KnapsackCapacityParameter.Hidden = true;
-        op.PenaltyParameter.ActualName = PenaltyParameter.Name;
-        op.PenaltyParameter.Hidden = true;
         op.WeightsParameter.ActualName = WeightsParameter.Name;
         op.WeightsParameter.Hidden = true;
         op.ValuesParameter.ActualName = ValuesParameter.Name;
         op.ValuesParameter.Hidden = true;
-      }
-      foreach (IBinaryVectorMultiNeighborhoodShakingOperator op in Operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>()) {
-        op.BinaryVectorParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
-        op.BinaryVectorParameter.Hidden = true;
-      }
-      foreach (ISingleObjectiveImprovementOperator op in Operators.OfType<ISingleObjectiveImprovementOperator>()) {
-        op.SolutionParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
+
+        var bitflipMoveEval = op as IKnapsackOneBitflipMoveEvaluator;
+        if (bitflipMoveEval != null) {
+          foreach (var moveOp in Encoding.Operators.OfType<IOneBitflipMoveQualityOperator>()) {
+            moveOp.MoveQualityParameter.ActualName = bitflipMoveEval.MoveQualityParameter.ActualName;
+            moveOp.MoveQualityParameter.Hidden = true;
+          }
+        }
+      }
+      foreach (var op in Operators.OfType<ISingleObjectiveImprovementOperator>()) {
+        operators.Add(op);
+        op.SolutionParameter.ActualName = Encoding.Name;
         op.SolutionParameter.Hidden = true;
       }
-      foreach (ISingleObjectivePathRelinker op in Operators.OfType<ISingleObjectivePathRelinker>()) {
-        op.ParentsParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
+      foreach (var op in Operators.OfType<ISingleObjectivePathRelinker>()) {
+        operators.Add(op);
+        op.ParentsParameter.ActualName = Encoding.Name;
         op.ParentsParameter.Hidden = true;
       }
-      foreach (ISolutionSimilarityCalculator op in Operators.OfType<ISolutionSimilarityCalculator>()) {
-        op.SolutionVariableName = SolutionCreator.BinaryVectorParameter.ActualName;
+      foreach (var op in Operators.OfType<ISolutionSimilarityCalculator>()) {
+        operators.Add(op);
+        op.SolutionVariableName = Encoding.Name;
         op.QualityVariableName = Evaluator.QualityParameter.ActualName;
       }
+
+      if (operators.Count > 0) Encoding.ConfigureOperators(Operators);
     }
     #endregion
 
     private void InitializeRandomKnapsackInstance() {
-      System.Random rand = new System.Random();
-
-      int itemCount = rand.Next(10, 100);
+      var sysrand = new System.Random();
+
+      var itemCount = sysrand.Next(10, 100);
       Weights = new IntArray(itemCount);
       Values = new IntArray(itemCount);
@@ -328,6 +259,6 @@
 
       for (int i = 0; i < itemCount; i++) {
-        int value = rand.Next(1, 10);
-        int weight = rand.Next(1, 10);
+        var value = sysrand.Next(1, 10);
+        var weight = sysrand.Next(1, 10);
 
         Values[i] = value;
@@ -336,6 +267,5 @@
       }
 
-      int capacity = (int)Math.Round(0.7 * totalWeight);
-      KnapsackCapacity = new IntValue(capacity);
+      KnapsackCapacity = (int)Math.Round(0.7 * totalWeight);
     }
   }
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/MoveEvaluators/KnapsackMoveEvaluator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/MoveEvaluators/KnapsackMoveEvaluator.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/MoveEvaluators/KnapsackMoveEvaluator.cs	(revision 13404)
@@ -25,5 +25,4 @@
 using HeuristicLab.Encodings.BinaryVectorEncoding;
 using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -47,7 +46,4 @@
     public ILookupParameter<IntValue> KnapsackCapacityParameter {
       get { return (ILookupParameter<IntValue>)Parameters["KnapsackCapacity"]; }
-    }
-    public ILookupParameter<DoubleValue> PenaltyParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["Penalty"]; }
     }
     public ILookupParameter<IntArray> WeightsParameter {
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/MoveEvaluators/KnapsackOneBitflipMoveEvaluator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/MoveEvaluators/KnapsackOneBitflipMoveEvaluator.cs	(revision 13403)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Knapsack/3.3/MoveEvaluators/KnapsackOneBitflipMoveEvaluator.cs	(revision 13404)
@@ -51,17 +51,19 @@
 
     public override IOperation Apply() {
-      BinaryVector binaryVector = BinaryVectorParameter.ActualValue;
-      OneBitflipMove move = OneBitflipMoveParameter.ActualValue;
+      var move = OneBitflipMoveParameter.ActualValue;
+      var solution = BinaryVectorParameter.ActualValue;
+      var weights = WeightsParameter.ActualValue;
+      var values = ValuesParameter.ActualValue;
+      var capacity = KnapsackCapacityParameter.ActualValue.Value;
 
-      BinaryVector newSolution = new BinaryVector(binaryVector);
-      newSolution[move.Index] = !newSolution[move.Index];
+      var totalWeight = !solution[move.Index] ? weights[move.Index] : 0.0;
+      var totalValue = !solution[move.Index] ? values[move.Index] : 0.0; ;
+      for (var i = 0; i < solution.Length; i++) {
+        if (i == move.Index || !solution[i]) continue;
+        totalWeight += weights[i];
+        totalValue += values[i];
+      }
 
-      DoubleValue quality = KnapsackEvaluator.Apply(newSolution,
-        KnapsackCapacityParameter.ActualValue,
-        PenaltyParameter.ActualValue,
-        WeightsParameter.ActualValue,
-        ValuesParameter.ActualValue).Quality;
-
-      double moveQuality = quality.Value;
+      var moveQuality = totalWeight > capacity ? capacity - totalWeight : totalValue;
 
       if (MoveQualityParameter.ActualValue == null) MoveQualityParameter.ActualValue = new DoubleValue(moveQuality);
