Index: branches/ProblemRefactoring/HeuristicLab.Analysis/3.3/AlleleFrequencyAnalysis/AlleleFrequencyAnalyzer.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Analysis/3.3/AlleleFrequencyAnalysis/AlleleFrequencyAnalyzer.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Analysis/3.3/AlleleFrequencyAnalysis/AlleleFrequencyAnalyzer.cs	(revision 13396)
@@ -37,5 +37,5 @@
   [Item("AlleleFrequencyAnalyzer", "An operator for analyzing the frequency of alleles.")]
   [StorableClass]
-  public abstract class AlleleFrequencyAnalyzer<T> : SingleSuccessorOperator, IAnalyzer, ISingleObjectiveOperator where T : class, IItem {
+  public abstract class AlleleFrequencyAnalyzer<T> : SingleSuccessorOperator, IAnalyzer, ISingleObjectiveOperator where T : class, ISolution {
     public virtual bool EnabledByDefault {
       get { return false; }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs	(revision 13396)
@@ -122,5 +122,5 @@
     #endregion
 
-    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+    public override void ConfigureOperators(IEnumerable<IItem> operators) {
       ConfigureCreators(operators.OfType<IBinaryVectorCreator>());
       ConfigureCrossovers(operators.OfType<IBinaryVectorCrossover>());
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorEncoding.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorEncoding.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorEncoding.cs	(revision 13396)
@@ -187,5 +187,5 @@
     #endregion
 
-    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+    public override void ConfigureOperators(IEnumerable<IItem> operators) {
       ConfigureBoundedOperators(operators.OfType<IBoundedIntegerVectorOperator>());
       ConfigureCreators(operators.OfType<IIntegerVectorCreator>());
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageEncoding.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageEncoding.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageEncoding.cs	(revision 13396)
@@ -123,5 +123,5 @@
     #endregion
 
-    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+    public override void ConfigureOperators(IEnumerable<IItem> operators) {
       ConfigureCreators(operators.OfType<ILinearLinkageCreator>());
       ConfigureCrossovers(operators.OfType<ILinearLinkageCrossover>());
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/HeuristicLab.Encodings.PermutationEncoding-3.3.csproj
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/HeuristicLab.Encodings.PermutationEncoding-3.3.csproj	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/HeuristicLab.Encodings.PermutationEncoding-3.3.csproj	(revision 13396)
@@ -128,6 +128,12 @@
     <Compile Include="Crossovers\PositionBasedCrossover.cs" />
     <Compile Include="Crossovers\UniformLikeCrossover.cs" />
+    <Compile Include="Interfaces\IPermutationInversionMoveQualityOperator.cs" />
+    <Compile Include="Interfaces\IPermutationLocalImprovementOperator.cs" />
+    <Compile Include="Interfaces\IPermutationScrambleMoveQualityOperator.cs" />
     <Compile Include="Interfaces\IPermutationScrambleMoveOperator.cs" />
     <Compile Include="Interfaces\IPermutationMultiNeighborhoodShakingOperator.cs" />
+    <Compile Include="Interfaces\IPermutationSolutionsOperator.cs" />
+    <Compile Include="Interfaces\IPermutationSolutionOperator.cs" />
+    <Compile Include="Interfaces\IPermutationSwap2MoveQualityOperator.cs" />
     <Compile Include="Interfaces\IPermutationSwap2MoveOperator.cs" />
     <Compile Include="Interfaces\IPermutationCreator.cs" />
@@ -136,4 +142,5 @@
     <Compile Include="Interfaces\IPermutationMoveOperator.cs" />
     <Compile Include="Interfaces\IPermutationOperator.cs" />
+    <Compile Include="Interfaces\IPermutationTranslocationMoveQualityOperator.cs" />
     <Compile Include="Interfaces\IPermutationTranslocationMoveOperator.cs" />
     <Compile Include="Interfaces\IPermutationInversionMoveOperator.cs" />
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationCreator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationCreator.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationCreator.cs	(revision 13396)
@@ -28,7 +28,6 @@
   /// An interface which represents an operator for creating permutations.
   /// </summary>
-  public interface IPermutationCreator : IPermutationOperator, ISolutionCreator<Permutation> {
+  public interface IPermutationCreator : IPermutationSolutionOperator, ISolutionCreator<Permutation> {
     IValueLookupParameter<IntValue> LengthParameter { get; }
-    ILookupParameter<Permutation> PermutationParameter { get; }
     IValueParameter<PermutationType> PermutationTypeParameter { get; }
   }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationInversionMoveQualityOperator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationInversionMoveQualityOperator.cs	(revision 13396)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationInversionMoveQualityOperator.cs	(revision 13396)
@@ -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.PermutationEncoding {
+  public interface IPermutationInversionMoveQualityOperator : IPermutationInversionMoveOperator {
+    ILookupParameter<DoubleValue> MoveQualityParameter { get; }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationLocalImprovementOperator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationLocalImprovementOperator.cs	(revision 13396)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationLocalImprovementOperator.cs	(revision 13396)
@@ -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.Optimization;
+
+namespace HeuristicLab.Encodings.PermutationEncoding {
+  public interface IPermutationLocalImprovementOperator : IPermutationSolutionOperator, ILocalImprovementOperator { }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationManipulator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationManipulator.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationManipulator.cs	(revision 13396)
@@ -20,5 +20,4 @@
 #endregion
 
-using HeuristicLab.Core;
 using HeuristicLab.Optimization;
 
@@ -27,6 +26,4 @@
   /// An interface which represents an operator for manipulating solutions.
   /// </summary>
-  public interface IPermutationManipulator : IPermutationOperator, IManipulator {
-    ILookupParameter<Permutation> PermutationParameter { get; }
-  }
+  public interface IPermutationManipulator : IPermutationSolutionOperator, IManipulator { }
 }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationScrambleMoveQualityOperator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationScrambleMoveQualityOperator.cs	(revision 13396)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationScrambleMoveQualityOperator.cs	(revision 13396)
@@ -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.PermutationEncoding {
+  public interface IPermutationScrambleMoveQualityOperator : IPermutationScrambleMoveOperator {
+    ILookupParameter<DoubleValue> MoveQualityParameter { get; }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationSolutionOperator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationSolutionOperator.cs	(revision 13396)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationSolutionOperator.cs	(revision 13396)
@@ -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.PermutationEncoding {
+  public interface IPermutationSolutionOperator : IPermutationOperator {
+    ILookupParameter<Permutation> PermutationParameter { get; }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationSolutionsOperator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationSolutionsOperator.cs	(revision 13396)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationSolutionsOperator.cs	(revision 13396)
@@ -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.PermutationEncoding {
+  public interface IPermutationSolutionsOperator : IPermutationOperator {
+    IScopeTreeLookupParameter<Permutation> PermutationsParameter { get; }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationSwap2MoveQualityOperator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationSwap2MoveQualityOperator.cs	(revision 13396)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationSwap2MoveQualityOperator.cs	(revision 13396)
@@ -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.PermutationEncoding {
+  public interface IPermutationSwap2MoveQualityOperator : IPermutationSwap2MoveOperator {
+    ILookupParameter<DoubleValue> MoveQualityParameter { get; }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationTranslocationMoveQualityOperator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationTranslocationMoveQualityOperator.cs	(revision 13396)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationTranslocationMoveQualityOperator.cs	(revision 13396)
@@ -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.PermutationEncoding {
+  public interface IPermutationTranslocationMoveQualityOperator : IPermutationTranslocationMoveOperator {
+    ILookupParameter<DoubleValue> MoveQualityParameter { get; }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Scramble/ScrambleMoveMaker.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Scramble/ScrambleMoveMaker.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Scramble/ScrambleMoveMaker.cs	(revision 13396)
@@ -31,5 +31,5 @@
   [Item("ScrambleMoveMaker", "Peforms a scramble move on a given permutation and updates the quality.")]
   [StorableClass]
-  public class ScrambleMoveMaker : SingleSuccessorOperator, IPermutationScrambleMoveOperator, IMoveMaker, ISingleObjectiveOperator {
+  public class ScrambleMoveMaker : SingleSuccessorOperator, IPermutationScrambleMoveQualityOperator, IMoveMaker, ISingleObjectiveOperator {
     public override bool CanChangeName {
       get { return false; }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Swap2/Swap2MoveHardTabuCriterion.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Swap2/Swap2MoveHardTabuCriterion.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Swap2/Swap2MoveHardTabuCriterion.cs	(revision 13396)
@@ -35,5 +35,5 @@
 If the aspiration condition is activated, a move will not be considered tabu against a move in the tabu list if it leads to a better solution than the quality recorded with the move in the tabu list.")]
   [StorableClass]
-  public class Swap2MoveHardTabuCriterion : SingleSuccessorOperator, IPermutationSwap2MoveOperator, ITabuChecker {
+  public class Swap2MoveHardTabuCriterion : SingleSuccessorOperator, IPermutationSwap2MoveQualityOperator, ITabuChecker {
     public override bool CanChangeName {
       get { return false; }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Swap2/Swap2MoveMaker.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Swap2/Swap2MoveMaker.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Swap2/Swap2MoveMaker.cs	(revision 13396)
@@ -31,5 +31,5 @@
   [Item("Swap2MoveMaker", "Peforms a swap-2 move on a given permutation and updates the quality.")]
   [StorableClass]
-  public class Swap2MoveMaker : SingleSuccessorOperator, IPermutationSwap2MoveOperator, IMoveMaker, ISingleObjectiveOperator {
+  public class Swap2MoveMaker : SingleSuccessorOperator, IPermutationSwap2MoveQualityOperator, IMoveMaker, ISingleObjectiveOperator {
     public override bool CanChangeName {
       get { return false; }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Swap2/Swap2MoveSoftTabuCriterion.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Swap2/Swap2MoveSoftTabuCriterion.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Swap2/Swap2MoveSoftTabuCriterion.cs	(revision 13396)
@@ -35,5 +35,5 @@
 If the aspiration condition is activated, a move will not be considered tabu against a move in the tabu list if it leads to a better solution than the quality recorded with the move in the tabu list.")]
   [StorableClass]
-  public class Swap2MoveSoftTabuCriterion : SingleSuccessorOperator, IPermutationSwap2MoveOperator, ITabuChecker {
+  public class Swap2MoveSoftTabuCriterion : SingleSuccessorOperator, IPermutationSwap2MoveQualityOperator, ITabuChecker {
     public override bool CanChangeName {
       get { return false; }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Swap2/Swap2MoveTabuMaker.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Swap2/Swap2MoveTabuMaker.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/Swap2/Swap2MoveTabuMaker.cs	(revision 13396)
@@ -29,5 +29,5 @@
   [Item("Swap2MoveTabuMaker", "Declares a given swap-2 move as tabu, by adding its attributes to the tabu list and also store the solution quality or the move quality (whichever is better).")]
   [StorableClass]
-  public class Swap2MoveTabuMaker : TabuMaker, IPermutationSwap2MoveOperator {
+  public class Swap2MoveTabuMaker : TabuMaker, IPermutationSwap2MoveQualityOperator {
     public ILookupParameter<Permutation> PermutationParameter {
       get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/ThreeOpt/TranslocationMoveHardTabuCriterion.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/ThreeOpt/TranslocationMoveHardTabuCriterion.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/ThreeOpt/TranslocationMoveHardTabuCriterion.cs	(revision 13396)
@@ -34,5 +34,5 @@
 If the aspiration condition is activated, a move will not be considered tabu against a move in the tabu list if it leads to a better solution than the quality recorded with the move in the tabu list.")]
   [StorableClass]
-  public class TranslocationMoveHardTabuCriterion : SingleSuccessorOperator, IPermutationTranslocationMoveOperator, ITabuChecker {
+  public class TranslocationMoveHardTabuCriterion : SingleSuccessorOperator, IPermutationTranslocationMoveQualityOperator, ITabuChecker {
     public override bool CanChangeName {
       get { return false; }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/ThreeOpt/TranslocationMoveMaker.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/ThreeOpt/TranslocationMoveMaker.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/ThreeOpt/TranslocationMoveMaker.cs	(revision 13396)
@@ -31,5 +31,5 @@
   [Item("TranslocationMoveMaker", "Peforms a translocation or insertion move (3-opt) on a given permutation and updates the quality.")]
   [StorableClass]
-  public class TranslocationMoveMaker : SingleSuccessorOperator, IPermutationTranslocationMoveOperator, IMoveMaker, ISingleObjectiveOperator {
+  public class TranslocationMoveMaker : SingleSuccessorOperator, IPermutationTranslocationMoveQualityOperator, IMoveMaker, ISingleObjectiveOperator {
     public override bool CanChangeName {
       get { return false; }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/ThreeOpt/TranslocationMoveSoftTabuCriterion.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/ThreeOpt/TranslocationMoveSoftTabuCriterion.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/ThreeOpt/TranslocationMoveSoftTabuCriterion.cs	(revision 13396)
@@ -34,5 +34,5 @@
 If the aspiration condition is activated, a move will not be considered tabu against a move in the tabu list if it leads to a better solution than the quality recorded with the move in the tabu list.")]
   [StorableClass]
-  public class TranslocationMoveSoftTabuCriterion : SingleSuccessorOperator, IPermutationTranslocationMoveOperator, ITabuChecker {
+  public class TranslocationMoveSoftTabuCriterion : SingleSuccessorOperator, IPermutationTranslocationMoveQualityOperator, ITabuChecker {
     public override bool CanChangeName {
       get { return false; }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/ThreeOpt/TranslocationMoveTabuMaker.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/ThreeOpt/TranslocationMoveTabuMaker.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/ThreeOpt/TranslocationMoveTabuMaker.cs	(revision 13396)
@@ -29,5 +29,5 @@
   [Item("TranslocationMoveTabuMaker", "Declares a given translocation or insertion move (3-opt) as tabu, by adding its attributes to the tabu list.")]
   [StorableClass]
-  public class TranslocationMoveTabuMaker : TabuMaker, IPermutationTranslocationMoveOperator {
+  public class TranslocationMoveTabuMaker : TabuMaker, IPermutationTranslocationMoveQualityOperator {
     public ILookupParameter<Permutation> PermutationParameter {
       get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/TwoOpt/InversionMoveHardTabuCriterion.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/TwoOpt/InversionMoveHardTabuCriterion.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/TwoOpt/InversionMoveHardTabuCriterion.cs	(revision 13396)
@@ -35,5 +35,5 @@
 If the aspiration condition is activated, a move will not be considered tabu against a move in the tabu list if it leads to a better solution than the quality recorded with the move in the tabu list.")]
   [StorableClass]
-  public class InversionMoveHardTabuCriterion : SingleSuccessorOperator, IPermutationInversionMoveOperator, ITabuChecker {
+  public class InversionMoveHardTabuCriterion : SingleSuccessorOperator, IPermutationInversionMoveQualityOperator, ITabuChecker {
     public override bool CanChangeName {
       get { return false; }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/TwoOpt/InversionMoveMaker.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/TwoOpt/InversionMoveMaker.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/TwoOpt/InversionMoveMaker.cs	(revision 13396)
@@ -31,5 +31,5 @@
   [Item("InversionMoveMaker", "Peforms an inversion move (2-opt) on a given permutation and updates the quality.")]
   [StorableClass]
-  public class InversionMoveMaker : SingleSuccessorOperator, IPermutationInversionMoveOperator, IMoveMaker, ISingleObjectiveOperator {
+  public class InversionMoveMaker : SingleSuccessorOperator, IPermutationInversionMoveQualityOperator, IMoveMaker, ISingleObjectiveOperator {
     public override bool CanChangeName {
       get { return false; }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/TwoOpt/InversionMoveSoftTabuCriterion.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/TwoOpt/InversionMoveSoftTabuCriterion.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/TwoOpt/InversionMoveSoftTabuCriterion.cs	(revision 13396)
@@ -35,5 +35,5 @@
 If the aspiration condition is activated, a move will not be considered tabu against a move in the tabu list if it leads to a better solution than the quality recorded with the move in the tabu list.")]
   [StorableClass]
-  public class InversionMoveSoftTabuCriterion : SingleSuccessorOperator, IPermutationInversionMoveOperator, ITabuChecker {
+  public class InversionMoveSoftTabuCriterion : SingleSuccessorOperator, IPermutationInversionMoveQualityOperator, ITabuChecker {
     public override bool CanChangeName {
       get { return false; }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/TwoOpt/InversionMoveTabuMaker.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/TwoOpt/InversionMoveTabuMaker.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/TwoOpt/InversionMoveTabuMaker.cs	(revision 13396)
@@ -29,5 +29,5 @@
   [Item("InversionMoveTabuMaker", "Declares a given inversion move (2-opt) as tabu, by adding its attributes to the tabu list and also store the solution quality or the move quality (whichever is better).")]
   [StorableClass]
-  public class InversionMoveTabuMaker : TabuMaker, IPermutationInversionMoveOperator {
+  public class InversionMoveTabuMaker : TabuMaker, IPermutationInversionMoveQualityOperator {
     public ILookupParameter<Permutation> PermutationParameter {
       get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationEncoding.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationEncoding.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationEncoding.cs	(revision 13396)
@@ -145,5 +145,8 @@
           typeof (IPermutationScrambleMoveOperator),
           typeof (IPermutationSwap2MoveOperator),                    
-          typeof (IPermutationTranslocationMoveOperator)
+          typeof (IPermutationTranslocationMoveOperator),
+          typeof (IPermutationLocalImprovementOperator),
+          typeof (IPermutationSolutionOperator),
+          typeof (IPermutationSolutionsOperator),
       };
     }
@@ -160,5 +163,5 @@
     #endregion
 
-    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+    public override void ConfigureOperators(IEnumerable<IItem> operators) {
       ConfigureCreators(operators.OfType<IPermutationCreator>());
       ConfigureCrossovers(operators.OfType<IPermutationCrossover>());
@@ -170,4 +173,7 @@
       ConfigureSwap2MoveOperators(operators.OfType<IPermutationSwap2MoveOperator>());
       ConfigureTranslocationMoveOperators(operators.OfType<IPermutationTranslocationMoveOperator>());
+      ConfigureLocalImprovementOperators(operators.OfType<IPermutationLocalImprovementOperator>());
+      ConfigureSolutionOperators(operators.OfType<IPermutationSolutionOperator>());
+      ConfigureSolutionsOperators(operators.OfType<IPermutationSolutionsOperator>());
     }
 
@@ -176,5 +182,4 @@
       foreach (var creator in creators) {
         creator.LengthParameter.ActualName = LengthParameter.Name;
-        creator.PermutationParameter.ActualName = Name;
         creator.PermutationTypeParameter.Value.Value = Type;
       }
@@ -187,7 +192,5 @@
     }
     private void ConfigureManipulators(IEnumerable<IPermutationManipulator> manipulators) {
-      foreach (var manipulator in manipulators) {
-        manipulator.PermutationParameter.ActualName = Name;
-      }
+      // IPermutationManipulator does not contain additional parameters (already contained in IPermutationSolutionOperator)
     }
     private void ConfigureShakingOperators(IEnumerable<IPermutationMultiNeighborhoodShakingOperator> shakingOperators) {
@@ -221,5 +224,17 @@
       }
     }
-
+    private void ConfigureLocalImprovementOperators(IEnumerable<IPermutationLocalImprovementOperator> localImprovementOperators) {
+      // IPermutationLocalImprovementOperator does not contain additional parameters (already contained in IPermutationSolutionOperator)
+    }
+    private void ConfigureSolutionOperators(IEnumerable<IPermutationSolutionOperator> solutionOperators) {
+      foreach (var solutionOperator in solutionOperators) {
+        solutionOperator.PermutationParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureSolutionsOperators(IEnumerable<IPermutationSolutionsOperator> solutionsOperators) {
+      foreach (var solutionsOperator in solutionsOperators) {
+        solutionsOperator.PermutationsParameter.ActualName = Name;
+      }
+    }
     #endregion
   }
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorEncoding.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorEncoding.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorEncoding.cs	(revision 13396)
@@ -197,5 +197,5 @@
     }
 
-    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+    public override void ConfigureOperators(IEnumerable<IItem> operators) {
       ConfigureCreators(operators.OfType<IRealVectorCreator>());
       ConfigureCrossovers(operators.OfType<IRealVectorCrossover>());
Index: branches/ProblemRefactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeEncoding.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeEncoding.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeEncoding.cs	(revision 13396)
@@ -282,5 +282,5 @@
     #region Specific operator wiring
 
-    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+    public override void ConfigureOperators(IEnumerable<IItem> operators) {
       ConfigureTreeOperators(operators.OfType<ISymbolicExpressionTreeOperator>());
       ConfigureSizeConstraintOperators(operators.OfType<ISymbolicExpressionTreeSizeConstraintOperator>());
Index: branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/CombinedEncoding.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/CombinedEncoding.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/CombinedEncoding.cs	(revision 13396)
@@ -88,5 +88,5 @@
     }
 
-    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+    public override void ConfigureOperators(IEnumerable<IItem> operators) {
       foreach (var encOp in operators.OfType<IMultiEncodingOperator>())
         encOp.SolutionParameter.ActualName = Name;
Index: branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Encoding.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Encoding.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Encoding.cs	(revision 13396)
@@ -100,6 +100,6 @@
     }
 
-    public void ConfigureOperator(IOperator @operator) { ConfigureOperators(new[] { @operator }); }
-    public abstract void ConfigureOperators(IEnumerable<IOperator> operators);
+    public void ConfigureOperator(IItem @operator) { ConfigureOperators(new[] { @operator }); }
+    public abstract void ConfigureOperators(IEnumerable<IItem> operators);
 
     public event EventHandler SolutionCreatorChanged;
Index: branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncoding.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncoding.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncoding.cs	(revision 13396)
@@ -29,6 +29,6 @@
     IEnumerable<IOperator> Operators { get; set; }
 
-    void ConfigureOperator(IOperator @operator);
-    void ConfigureOperators(IEnumerable<IOperator> operators);
+    void ConfigureOperator(IItem @operator);
+    void ConfigureOperators(IEnumerable<IItem> operators);
 
     event EventHandler SolutionCreatorChanged;
Index: branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Problem.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Problem.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Problem.cs	(revision 13396)
@@ -35,5 +35,5 @@
     where TEvaluator : class, IEvaluator {
 
-    public string Filename { get; set; }
+    public string Filename { get; set; } // TODO: Really okay here?
 
     protected IValueParameter<TEncoding> EncodingParameter {
@@ -71,4 +71,13 @@
         Parameterize();
       }
+      RegisterEvents();
+    }
+    protected Problem(TEncoding encoding) {
+      if (encoding == null) throw new ArgumentNullException("encoding");
+      Parameters.Add(new ValueParameter<TEncoding>("Encoding", "Describes the configuration of the encoding, what the variables are called, what type they are and their bounds if any.", encoding));
+      oldEncoding = Encoding;
+      SolutionCreator = Encoding.SolutionCreator;
+      Parameterize();
+
       RegisterEvents();
     }
Index: branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs	(revision 13396)
@@ -41,4 +41,8 @@
     }
 
+    protected IFixedValueParameter<BoolValue> MaximizationParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+
     public double BestKnownQuality {
       get {
@@ -62,4 +66,19 @@
     protected SingleObjectiveProblem()
       : base() {
+      Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", (BoolValue)new BoolValue(Maximization).AsReadOnly()) { Hidden = true });
+      Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this problem."));
+
+      Operators.Add(Evaluator);
+      Operators.Add(new SingleObjectiveAnalyzer<TSolution>());
+      Operators.Add(new SingleObjectiveImprover<TSolution>());
+      Operators.Add(new SingleObjectiveMoveEvaluator<TSolution>());
+      Operators.Add(new SingleObjectiveMoveGenerator<TSolution>());
+      Operators.Add(new SingleObjectiveMoveMaker<TSolution>());
+
+      ParameterizeOperators();
+    }
+
+    protected SingleObjectiveProblem(TEncoding encoding)
+      : base(encoding) {
       Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", (BoolValue)new BoolValue(Maximization).AsReadOnly()) { Hidden = true });
       Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this problem."));
Index: branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/ISolutionCreator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/ISolutionCreator.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/ISolutionCreator.cs	(revision 13396)
@@ -28,4 +28,6 @@
   public interface ISolutionCreator : IOperator { }
 
-  public interface ISolutionCreator<TSolution> : ISolutionCreator where TSolution : class, ISolution { }
+  public interface ISolutionCreator<TSolution> : ISolutionCreator where TSolution : class, ISolution {
+    //ILookupParameter<TSolution> SolutionParameter { get; } // TODO: unify encoding specific parameters by defining ISolutionOperator and ISolutionsOperator
+  }
 }
Index: branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSeachOperator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSeachOperator.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSeachOperator.cs	(revision 13396)
@@ -31,7 +31,7 @@
 
 namespace HeuristicLab.Problems.QuadraticAssignment.Algorithms {
-  [Item("RobustTabooSearchOperator", "Performs an iteration of the robust taboo search algorithm as descrbied in Taillard 1991.")]
+  [Item("RobustTabooSearchOperator", "Performs an iteration of the robust taboo search algorithm as described in Taillard 1991.")]
   [StorableClass]
-  public sealed class RobustTabooSeachOperator : SingleSuccessorOperator, IIterationBasedOperator, IStochasticOperator, ISingleObjectiveOperator {
+  public sealed class RobustTabooSeachOperator : SingleSuccessorOperator, IIterationBasedOperator, IStochasticOperator, ISingleObjectiveOperator, IPermutationSolutionOperator {
 
     #region Parameter Properties
Index: branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSearch.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSearch.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment.Algorithms/3.3/RobustTabooSearch.cs	(revision 13396)
@@ -401,7 +401,8 @@
 
         mainOperator.DistancesParameter.ActualName = Problem.DistancesParameter.Name;
-        mainOperator.PermutationParameter.ActualName = Problem.SolutionCreator.PermutationParameter.ActualName;
         mainOperator.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
         mainOperator.WeightsParameter.ActualName = Problem.WeightsParameter.Name;
+
+        Problem.Encoding.ConfigureOperators(new IOperator[] { mainOperator });
       }
     }
Index: branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/Analyzers/BestQAPSolutionAnalyzer.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/Analyzers/BestQAPSolutionAnalyzer.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/Analyzers/BestQAPSolutionAnalyzer.cs	(revision 13396)
@@ -36,38 +36,38 @@
   [Item("BestQAPSolutionAnalyzer", "An operator for analyzing the best solution of Quadratic Assignment Problems.")]
   [StorableClass]
-  public sealed class BestQAPSolutionAnalyzer : SingleSuccessorOperator, IAnalyzer, ISingleObjectiveOperator {
+  public sealed class BestQAPSolutionAnalyzer : SingleSuccessorOperator, IAnalyzer, ISingleObjectiveOperator, IPermutationSolutionsOperator {
     public 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 LookupParameter<DoubleMatrix> DistancesParameter {
-      get { return (LookupParameter<DoubleMatrix>)Parameters["Distances"]; }
+    public ILookupParameter<DoubleMatrix> DistancesParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Distances"]; }
     }
-    public LookupParameter<DoubleMatrix> WeightsParameter {
-      get { return (LookupParameter<DoubleMatrix>)Parameters["Weights"]; }
+    public ILookupParameter<DoubleMatrix> WeightsParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Weights"]; }
     }
-    public ScopeTreeLookupParameter<Permutation> PermutationParameter {
-      get { return (ScopeTreeLookupParameter<Permutation>)Parameters["Permutation"]; }
+    public IScopeTreeLookupParameter<Permutation> PermutationsParameter {
+      get { return (IScopeTreeLookupParameter<Permutation>)Parameters["Permutations"]; }
     }
-    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
-    public LookupParameter<QAPAssignment> BestSolutionParameter {
-      get { return (LookupParameter<QAPAssignment>)Parameters["BestSolution"]; }
+    public ILookupParameter<QAPAssignment> BestSolutionParameter {
+      get { return (ILookupParameter<QAPAssignment>)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<ItemSet<Permutation>> BestKnownSolutionsParameter {
-      get { return (LookupParameter<ItemSet<Permutation>>)Parameters["BestKnownSolutions"]; }
+    public ILookupParameter<ItemSet<Permutation>> BestKnownSolutionsParameter {
+      get { return (ILookupParameter<ItemSet<Permutation>>)Parameters["BestKnownSolutions"]; }
     }
-    public LookupParameter<Permutation> BestKnownSolutionParameter {
-      get { return (LookupParameter<Permutation>)Parameters["BestKnownSolution"]; }
+    public ILookupParameter<Permutation> BestKnownSolutionParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["BestKnownSolution"]; }
     }
 
@@ -83,5 +83,5 @@
       Parameters.Add(new LookupParameter<DoubleMatrix>("Distances", "The distances between the locations."));
       Parameters.Add(new LookupParameter<DoubleMatrix>("Weights", "The weights between the facilities."));
-      Parameters.Add(new ScopeTreeLookupParameter<Permutation>("Permutation", "The QAP solutions from which the best solution should be analyzed."));
+      Parameters.Add(new ScopeTreeLookupParameter<Permutation>("Permutations", "The QAP solutions from which the best solution should be analyzed."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The qualities of the QAP solutions which should be analyzed."));
       Parameters.Add(new LookupParameter<QAPAssignment>("BestSolution", "The best QAP solution."));
@@ -109,5 +109,5 @@
       DoubleMatrix distances = DistancesParameter.ActualValue;
       DoubleMatrix weights = WeightsParameter.ActualValue;
-      ItemArray<Permutation> permutations = PermutationParameter.ActualValue;
+      ItemArray<Permutation> permutations = PermutationsParameter.ActualValue;
       ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
       ResultCollection results = ResultsParameter.ActualValue;
Index: branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/Analyzers/QAPAlleleFrequencyAnalyzer.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/Analyzers/QAPAlleleFrequencyAnalyzer.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/Analyzers/QAPAlleleFrequencyAnalyzer.cs	(revision 13396)
@@ -36,9 +36,9 @@
   [StorableClass]
   public sealed class QAPAlleleFrequencyAnalyzer : AlleleFrequencyAnalyzer<Permutation> {
-    public LookupParameter<DoubleMatrix> WeightsParameter {
-      get { return (LookupParameter<DoubleMatrix>)Parameters["Weights"]; }
+    public ILookupParameter<DoubleMatrix> WeightsParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Weights"]; }
     }
-    public LookupParameter<DoubleMatrix> DistancesParameter {
-      get { return (LookupParameter<DoubleMatrix>)Parameters["Distances"]; }
+    public ILookupParameter<DoubleMatrix> DistancesParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Distances"]; }
     }
 
Index: branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/Evaluators/QAPEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/Evaluators/QAPEvaluator.cs	(revision 13390)
+++ 	(revision )
@@ -1,91 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Operators;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.QuadraticAssignment {
-  [StorableClass]
-  public class QAPEvaluator : InstrumentedOperator, IQAPEvaluator {
-
-    public ILookupParameter<Permutation> PermutationParameter {
-      get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
-    }
-    public ILookupParameter<DoubleMatrix> DistancesParameter {
-      get { return (ILookupParameter<DoubleMatrix>)Parameters["Distances"]; }
-    }
-    public ILookupParameter<DoubleMatrix> WeightsParameter {
-      get { return (ILookupParameter<DoubleMatrix>)Parameters["Weights"]; }
-    }
-    public ILookupParameter<DoubleValue> QualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
-    }
-
-    [StorableConstructor]
-    protected QAPEvaluator(bool deserializing) : base(deserializing) { }
-    protected QAPEvaluator(QAPEvaluator original, Cloner cloner) : base(original, cloner) { }
-    public QAPEvaluator() {
-      Parameters.Add(new LookupParameter<Permutation>("Permutation", "The permutation that represents the current solution."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("Distances", "The distance matrix that contains the distances between the locations."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("Weights", "The matrix with the weights between the facilities, that is how strongly they're connected to each other."));
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value aka fitness value of the solution."));
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new QAPEvaluator(this, cloner);
-    }
-
-    public static double Apply(Permutation assignment, DoubleMatrix weights, DoubleMatrix distances) {
-      double quality = 0;
-      for (int i = 0; i < assignment.Length; i++) {
-        for (int j = 0; j < assignment.Length; j++) {
-          quality += weights[i, j] * distances[assignment[i], assignment[j]];
-        }
-      }
-      return quality;
-    }
-
-    public static double Impact(int facility, Permutation assignment, DoubleMatrix weights, DoubleMatrix distances) {
-      double impact = 0;
-      for (int i = 0; i < assignment.Length; i++) {
-        impact += weights[facility, i] * distances[assignment[facility], assignment[i]];
-        impact += weights[i, facility] * distances[assignment[i], assignment[facility]];
-      }
-      return impact;
-    }
-
-    public override IOperation InstrumentedApply() {
-      Permutation assignment = PermutationParameter.ActualValue;
-      DoubleMatrix weights = WeightsParameter.ActualValue;
-      DoubleMatrix distanceMatrix = DistancesParameter.ActualValue;
-
-      double quality = Apply(assignment, weights, distanceMatrix);
-      QualityParameter.ActualValue = new DoubleValue(quality);
-
-      return base.InstrumentedApply();
-    }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/HeuristicLab.Problems.QuadraticAssignment-3.3.csproj
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/HeuristicLab.Problems.QuadraticAssignment-3.3.csproj	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/HeuristicLab.Problems.QuadraticAssignment-3.3.csproj	(revision 13396)
@@ -124,5 +124,4 @@
     <Compile Include="Evaluators\QAPScrambleMoveEvaluator.cs" />
     <Compile Include="Evaluators\QAPSwap2MoveEvaluator.cs" />
-    <Compile Include="Evaluators\QAPEvaluator.cs" />
     <Compile Include="Evaluators\QAPInversionMoveEvaluator.cs" />
     <Compile Include="Evaluators\QAPMoveEvaluator.cs" />
@@ -130,5 +129,5 @@
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="Interfaces\IQAPEvaluator.cs" />
+    <Compile Include="Interfaces\IQAPLocalImprovementOperator.cs" />
     <Compile Include="Interfaces\IQAPMoveEvaluator.cs" />
     <Compile Include="LocalImprovement\QAPExhaustiveInsertionLocalImprovement.cs" />
@@ -224,4 +223,7 @@
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="SimilarityCalculators\" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
Index: branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/Interfaces/IQAPEvaluator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/Interfaces/IQAPEvaluator.cs	(revision 13390)
+++ 	(revision )
@@ -1,33 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Optimization;
-
-namespace HeuristicLab.Problems.QuadraticAssignment {
-  public interface IQAPEvaluator : ISingleObjectiveEvaluator {
-    ILookupParameter<Permutation> PermutationParameter { get; }
-    ILookupParameter<DoubleMatrix> DistancesParameter { get; }
-    ILookupParameter<DoubleMatrix> WeightsParameter { get; }
-  }
-}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/Interfaces/IQAPLocalImprovementOperator.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/Interfaces/IQAPLocalImprovementOperator.cs	(revision 13396)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/Interfaces/IQAPLocalImprovementOperator.cs	(revision 13396)
@@ -0,0 +1,33 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+
+namespace HeuristicLab.Problems.QuadraticAssignment {
+  public interface IQAPLocalImprovementOperator : IPermutationLocalImprovementOperator {
+    ILookupParameter<DoubleMatrix> DistancesParameter { get; }
+    ILookupParameter<BoolValue> MaximizationParameter { get; }
+    ILookupParameter<DoubleValue> QualityParameter { get; }
+    ILookupParameter<DoubleMatrix> WeightsParameter { get; }
+  }
+}
Index: branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveInsertionLocalImprovement.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveInsertionLocalImprovement.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveInsertionLocalImprovement.cs	(revision 13396)
@@ -34,5 +34,5 @@
   [Item("QAPExhaustiveInsertionLocalImprovement", "Takes a solution and finds the local optimum with respect to the insertion neighborhood by decending along the steepest gradient.")]
   [StorableClass]
-  public class QAPExhaustiveInsertionLocalImprovement : SingleSuccessorOperator, ILocalImprovementOperator, ISingleObjectiveOperator {
+  public class QAPExhaustiveInsertionLocalImprovement : SingleSuccessorOperator, IQAPLocalImprovementOperator, ISingleObjectiveOperator {
 
     public ILookupParameter<IntValue> LocalIterationsParameter {
@@ -52,6 +52,6 @@
     }
 
-    public ILookupParameter<Permutation> AssignmentParameter {
-      get { return (ILookupParameter<Permutation>)Parameters["Assignment"]; }
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
     }
 
@@ -83,5 +83,5 @@
       Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The amount of evaluated solutions (here a move is counted only as 4/n evaluated solutions with n being the length of the permutation)."));
       Parameters.Add(new LookupParameter<ResultCollection>("Results", "The collection where to store results."));
-      Parameters.Add(new LookupParameter<Permutation>("Assignment", "The permutation that is to be locally optimized."));
+      Parameters.Add(new LookupParameter<Permutation>("Permutation", "The permutation that is to be locally optimized."));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value of the assignment."));
       Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem should be maximized or minimized."));
@@ -122,5 +122,5 @@
     public override IOperation Apply() {
       var maxIterations = MaximumIterationsParameter.ActualValue.Value;
-      var assignment = AssignmentParameter.ActualValue;
+      var assignment = PermutationParameter.ActualValue;
       var maximization = MaximizationParameter.ActualValue.Value;
       var weights = WeightsParameter.ActualValue;
Index: branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveInversionLocalImprovement.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveInversionLocalImprovement.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveInversionLocalImprovement.cs	(revision 13396)
@@ -34,5 +34,5 @@
   [Item("QAPExhaustiveInversionLocalImprovement", "Takes a solution and finds the local optimum with respect to the inversion neighborhood by decending along the steepest gradient.")]
   [StorableClass]
-  public class QAPExhaustiveInversionLocalImprovement : SingleSuccessorOperator, ILocalImprovementOperator, ISingleObjectiveOperator {
+  public class QAPExhaustiveInversionLocalImprovement : SingleSuccessorOperator, IQAPLocalImprovementOperator, ISingleObjectiveOperator {
 
     public ILookupParameter<IntValue> LocalIterationsParameter {
@@ -52,6 +52,6 @@
     }
 
-    public ILookupParameter<Permutation> AssignmentParameter {
-      get { return (ILookupParameter<Permutation>)Parameters["Assignment"]; }
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
     }
 
@@ -83,5 +83,5 @@
       Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The amount of evaluated solutions (here a move is counted only as 4/n evaluated solutions with n being the length of the permutation)."));
       Parameters.Add(new LookupParameter<ResultCollection>("Results", "The collection where to store results."));
-      Parameters.Add(new LookupParameter<Permutation>("Assignment", "The permutation that is to be locally optimized."));
+      Parameters.Add(new LookupParameter<Permutation>("Permutation", "The permutation that is to be locally optimized."));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value of the assignment."));
       Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem should be maximized or minimized."));
@@ -119,5 +119,5 @@
     public override IOperation Apply() {
       var maxIterations = MaximumIterationsParameter.ActualValue.Value;
-      var assignment = AssignmentParameter.ActualValue;
+      var assignment = PermutationParameter.ActualValue;
       var maximization = MaximizationParameter.ActualValue.Value;
       var weights = WeightsParameter.ActualValue;
Index: branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveSwap2LocalImprovement.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveSwap2LocalImprovement.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPExhaustiveSwap2LocalImprovement.cs	(revision 13396)
@@ -34,5 +34,5 @@
   [Item("QAPExhaustiveSwap2LocalImprovement", "Takes a solution and finds the local optimum with respect to the swap2 neighborhood by decending along the steepest gradient.")]
   [StorableClass]
-  public class QAPExhaustiveSwap2LocalImprovement : SingleSuccessorOperator, ILocalImprovementOperator, ISingleObjectiveOperator {
+  public class QAPExhaustiveSwap2LocalImprovement : SingleSuccessorOperator, IQAPLocalImprovementOperator, ISingleObjectiveOperator {
 
     public ILookupParameter<IntValue> LocalIterationsParameter {
@@ -52,6 +52,6 @@
     }
 
-    public ILookupParameter<Permutation> AssignmentParameter {
-      get { return (ILookupParameter<Permutation>)Parameters["Assignment"]; }
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
     }
 
@@ -87,5 +87,5 @@
       Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The amount of evaluated solutions (here a move is counted only as 4/n evaluated solutions with n being the length of the permutation)."));
       Parameters.Add(new LookupParameter<ResultCollection>("Results", "The collection where to store results."));
-      Parameters.Add(new LookupParameter<Permutation>("Assignment", "The permutation that is to be locally optimized."));
+      Parameters.Add(new LookupParameter<Permutation>("Permutation", "The permutation that is to be locally optimized."));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value of the assignment."));
       Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem should be maximized or minimized."));
@@ -175,5 +175,5 @@
     public override IOperation Apply() {
       var maxIterations = MaximumIterationsParameter.ActualValue.Value;
-      var assignment = AssignmentParameter.ActualValue;
+      var assignment = PermutationParameter.ActualValue;
       var maximization = MaximizationParameter.ActualValue.Value;
       var weights = WeightsParameter.ActualValue;
Index: branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPStochasticScrambleLocalImprovement.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPStochasticScrambleLocalImprovement.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/LocalImprovement/QAPStochasticScrambleLocalImprovement.cs	(revision 13396)
@@ -34,5 +34,5 @@
   [Item("QAPStochasticScrambleLocalImprovement", "Takes a solution and finds the local optimum with respect to the scramble neighborhood by decending along the steepest gradient.")]
   [StorableClass]
-  public class QAPStochasticScrambleLocalImprovement : SingleSuccessorOperator, ILocalImprovementOperator, IStochasticOperator, ISingleObjectiveOperator {
+  public class QAPStochasticScrambleLocalImprovement : SingleSuccessorOperator, IQAPLocalImprovementOperator, IStochasticOperator, ISingleObjectiveOperator {
 
     public ILookupParameter<IntValue> LocalIterationsParameter {
@@ -56,6 +56,6 @@
     }
 
-    public ILookupParameter<Permutation> AssignmentParameter {
-      get { return (ILookupParameter<Permutation>)Parameters["Assignment"]; }
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
     }
 
@@ -92,5 +92,5 @@
       Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The amount of evaluated solutions (here a move is counted only as 4/n evaluated solutions with n being the length of the permutation)."));
       Parameters.Add(new LookupParameter<ResultCollection>("Results", "The collection where to store results."));
-      Parameters.Add(new LookupParameter<Permutation>("Assignment", "The permutation that is to be locally optimized."));
+      Parameters.Add(new LookupParameter<Permutation>("Permutation", "The permutation that is to be locally optimized."));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value of the assignment."));
       Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem should be maximized or minimized."));
@@ -132,5 +132,5 @@
       var maxIterations = MaximumIterationsParameter.ActualValue.Value;
       var neighborhoodSize = NeighborhoodSizeParameter.ActualValue.Value;
-      var assignment = AssignmentParameter.ActualValue;
+      var assignment = PermutationParameter.ActualValue;
       var maximization = MaximizationParameter.ActualValue.Value;
       var weights = WeightsParameter.ActualValue;
Index: branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/QuadraticAssignmentProblem.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/QuadraticAssignmentProblem.cs	(revision 13390)
+++ branches/ProblemRefactoring/HeuristicLab.Problems.QuadraticAssignment/3.3/QuadraticAssignmentProblem.cs	(revision 13396)
@@ -38,13 +38,13 @@
   [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 140)]
   [StorableClass]
-  public sealed class QuadraticAssignmentProblem : SingleObjectiveHeuristicOptimizationProblem<IQAPEvaluator, IPermutationCreator>,
-    ISingleObjectiveProblem<PermutationEncoding, Permutation>, IStorableContent,
+  public sealed class QuadraticAssignmentProblem : SingleObjectiveProblem<PermutationEncoding, Permutation>,
     IProblemInstanceConsumer<QAPData>,
     IProblemInstanceConsumer<TSPData> {
-    public string Filename { get; set; }
 
     public static new Image StaticItemImage {
-      get { return HeuristicLab.Common.Resources.VSImageLibrary.Type; }
-    }
+      get { return Common.Resources.VSImageLibrary.Type; }
+    }
+
+    public override bool Maximization { get { return false; } }
 
     #region Parameter Properties
@@ -115,5 +115,5 @@
     }
     public QuadraticAssignmentProblem()
-      : base(new QAPEvaluator(), new RandomPermutationCreator()) {
+      : base(new PermutationEncoding("Assignment") { Length = 5 }) {
       Parameters.Add(new OptionalValueParameter<ItemSet<Permutation>>("BestKnownSolutions", "The list of best known solutions which is updated whenever a new better solution is found or may be the optimal solution if it is known beforehand.", null));
       Parameters.Add(new OptionalValueParameter<Permutation>("BestKnownSolution", "The best known solution which is updated whenever a new better solution is found or may be the optimal solution if it is known beforehand.", null));
@@ -122,7 +122,4 @@
       Parameters.Add(new OptionalValueParameter<DoubleValue>("LowerBound", "The Gilmore-Lawler lower bound to the solution quality."));
       Parameters.Add(new OptionalValueParameter<DoubleValue>("AverageQuality", "The expected quality of a random solution."));
-
-      Maximization.Value = false;
-      MaximizationParameter.Hidden = true;
 
       WeightsParameter.GetsCollected = false;
@@ -144,12 +141,22 @@
       });
 
-      SolutionCreator.PermutationParameter.ActualName = "Assignment";
-      ParameterizeSolutionCreator();
-      ParameterizeEvaluator();
-
       InitializeOperators();
       RegisterEventHandlers();
     }
 
+    public override double Evaluate(Permutation assignment, IRandom random) {
+      return Evaluate(assignment);
+    }
+
+    public double Evaluate(Permutation assignment) {
+      double quality = 0;
+      for (int i = 0; i < assignment.Length; i++) {
+        for (int j = 0; j < assignment.Length; j++) {
+          quality += Weights[i, j] * Distances[assignment[i], assignment[j]];
+        }
+      }
+      return quality;
+    }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new QuadraticAssignmentProblem(this, cloner);
@@ -158,27 +165,4 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      // BackwardsCompatibility3.3
-      #region Backwards compatible code, remove with 3.4
-      if (!Parameters.ContainsKey("BestKnownSolutions")) {
-        Parameters.Add(new OptionalValueParameter<ItemSet<Permutation>>("BestKnownSolutions", "The list of best known solutions which is updated whenever a new better solution is found or may be the optimal solution if it is known beforehand.", null));
-      } else if (Parameters["BestKnownSolutions"].GetType().Equals(typeof(OptionalValueParameter<ItemList<Permutation>>))) {
-        ItemList<Permutation> list = ((OptionalValueParameter<ItemList<Permutation>>)Parameters["BestKnownSolutions"]).Value;
-        Parameters.Remove("BestKnownSolutions");
-        Parameters.Add(new OptionalValueParameter<ItemSet<Permutation>>("BestKnownSolutions", "The list of best known solutions which is updated whenever a new better solution is found or may be the optimal solution if it is known beforehand.", (list != null ? new ItemSet<Permutation>(list) : null)));
-      }
-      if (Parameters.ContainsKey("DistanceMatrix")) {
-        DoubleMatrix d = ((ValueParameter<DoubleMatrix>)Parameters["DistanceMatrix"]).Value;
-        Parameters.Remove("DistanceMatrix");
-        Parameters.Add(new ValueParameter<DoubleMatrix>("Distances", "The distance matrix which can either be specified directly without the coordinates, or can be calculated automatically from the coordinates.", d));
-      }
-      if (!Parameters.ContainsKey("LowerBound")) {
-        Parameters.Add(new OptionalValueParameter<DoubleValue>("LowerBound", "The Gilmore-Lawler lower bound to the solution quality."));
-        LowerBound = new DoubleValue(GilmoreLawlerBoundCalculator.CalculateLowerBound(Weights, Distances));
-      }
-      if (!Parameters.ContainsKey("AverageQuality")) {
-        Parameters.Add(new OptionalValueParameter<DoubleValue>("AverageQuality", "The expected quality of a random solution."));
-        AverageQuality = new DoubleValue(ComputeAverageQuality());
-      }
-      #endregion
       RegisterEventHandlers();
     }
@@ -186,35 +170,19 @@
     #region Events
     protected override void OnSolutionCreatorChanged() {
-      SolutionCreator.PermutationParameter.ActualNameChanged += new EventHandler(SolutionCreator_PermutationParameter_ActualNameChanged);
-      ParameterizeSolutionCreator();
-      ParameterizeEvaluator();
-      ParameterizeAnalyzers();
-      ParameterizeOperators();
+      Parameterize();
       base.OnSolutionCreatorChanged();
     }
     protected override void OnEvaluatorChanged() {
-      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
-      ParameterizeEvaluator();
-      ParameterizeAnalyzers();
-      ParameterizeOperators();
+      Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+      Parameterize();
       base.OnEvaluatorChanged();
     }
-
-    private void SolutionCreator_PermutationParameter_ActualNameChanged(object sender, EventArgs e) {
-      ParameterizeEvaluator();
-      ParameterizeAnalyzers();
-      ParameterizeOperators();
-    }
     private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
-      ParameterizeAnalyzers();
-      ParameterizeOperators();
+      Parameterize();
     }
     private void WeightsParameter_ValueChanged(object sender, EventArgs e) {
-      Weights.RowsChanged += new EventHandler(Weights_RowsChanged);
-      Weights.ColumnsChanged += new EventHandler(Weights_ColumnsChanged);
-      Weights.ToStringChanged += new EventHandler(Weights_ToStringChanged);
-      ParameterizeSolutionCreator();
-      ParameterizeEvaluator();
-      ParameterizeOperators();
+      Weights.RowsChanged += Weights_RowsChanged;
+      Weights.ColumnsChanged += Weights_ColumnsChanged;
+      Weights.ToStringChanged += Weights_ToStringChanged;
       AdjustDistanceMatrix();
     }
@@ -223,7 +191,4 @@
         ((IStringConvertibleMatrix)Weights).Columns = Weights.Rows;
       else {
-        ParameterizeSolutionCreator();
-        ParameterizeEvaluator();
-        ParameterizeOperators();
         AdjustDistanceMatrix();
       }
@@ -233,7 +198,4 @@
         ((IStringConvertibleMatrix)Weights).Rows = Weights.Columns;
       else {
-        ParameterizeSolutionCreator();
-        ParameterizeEvaluator();
-        ParameterizeOperators();
         AdjustDistanceMatrix();
       }
@@ -243,10 +205,7 @@
     }
     private void DistancesParameter_ValueChanged(object sender, EventArgs e) {
-      Distances.RowsChanged += new EventHandler(Distances_RowsChanged);
-      Distances.ColumnsChanged += new EventHandler(Distances_ColumnsChanged);
-      Distances.ToStringChanged += new EventHandler(Distances_ToStringChanged);
-      ParameterizeSolutionCreator();
-      ParameterizeEvaluator();
-      ParameterizeOperators();
+      Distances.RowsChanged += Distances_RowsChanged;
+      Distances.ColumnsChanged += Distances_ColumnsChanged;
+      Distances.ToStringChanged += Distances_ToStringChanged;
       AdjustWeightsMatrix();
     }
@@ -255,7 +214,4 @@
         ((IStringConvertibleMatrix)Distances).Columns = Distances.Rows;
       else {
-        ParameterizeSolutionCreator();
-        ParameterizeEvaluator();
-        ParameterizeOperators();
         AdjustWeightsMatrix();
       }
@@ -265,7 +221,4 @@
         ((IStringConvertibleMatrix)Distances).Rows = Distances.Columns;
       else {
-        ParameterizeSolutionCreator();
-        ParameterizeEvaluator();
-        ParameterizeOperators();
         AdjustWeightsMatrix();
       }
@@ -277,14 +230,12 @@
 
     private void RegisterEventHandlers() {
-      SolutionCreator.PermutationParameter.ActualNameChanged += new EventHandler(SolutionCreator_PermutationParameter_ActualNameChanged);
-      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
-      WeightsParameter.ValueChanged += new EventHandler(WeightsParameter_ValueChanged);
-      Weights.RowsChanged += new EventHandler(Weights_RowsChanged);
-      Weights.ColumnsChanged += new EventHandler(Weights_ColumnsChanged);
-      Weights.ToStringChanged += new EventHandler(Weights_ToStringChanged);
-      DistancesParameter.ValueChanged += new EventHandler(DistancesParameter_ValueChanged);
-      Distances.RowsChanged += new EventHandler(Distances_RowsChanged);
-      Distances.ColumnsChanged += new EventHandler(Distances_ColumnsChanged);
-      Distances.ToStringChanged += new EventHandler(Distances_ToStringChanged);
+      WeightsParameter.ValueChanged += WeightsParameter_ValueChanged;
+      Weights.RowsChanged += Weights_RowsChanged;
+      Weights.ColumnsChanged += Weights_ColumnsChanged;
+      Weights.ToStringChanged += Weights_ToStringChanged;
+      DistancesParameter.ValueChanged += DistancesParameter_ValueChanged;
+      Distances.RowsChanged += Distances_RowsChanged;
+      Distances.ColumnsChanged += Distances_ColumnsChanged;
+      Distances.ToStringChanged += Distances_ToStringChanged;
     }
 
@@ -297,40 +248,20 @@
       });
       Operators.AddRange(defaultOperators);
-      Operators.AddRange(ApplicationManager.Manager.GetInstances<IPermutationOperator>().Except(defaultOperators, new TypeEqualityComparer<IPermutationOperator>()));
-      Operators.RemoveAll(x => x is ISingleObjectiveMoveEvaluator);
       Operators.AddRange(ApplicationManager.Manager.GetInstances<IQAPMoveEvaluator>());
+      Operators.AddRange(ApplicationManager.Manager.GetInstances<IQAPLocalImprovementOperator>());
       Operators.Add(new BestQAPSolutionAnalyzer());
       Operators.Add(new QAPAlleleFrequencyAnalyzer());
       Operators.Add(new QAPPopulationDiversityAnalyzer());
 
-      Operators.Add(new QAPExhaustiveInsertionLocalImprovement());
-      Operators.Add(new QAPExhaustiveInversionLocalImprovement());
-      Operators.Add(new QAPStochasticScrambleLocalImprovement());
-      Operators.Add(new QAPExhaustiveSwap2LocalImprovement());
-
       Operators.Add(new QAPSimilarityCalculator());
-      ParameterizeAnalyzers();
-      ParameterizeOperators();
-    }
-    private void ParameterizeSolutionCreator() {
-      if (SolutionCreator != null) {
-        SolutionCreator.PermutationTypeParameter.Value = new PermutationType(PermutationTypes.Absolute);
-        SolutionCreator.LengthParameter.Value = new IntValue(Weights.Rows);
-      }
-    }
-    private void ParameterizeEvaluator() {
-      if (Evaluator != null) {
-        Evaluator.PermutationParameter.ActualName = SolutionCreator.PermutationParameter.ActualName;
-        Evaluator.DistancesParameter.ActualName = DistancesParameter.Name;
-        Evaluator.WeightsParameter.ActualName = WeightsParameter.Name;
-      }
-    }
-    private void ParameterizeAnalyzers() {
+      Parameterize();
+    }
+    private void Parameterize() {
+      var operators = new List<IItem>();
       if (BestQAPSolutionAnalyzer != null) {
+        operators.Add(BestQAPSolutionAnalyzer);
         BestQAPSolutionAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
         BestQAPSolutionAnalyzer.DistancesParameter.ActualName = DistancesParameter.Name;
         BestQAPSolutionAnalyzer.WeightsParameter.ActualName = WeightsParameter.Name;
-        BestQAPSolutionAnalyzer.PermutationParameter.ActualName = SolutionCreator.PermutationParameter.ActualName;
-        BestQAPSolutionAnalyzer.ResultsParameter.ActualName = "Results";
         BestQAPSolutionAnalyzer.BestKnownQualityParameter.ActualName = BestKnownQualityParameter.Name;
         BestQAPSolutionAnalyzer.BestKnownSolutionsParameter.ActualName = BestKnownSolutionsParameter.Name;
@@ -338,54 +269,18 @@
       }
       if (QAPAlleleFrequencyAnalyzer != null) {
+        operators.Add(QAPAlleleFrequencyAnalyzer);
         QAPAlleleFrequencyAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
         QAPAlleleFrequencyAnalyzer.BestKnownSolutionParameter.ActualName = BestKnownSolutionParameter.Name;
         QAPAlleleFrequencyAnalyzer.DistancesParameter.ActualName = DistancesParameter.Name;
         QAPAlleleFrequencyAnalyzer.MaximizationParameter.ActualName = MaximizationParameter.Name;
-        QAPAlleleFrequencyAnalyzer.ResultsParameter.ActualName = "Results";
-        QAPAlleleFrequencyAnalyzer.SolutionParameter.ActualName = SolutionCreator.PermutationParameter.ActualName;
         QAPAlleleFrequencyAnalyzer.WeightsParameter.ActualName = WeightsParameter.Name;
       }
       if (QAPPopulationDiversityAnalyzer != null) {
+        operators.Add(QAPPopulationDiversityAnalyzer);
         QAPPopulationDiversityAnalyzer.MaximizationParameter.ActualName = MaximizationParameter.Name;
         QAPPopulationDiversityAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
-        QAPPopulationDiversityAnalyzer.ResultsParameter.ActualName = "Results";
-        QAPPopulationDiversityAnalyzer.SolutionParameter.ActualName = SolutionCreator.PermutationParameter.ActualName;
-      }
-    }
-    private void ParameterizeOperators() {
-      foreach (IPermutationCrossover op in Operators.OfType<IPermutationCrossover>()) {
-        op.ParentsParameter.ActualName = SolutionCreator.PermutationParameter.ActualName;
-        op.ChildParameter.ActualName = SolutionCreator.PermutationParameter.ActualName;
-      }
-      foreach (IPermutationManipulator op in Operators.OfType<IPermutationManipulator>()) {
-        op.PermutationParameter.ActualName = SolutionCreator.PermutationParameter.ActualName;
-      }
-      foreach (IPermutationMoveOperator op in Operators.OfType<IPermutationMoveOperator>()) {
-        op.PermutationParameter.ActualName = SolutionCreator.PermutationParameter.ActualName;
-      }
-      if (Operators.OfType<IMoveGenerator>().Any()) {
-        if (Operators.OfType<IMoveGenerator>().OfType<IPermutationInversionMoveOperator>().Any()) {
-          string inversionMove = Operators.OfType<IMoveGenerator>().OfType<IPermutationInversionMoveOperator>().First().InversionMoveParameter.ActualName;
-          foreach (IPermutationInversionMoveOperator op in Operators.OfType<IPermutationInversionMoveOperator>())
-            op.InversionMoveParameter.ActualName = inversionMove;
-        }
-        if (Operators.OfType<IMoveGenerator>().OfType<IPermutationTranslocationMoveOperator>().Any()) {
-          string translocationMove = Operators.OfType<IMoveGenerator>().OfType<IPermutationTranslocationMoveOperator>().First().TranslocationMoveParameter.ActualName;
-          foreach (IPermutationTranslocationMoveOperator op in Operators.OfType<IPermutationTranslocationMoveOperator>())
-            op.TranslocationMoveParameter.ActualName = translocationMove;
-        }
-        if (Operators.OfType<IMoveGenerator>().OfType<IPermutationSwap2MoveOperator>().Any()) {
-          string swapMove = Operators.OfType<IMoveGenerator>().OfType<IPermutationSwap2MoveOperator>().First().Swap2MoveParameter.ActualName;
-          foreach (IPermutationSwap2MoveOperator op in Operators.OfType<IPermutationSwap2MoveOperator>()) {
-            op.Swap2MoveParameter.ActualName = swapMove;
-          }
-        }
-      }
-      foreach (var op in Operators.OfType<IPermutationMultiNeighborhoodShakingOperator>())
-        op.PermutationParameter.ActualName = SolutionCreator.PermutationParameter.ActualName;
-
-      QAPExhaustiveSwap2LocalImprovement localOpt = Operators.OfType<QAPExhaustiveSwap2LocalImprovement>().SingleOrDefault();
-      if (localOpt != null) {
-        localOpt.AssignmentParameter.ActualName = SolutionCreator.PermutationParameter.ActualName;
+      }
+      foreach (var localOpt in Operators.OfType<IQAPLocalImprovementOperator>()) {
+        operators.Add(localOpt);
         localOpt.DistancesParameter.ActualName = DistancesParameter.Name;
         localOpt.MaximizationParameter.ActualName = MaximizationParameter.Name;
@@ -394,9 +289,42 @@
       }
 
-      QAPSimilarityCalculator similarityCalculator = Operators.OfType<QAPSimilarityCalculator>().SingleOrDefault();
+      foreach (var moveOp in Operators.OfType<IQAPMoveEvaluator>()) {
+        operators.Add(moveOp);
+        moveOp.DistancesParameter.ActualName = DistancesParameter.Name;
+        moveOp.WeightsParameter.ActualName = WeightsParameter.Name;
+        moveOp.QualityParameter.ActualName = Evaluator.QualityParameter.Name;
+
+        var swaMoveOp = moveOp as QAPSwap2MoveEvaluator;
+        if (swaMoveOp != null) {
+          var moveQualityName = swaMoveOp.MoveQualityParameter.ActualName;
+          foreach (var o in Encoding.Operators.OfType<IPermutationSwap2MoveQualityOperator>())
+            o.MoveQualityParameter.ActualName = moveQualityName;
+        }
+        var invMoveOp = moveOp as QAPInversionMoveEvaluator;
+        if (invMoveOp != null) {
+          var moveQualityName = invMoveOp.MoveQualityParameter.ActualName;
+          foreach (var o in Encoding.Operators.OfType<IPermutationInversionMoveQualityOperator>())
+            o.MoveQualityParameter.ActualName = moveQualityName;
+        }
+        var traMoveOp = moveOp as QAPTranslocationMoveEvaluator;
+        if (traMoveOp != null) {
+          var moveQualityName = traMoveOp.MoveQualityParameter.ActualName;
+          foreach (var o in Encoding.Operators.OfType<IPermutationTranslocationMoveQualityOperator>())
+            o.MoveQualityParameter.ActualName = moveQualityName;
+        }
+        var scrMoveOp = moveOp as QAPScrambleMoveEvaluator;
+        if (scrMoveOp != null) {
+          var moveQualityName = scrMoveOp.MoveQualityParameter.ActualName;
+          foreach (var o in Encoding.Operators.OfType<IPermutationScrambleMoveQualityOperator>())
+            o.MoveQualityParameter.ActualName = moveQualityName;
+        }
+      }
+      var similarityCalculator = Operators.OfType<QAPSimilarityCalculator>().SingleOrDefault();
       if (similarityCalculator != null) {
-        similarityCalculator.SolutionVariableName = SolutionCreator.PermutationParameter.ActualName;
+        similarityCalculator.SolutionVariableName = Encoding.Name;
         similarityCalculator.QualityVariableName = Evaluator.QualityParameter.ActualName;
       }
+
+      if (operators.Count > 0) Encoding.ConfigureOperators(operators);
     }
 
@@ -404,4 +332,5 @@
       if (Distances.Rows != Weights.Rows || Distances.Columns != Weights.Columns) {
         ((IStringConvertibleMatrix)Distances).Rows = Weights.Rows;
+        Encoding.Length = Weights.Rows;
       }
     }
@@ -410,4 +339,5 @@
       if (Weights.Rows != Distances.Rows || Weights.Columns != Distances.Columns) {
         ((IStringConvertibleMatrix)Weights).Rows = Distances.Rows;
+        Encoding.Length = Distances.Rows;
       }
     }
@@ -418,9 +348,9 @@
       LowerBound = new DoubleValue(GilmoreLawlerBoundCalculator.CalculateLowerBound(Weights, Distances, out lbSolution));
       // evalute the LAP optimal solution as if it was a QAP solution
-      var lbSolutionQuality = QAPEvaluator.Apply(lbSolution, Weights, Distances);
+      var lbSolutionQuality = Evaluate(lbSolution);
       // in case both qualities are the same it means that the LAP optimum is also a QAP optimum
       if (LowerBound.Value.IsAlmost(lbSolutionQuality)) {
         BestKnownSolution = lbSolution;
-        BestKnownQuality = new DoubleValue(LowerBound.Value);
+        BestKnownQuality = LowerBound.Value;
       }
       AverageQuality = new DoubleValue(ComputeAverageQuality());
@@ -451,5 +381,5 @@
       Description = data.Description;
       Load(weights, distances);
-      if (data.BestKnownQuality.HasValue) BestKnownQuality = new DoubleValue(data.BestKnownQuality.Value);
+      if (data.BestKnownQuality.HasValue) BestKnownQuality = data.BestKnownQuality.Value;
       EvaluateAndLoadAssignment(data.BestKnownAssignment);
       OnReset();
@@ -466,5 +396,5 @@
       Description = data.Description;
       Load(weights, distances);
-      if (data.BestKnownQuality.HasValue) BestKnownQuality = new DoubleValue(data.BestKnownQuality.Value);
+      if (data.BestKnownQuality.HasValue) BestKnownQuality = data.BestKnownQuality.Value;
       EvaluateAndLoadAssignment(data.BestKnownTour);
       OnReset();
@@ -485,6 +415,7 @@
       Weights = weights;
       Distances = distances;
-
-      BestKnownQuality = null;
+      Encoding.Length = weights.Rows;
+
+      BestKnownQualityParameter.Value = null;
       BestKnownSolution = null;
       BestKnownSolutions = null;
@@ -495,9 +426,8 @@
       if (assignment == null || assignment.Length == 0) return;
       var vector = new Permutation(PermutationTypes.Absolute, assignment);
-      var result = QAPEvaluator.Apply(vector, Weights, Distances);
-      BestKnownQuality = new DoubleValue(result);
+      var result = Evaluate(vector);
+      BestKnownQuality = result;
       BestKnownSolution = vector;
-      BestKnownSolutions = new ItemSet<Permutation>();
-      BestKnownSolutions.Add((Permutation)vector.Clone());
+      BestKnownSolutions = new ItemSet<Permutation> { (Permutation)vector.Clone() };
     }
   }
