Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Analyzers/BestGQAPSolutionAnalyzer.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Analyzers/BestGQAPSolutionAnalyzer.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Analyzers/BestGQAPSolutionAnalyzer.cs	(revision 7419)
@@ -37,5 +37,9 @@
   [Item("Best GeneralizedQAP Solution Analyzer", "An operator for analyzing the best solution of Generalized Quadratic Assignment Problems.")]
   [StorableClass]
-  public sealed class BestGQAPSolutionAnalyzer : SingleSuccessorOperator, IAnalyzer {
+  public sealed class BestGQAPSolutionAnalyzer : SingleSuccessorOperator, IAssignmentsAwareGQAPOperator,
+    IQualitiesAwareGQAPOperator, IDistancesAwareGQAPOperator, IWeightsAwareGQAPOperator, IInstallationCostsAwareGQAPOperator,
+    IDemandsAwareGQAPOperator, ICapacitiesAwareGQAPOperator, ITransportationCostsAwareGQAPOperator,
+    IOverbookedCapacityPenaltyAwareGQAPOperator, IEquipmentNamesAwareGQAPOperator, ILocationNamesAwareGQAPOperator,
+    IBestKnownQualityAwareGQAPOperator, IBestKnownSolutionAwareGQAPOperator, IAnalyzer {
 
     public bool EnabledByDefault {
@@ -43,54 +47,42 @@
     }
 
-    public LookupParameter<BoolValue> MaximizationParameter {
-      get { return (LookupParameter<BoolValue>)Parameters["Maximization"]; }
+    public IScopeTreeLookupParameter<IntegerVector> AssignmentParameter {
+      get { return (IScopeTreeLookupParameter<IntegerVector>)Parameters["Assignment"]; }
     }
-    public LookupParameter<DoubleMatrix> DistancesParameter {
-      get { return (LookupParameter<DoubleMatrix>)Parameters["Distances"]; }
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
-    public LookupParameter<DoubleMatrix> WeightsParameter {
-      get { return (LookupParameter<DoubleMatrix>)Parameters["Weights"]; }
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
-    public LookupParameter<DoubleMatrix> InstallationCostsParameter {
-      get { return (LookupParameter<DoubleMatrix>)Parameters["InstallationCosts"]; }
+    public IScopeTreeLookupParameter<DoubleValue> FlowDistanceQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["FlowDistanceQuality"]; }
     }
-    public LookupParameter<DoubleArray> DemandsParameter {
-      get { return (LookupParameter<DoubleArray>)Parameters["Demands"]; }
+    public IScopeTreeLookupParameter<DoubleValue> InstallationQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["InstallationQuality"]; }
     }
-    public LookupParameter<DoubleArray> CapacitiesParameter {
-      get { return (LookupParameter<DoubleArray>)Parameters["Capacities"]; }
+    public IScopeTreeLookupParameter<DoubleValue> OverbookedCapacityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["OverbookedCapacity"]; }
     }
-    public LookupParameter<DoubleValue> TransportationCostsParameter {
-      get { return (LookupParameter<DoubleValue>)Parameters["TransportationCosts"]; }
+    public ILookupParameter<DoubleMatrix> DistancesParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Distances"]; }
     }
-    public LookupParameter<DoubleValue> OverbookedCapacityPenaltyParameter {
-      get { return (LookupParameter<DoubleValue>)Parameters["OverbookedCapacityPenalty"]; }
+    public ILookupParameter<DoubleMatrix> WeightsParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Weights"]; }
     }
-    public ScopeTreeLookupParameter<IntegerVector> AssignmentParameter {
-      get { return (ScopeTreeLookupParameter<IntegerVector>)Parameters["Assignment"]; }
+    public ILookupParameter<DoubleMatrix> InstallationCostsParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["InstallationCosts"]; }
     }
-    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    public ILookupParameter<DoubleArray> DemandsParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Demands"]; }
     }
-    public ScopeTreeLookupParameter<DoubleValue> FlowDistanceQualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["FlowDistanceQuality"]; }
+    public ILookupParameter<DoubleArray> CapacitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Capacities"]; }
     }
-    public ScopeTreeLookupParameter<DoubleValue> InstallationQualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["InstallationQuality"]; }
+    public IValueLookupParameter<DoubleValue> TransportationCostsParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["TransportationCosts"]; }
     }
-    public ScopeTreeLookupParameter<DoubleValue> OverbookedCapacityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["OverbookedCapacity"]; }
-    }
-    public LookupParameter<GQAPAssignment> BestSolutionParameter {
-      get { return (LookupParameter<GQAPAssignment>)Parameters["BestSolution"]; }
-    }
-    public ValueLookupParameter<ResultCollection> ResultsParameter {
-      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
-    }
-    public LookupParameter<DoubleValue> BestKnownQualityParameter {
-      get { return (LookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
-    }
-    public LookupParameter<IntegerVector> BestKnownSolutionParameter {
-      get { return (LookupParameter<IntegerVector>)Parameters["BestKnownSolution"]; }
+    public IValueLookupParameter<DoubleValue> OverbookedCapacityPenaltyParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["OverbookedCapacityPenalty"]; }
     }
     public ILookupParameter<StringArray> EquipmentNamesParameter {
@@ -99,4 +91,16 @@
     public ILookupParameter<StringArray> LocationNamesParameter {
       get { return (ILookupParameter<StringArray>)Parameters["LocationNames"]; }
+    }
+    public ILookupParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
+    }
+    public ILookupParameter<IntegerVector> BestKnownSolutionParameter {
+      get { return (ILookupParameter<IntegerVector>)Parameters["BestKnownSolution"]; }
+    }
+    public ILookupParameter<GQAPAssignment> BestSolutionParameter {
+      get { return (ILookupParameter<GQAPAssignment>)Parameters["BestSolution"]; }
+    }
+    public IValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
     }
 
@@ -115,6 +119,6 @@
       Parameters.Add(new LookupParameter<DoubleArray>("Demands", "The demands of the equipments."));
       Parameters.Add(new LookupParameter<DoubleArray>("Capacities", "The capacities at the locations."));
-      Parameters.Add(new LookupParameter<DoubleValue>("TransportationCosts", "The transportation cost represents the flow-unit per distance-unit cost factor. This value can also be set to 1 if these costs are factored into the weights matrix already."));
-      Parameters.Add(new LookupParameter<DoubleValue>("OverbookedCapacityPenalty", "The multiplier for the constraint violation when added to the quality."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("TransportationCosts", "The transportation cost represents the flow-unit per distance-unit cost factor. This value can also be set to 1 if these costs are factored into the weights matrix already."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("OverbookedCapacityPenalty", "The multiplier for the constraint violation when added to the quality."));
       Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>("Assignment", "The GQAP solutions from which the best solution should be analyzed."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The qualities of the GQAP solutions which should be analyzed."));
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Analyzers/GQAPSolutionArchiveAnalyzer.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Analyzers/GQAPSolutionArchiveAnalyzer.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Analyzers/GQAPSolutionArchiveAnalyzer.cs	(revision 7419)
@@ -35,60 +35,52 @@
   [Item("GeneralizedQAP Solution Archive Analyzer", "An operator for analyzing the archive of found solutions for the GQAP.")]
   [StorableClass]
-  public sealed class GQAPSolutionArchiveAnalyzer : SingleSuccessorOperator, IAnalyzer {
+  public sealed class GQAPSolutionArchiveAnalyzer : SingleSuccessorOperator, IAssignmentsAwareGQAPOperator,
+    IQualitiesAwareGQAPOperator, IDistancesAwareGQAPOperator, IWeightsAwareGQAPOperator, IInstallationCostsAwareGQAPOperator,
+    IDemandsAwareGQAPOperator, ICapacitiesAwareGQAPOperator, ITransportationCostsAwareGQAPOperator,
+    IOverbookedCapacityPenaltyAwareGQAPOperator, IEquipmentNamesAwareGQAPOperator, ILocationNamesAwareGQAPOperator,
+    IBestKnownQualityAwareGQAPOperator, IBestKnownSolutionAwareGQAPOperator, IAnalyzer {
 
     public bool EnabledByDefault {
-      get { return true; }
+      get { return false; }
     }
 
-    public LookupParameter<BoolValue> MaximizationParameter {
-      get { return (LookupParameter<BoolValue>)Parameters["Maximization"]; }
+    public IScopeTreeLookupParameter<IntegerVector> AssignmentParameter {
+      get { return (IScopeTreeLookupParameter<IntegerVector>)Parameters["Assignment"]; }
     }
-    public LookupParameter<DoubleMatrix> DistancesParameter {
-      get { return (LookupParameter<DoubleMatrix>)Parameters["Distances"]; }
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
-    public LookupParameter<DoubleMatrix> WeightsParameter {
-      get { return (LookupParameter<DoubleMatrix>)Parameters["Weights"]; }
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
-    public LookupParameter<DoubleMatrix> InstallationCostsParameter {
-      get { return (LookupParameter<DoubleMatrix>)Parameters["InstallationCosts"]; }
+    public IScopeTreeLookupParameter<DoubleValue> FlowDistanceQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["FlowDistanceQuality"]; }
     }
-    public LookupParameter<DoubleArray> DemandsParameter {
-      get { return (LookupParameter<DoubleArray>)Parameters["Demands"]; }
+    public IScopeTreeLookupParameter<DoubleValue> InstallationQualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["InstallationQuality"]; }
     }
-    public LookupParameter<DoubleArray> CapacitiesParameter {
-      get { return (LookupParameter<DoubleArray>)Parameters["Capacities"]; }
+    public IScopeTreeLookupParameter<DoubleValue> OverbookedCapacityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["OverbookedCapacity"]; }
     }
-    public LookupParameter<DoubleValue> TransportationCostsParameter {
-      get { return (LookupParameter<DoubleValue>)Parameters["TransportationCosts"]; }
+    public ILookupParameter<DoubleMatrix> DistancesParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Distances"]; }
     }
-    public LookupParameter<DoubleValue> OverbookedCapacityPenaltyParameter {
-      get { return (LookupParameter<DoubleValue>)Parameters["OverbookedCapacityPenalty"]; }
+    public ILookupParameter<DoubleMatrix> WeightsParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Weights"]; }
     }
-    public ScopeTreeLookupParameter<IntegerVector> AssignmentParameter {
-      get { return (ScopeTreeLookupParameter<IntegerVector>)Parameters["Assignment"]; }
+    public ILookupParameter<DoubleMatrix> InstallationCostsParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["InstallationCosts"]; }
     }
-    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    public ILookupParameter<DoubleArray> DemandsParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Demands"]; }
     }
-    public ScopeTreeLookupParameter<DoubleValue> FlowDistanceQualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["FlowDistanceQuality"]; }
+    public ILookupParameter<DoubleArray> CapacitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Capacities"]; }
     }
-    public ScopeTreeLookupParameter<DoubleValue> InstallationQualityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["InstallationQuality"]; }
+    public IValueLookupParameter<DoubleValue> TransportationCostsParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["TransportationCosts"]; }
     }
-    public ScopeTreeLookupParameter<DoubleValue> OverbookedCapacityParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["OverbookedCapacity"]; }
-    }
-    public LookupParameter<GQAPAssignment> BestSolutionParameter {
-      get { return (LookupParameter<GQAPAssignment>)Parameters["BestSolution"]; }
-    }
-    public ValueLookupParameter<ResultCollection> ResultsParameter {
-      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
-    }
-    public LookupParameter<DoubleValue> BestKnownQualityParameter {
-      get { return (LookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
-    }
-    public LookupParameter<IntegerVector> BestKnownSolutionParameter {
-      get { return (LookupParameter<IntegerVector>)Parameters["BestKnownSolution"]; }
+    public IValueLookupParameter<DoubleValue> OverbookedCapacityPenaltyParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["OverbookedCapacityPenalty"]; }
     }
     public ILookupParameter<StringArray> EquipmentNamesParameter {
@@ -97,4 +89,16 @@
     public ILookupParameter<StringArray> LocationNamesParameter {
       get { return (ILookupParameter<StringArray>)Parameters["LocationNames"]; }
+    }
+    public ILookupParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
+    }
+    public ILookupParameter<IntegerVector> BestKnownSolutionParameter {
+      get { return (ILookupParameter<IntegerVector>)Parameters["BestKnownSolution"]; }
+    }
+    public ILookupParameter<GQAPAssignment> BestSolutionParameter {
+      get { return (ILookupParameter<GQAPAssignment>)Parameters["BestSolution"]; }
+    }
+    public IValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
     }
 
@@ -113,6 +117,6 @@
       Parameters.Add(new LookupParameter<DoubleArray>("Demands", "The demands of the equipments."));
       Parameters.Add(new LookupParameter<DoubleArray>("Capacities", "The capacities at the locations."));
-      Parameters.Add(new LookupParameter<DoubleValue>("TransportationCosts", "The transportation cost represents the flow-unit per distance-unit cost factor. This value can also be set to 1 if these costs are factored into the weights matrix already."));
-      Parameters.Add(new LookupParameter<DoubleValue>("OverbookedCapacityPenalty", "The multiplier for the constraint violation when added to the quality."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("TransportationCosts", "The transportation cost represents the flow-unit per distance-unit cost factor. This value can also be set to 1 if these costs are factored into the weights matrix already."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("OverbookedCapacityPenalty", "The multiplier for the constraint violation when added to the quality."));
       Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>("Assignment", "The GQAP solutions from which the best solution should be analyzed."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The qualities of the GQAP solutions which should be analyzed."));
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Evaluators/GQAPEvaluator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Evaluators/GQAPEvaluator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Evaluators/GQAPEvaluator.cs	(revision 7419)
@@ -33,6 +33,18 @@
   [Item("GQAPEvaluator", "Evaluates solutions to the generalized quadratic assignment problem.")]
   [StorableClass]
-  public class GQAPEvaluator : SingleSuccessorOperator, IGQAPEvaluator {
+  public class GQAPEvaluator : SingleSuccessorOperator, IGQAPEvaluator,
+  IWeightsAwareGQAPOperator, IDistancesAwareGQAPOperator, IInstallationCostsAwareGQAPOperator,
+  IDemandsAwareGQAPOperator, ICapacitiesAwareGQAPOperator, IAssignmentAwareGQAPOperator {
 
+    #region Parameter Descriptions
+    public static readonly string QualityDescription = "The quality of the solution.";
+    public static readonly string FlowDistanceQualityDescription = "The quality regarding the flow-distance criteria.";
+    public static readonly string InstallationQualityDescription = "The quality regarding the installation costs.";
+    public static readonly string OverbookedCapacityDescription = "The sum of the overbooked capacities relative to the capacity of each location.";
+    #endregion
+
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
     public ILookupParameter<DoubleValue> QualityParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
@@ -77,16 +89,17 @@
     public GQAPEvaluator()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
-      Parameters.Add(new LookupParameter<DoubleValue>("FlowDistanceQuality", "The quality regarding the flow-distance criteria."));
-      Parameters.Add(new LookupParameter<DoubleValue>("InstallationQuality", "The quality regarding the installation costs."));
-      Parameters.Add(new LookupParameter<DoubleValue>("OverbookedCapacity", "The sum of the overbooked capacities relative to the capacity of each location."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("TransportationCosts", "The transportation cost represents the flow-unit per distance-unit cost factor. This value can also be set to 1 if these costs are factored into the weights or distance matrix already."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("OverbookedCapacityPenalty", "The multiplier for the constraint violation when added to the quality."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("Weights", "The weights matrix describes the flows between the equipments."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("Distances", "The distances matrix describes the distances between the locations at which the equipment can be installed."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("InstallationCosts", "The installation costs matrix describes the installation costs of installing equipment i at location j"));
-      Parameters.Add(new LookupParameter<DoubleArray>("Demands", "The demands vector describes the space requirements of the equipments."));
-      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", "The capacities vector describes the available space at the locations."));
-      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", "The vector that encodes the assignment."));
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", GeneralizedQuadraticAssignmentProblem.MaximizationDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", QualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("FlowDistanceQuality", FlowDistanceQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("InstallationQuality", InstallationQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("OverbookedCapacity", OverbookedCapacityDescription));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("TransportationCosts", GeneralizedQuadraticAssignmentProblem.TransportationCostsDescription));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("OverbookedCapacityPenalty", GeneralizedQuadraticAssignmentProblem.OverbookedCapacityPenaltyDescription));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("Weights", GeneralizedQuadraticAssignmentProblem.WeightsDescription));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("Distances", GeneralizedQuadraticAssignmentProblem.DistancesDescription));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("InstallationCosts", GeneralizedQuadraticAssignmentProblem.InstallationCostsDescription));
+      Parameters.Add(new LookupParameter<DoubleArray>("Demands", GeneralizedQuadraticAssignmentProblem.DemandsDescription));
+      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", GeneralizedQuadraticAssignmentProblem.CapacitiesDescription));
+      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", GQAPSolutionCreator.AssignmentDescription));
     }
 
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Evaluators/GQAPNMoveEvaluator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Evaluators/GQAPNMoveEvaluator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Evaluators/GQAPNMoveEvaluator.cs	(revision 7419)
@@ -27,4 +27,5 @@
 using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -33,11 +34,49 @@
   [Item("GQAPNMoveEvaluator", "Evaluates an n-move.")]
   [StorableClass]
-  public class GQAPNMoveEvaluator : SingleSuccessorOperator, IGQAPNMoveEvaluator {
-
+  public class GQAPNMoveEvaluator : SingleSuccessorOperator, IGQAPNMoveEvaluator, IAssignmentAwareGQAPOperator,
+  IQualityAwareGQAPOperator, ITransportationCostsAwareGQAPOperator,
+  IOverbookedCapacityPenaltyAwareGQAPOperator, IWeightsAwareGQAPOperator, IDistancesAwareGQAPOperator,
+  IInstallationCostsAwareGQAPOperator, IDemandsAwareGQAPOperator, ICapacitiesAwareGQAPOperator {
+
+    #region Parameter Descriptions
+    public static readonly string MoveQualityDescription = "The quality of the move if it would be applied.";
+    public static readonly string MoveFlowDistanceQualityDescription = "The quality of the move regarding the flow-distance criteria.";
+    public static readonly string MoveInstallationQualityDescription = "The quality of the move regarding the installation costs.";
+    public static readonly string MoveOverbookedCapacityDescription = "The sum of the overbooked capacities of the move relative to the capacity of each location.";
+    #endregion
+
+    #region Parameter Properties
+    ILookupParameter<BoolValue> IQualityAwareGQAPOperator.MaximizationParameter {
+      get { return MaximizationParameter; }
+    }
+    ILookupParameter<BoolValue> IGQAPMoveEvaluator.MaximizationParameter {
+      get { return MaximizationParameter; }
+    }
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveFlowDistanceQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveFlowDistanceQuality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveInstallationQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveInstallationQuality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveOverbookedCapacityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveOverbookedCapacity"]; }
+    }
+    public ILookupParameter<NMove> MoveParameter {
+      get { return (ILookupParameter<NMove>)Parameters["Move"]; }
+    }
     public ILookupParameter<IntegerVector> AssignmentParameter {
       get { return (ILookupParameter<IntegerVector>)Parameters["Assignment"]; }
     }
-    public ILookupParameter<NMove> MoveParameter {
-      get { return (ILookupParameter<NMove>)Parameters["Move"]; }
+    ILookupParameter<DoubleValue> ISingleObjectiveMoveEvaluator.QualityParameter {
+      get { return QualityParameter; }
+    }
+    ILookupParameter<DoubleValue> IQualityAwareGQAPOperator.QualityParameter {
+      get { return QualityParameter; }
     }
     public ILookupParameter<DoubleValue> QualityParameter {
@@ -53,16 +92,4 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["OverbookedCapacity"]; }
     }
-    public ILookupParameter<DoubleValue> MoveQualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
-    }
-    public ILookupParameter<DoubleValue> MoveFlowDistanceQualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["MoveFlowDistanceQuality"]; }
-    }
-    public ILookupParameter<DoubleValue> MoveInstallationQualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["MoveInstallationQuality"]; }
-    }
-    public ILookupParameter<DoubleValue> MoveOverbookedCapacityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["MoveOverbookedCapacity"]; }
-    }
     public IValueLookupParameter<DoubleValue> TransportationCostsParameter {
       get { return (IValueLookupParameter<DoubleValue>)Parameters["TransportationCosts"]; }
@@ -86,4 +113,5 @@
       get { return (ILookupParameter<DoubleArray>)Parameters["Capacities"]; }
     }
+    #endregion
 
     [StorableConstructor]
@@ -92,21 +120,22 @@
     public GQAPNMoveEvaluator()
       : base() {
-      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", "The equipment-location assignment vector."));
-      Parameters.Add(new LookupParameter<NMove>("Move", "The move to perform."));
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The solution quality."));
-      Parameters.Add(new LookupParameter<DoubleValue>("FlowDistanceQuality", "The quality regarding the flow-distance criteria."));
-      Parameters.Add(new LookupParameter<DoubleValue>("InstallationQuality", "The quality regarding the installation costs."));
-      Parameters.Add(new LookupParameter<DoubleValue>("OverbookedCapacity", "The sum of the overbooked capacities relative to the capacity of each location."));
-      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the move if it would be applied."));
-      Parameters.Add(new LookupParameter<DoubleValue>("MoveFlowDistanceQuality", "The quality of the move regarding the flow-distance criteria."));
-      Parameters.Add(new LookupParameter<DoubleValue>("MoveInstallationQuality", "The quality of the move regarding the installation costs."));
-      Parameters.Add(new LookupParameter<DoubleValue>("MoveOverbookedCapacity", "The sum of the overbooked capacities of the move relative to the capacity of each location."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("OverbookedCapacityPenalty", "The multiplier for the constraint violation when added to the quality."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("TransportationCosts", "The transportation cost represents the flow-unit per distance-unit cost factor. This value can also be set to 1 if these costs are factored into the weights or distance matrix already."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("Weights", "The weights matrix describes the flows between the equipments."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("Distances", "The distances matrix describes the distances between the locations at which the equipment can be installed."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("InstallationCosts", "The installation costs matrix describes the installation costs of installing equipment i at location j"));
-      Parameters.Add(new LookupParameter<DoubleArray>("Demands", "The demands vector describes the space requirements of the equipments."));
-      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", "The capacities vector describes the available space at the locations."));
+      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", GQAPSolutionCreator.AssignmentDescription));
+      Parameters.Add(new LookupParameter<NMove>("Move", GQAPNMoveGenerator.MoveDescription));
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", GeneralizedQuadraticAssignmentProblem.MaximizationDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", GQAPEvaluator.QualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("FlowDistanceQuality", GQAPEvaluator.FlowDistanceQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("InstallationQuality", GQAPEvaluator.InstallationQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("OverbookedCapacity", GQAPEvaluator.OverbookedCapacityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", MoveQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveFlowDistanceQuality", MoveFlowDistanceQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveInstallationQuality", MoveInstallationQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveOverbookedCapacity", MoveOverbookedCapacityDescription));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("OverbookedCapacityPenalty", GeneralizedQuadraticAssignmentProblem.OverbookedCapacityPenaltyDescription));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("TransportationCosts", GeneralizedQuadraticAssignmentProblem.TransportationCostsDescription));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("Weights", GeneralizedQuadraticAssignmentProblem.WeightsDescription));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("Distances", GeneralizedQuadraticAssignmentProblem.DistancesDescription));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("InstallationCosts", GeneralizedQuadraticAssignmentProblem.InstallationCostsDescription));
+      Parameters.Add(new LookupParameter<DoubleArray>("Demands", GeneralizedQuadraticAssignmentProblem.DemandsDescription));
+      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", GeneralizedQuadraticAssignmentProblem.CapacitiesDescription));
     }
 
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/GeneralizedQuadraticAssignmentProblem.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/GeneralizedQuadraticAssignmentProblem.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/GeneralizedQuadraticAssignmentProblem.cs	(revision 7419)
@@ -37,4 +37,5 @@
   [StorableClass]
   public sealed class GeneralizedQuadraticAssignmentProblem : SingleObjectiveHeuristicOptimizationProblem<IGQAPEvaluator, IGQAPSolutionCreator>, IStorableContent {
+
     public override Image ItemImage {
       get { return HeuristicLab.Common.Resources.VSImageLibrary.Type; }
@@ -42,4 +43,18 @@
 
     public string Filename { get; set; }
+
+    #region Parameter Descriptions
+    public static readonly string MaximizationDescription = "False if the fitness function should be minimized (default) or otherwise True if it should be maximized.";
+    public static readonly string WeightsDescription = "The weights matrix describes the flows between the equipments.";
+    public static readonly string DistancesDescription = "The distances matrix describes the distances between the locations at which the equipment can be installed.";
+    public static readonly string InstallationCostsDescription = "The installation costs matrix describes the installation costs of installing equipment i at location j";
+    public static readonly string DemandsDescription = "The demands vector describes the space requirements of the equipments.";
+    public static readonly string CapacitiesDescription = "The capacities vector describes the available space at the locations.";
+    public static readonly string TransportationCostsDescription = "The transportation cost represents the flow-unit per distance-unit cost factor. This value can also be set to 1 if these costs are factored into the weights matrix already.";
+    public static readonly string OverbookedCapacityPenaltyDescription = "The multiplier for the constraint violation when added to the quality.";
+    public static readonly string BestKnownSolutionDescription = "The best known solution (if available)";
+    public static readonly string EquipmentNamesDescription = "Optional: A list of names that describes the equipments.";
+    public static readonly string LocationNamesDescription = "Optional: A list of names that describes the locations.";
+    #endregion
 
     #region Parameter Properties
@@ -130,14 +145,14 @@
     public GeneralizedQuadraticAssignmentProblem()
       : base(new GQAPEvaluator(), new RandomSolutionCreator()) {
-      Parameters.Add(new ValueParameter<DoubleMatrix>("Weights", "The weights matrix describes the flows between the equipments.", new DoubleMatrix()));
-      Parameters.Add(new ValueParameter<DoubleMatrix>("Distances", "The distances matrix describes the distances between the locations at which the equipment can be installed.", new DoubleMatrix()));
-      Parameters.Add(new ValueParameter<DoubleMatrix>("InstallationCosts", "The installation costs matrix describes the installation costs of installing equipment i at location j", new DoubleMatrix()));
-      Parameters.Add(new FixedValueParameter<DoubleValue>("TransportationCosts", "The transportation cost represents the flow-unit per distance-unit cost factor. This value can also be set to 1 if these costs are factored into the weights matrix already.", new DoubleValue(1)));
-      Parameters.Add(new FixedValueParameter<DoubleValue>("OverbookedCapacityPenalty", "The multiplier for the constraint violation when added to the quality.", new DoubleValue(1000)));
-      Parameters.Add(new ValueParameter<DoubleArray>("Demands", "The demands vector describes the space requirements of the equipments.", new DoubleArray()));
-      Parameters.Add(new ValueParameter<DoubleArray>("Capacities", "The capacities vector describes the available space at the locations.", new DoubleArray()));
-      Parameters.Add(new OptionalValueParameter<IItem>("BestKnownSolution", "The best known solution (if available)", null));
-      Parameters.Add(new OptionalValueParameter<StringArray>("EquipmentNames", "Optional: A list of names that describes the equipments.", null, false));
-      Parameters.Add(new OptionalValueParameter<StringArray>("LocationNames", "Optional: A list of names that describes the locations.", null, false));
+      Parameters.Add(new ValueParameter<DoubleMatrix>("Weights", WeightsDescription, new DoubleMatrix()));
+      Parameters.Add(new ValueParameter<DoubleMatrix>("Distances", DistancesDescription, new DoubleMatrix()));
+      Parameters.Add(new ValueParameter<DoubleMatrix>("InstallationCosts", InstallationCostsDescription, new DoubleMatrix()));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("TransportationCosts", TransportationCostsDescription, new DoubleValue(1)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("OverbookedCapacityPenalty", OverbookedCapacityPenaltyDescription, new DoubleValue(1000)));
+      Parameters.Add(new ValueParameter<DoubleArray>("Demands", DemandsDescription, new DoubleArray()));
+      Parameters.Add(new ValueParameter<DoubleArray>("Capacities", CapacitiesDescription, new DoubleArray()));
+      Parameters.Add(new OptionalValueParameter<IItem>("BestKnownSolution", BestKnownSolutionDescription, null));
+      Parameters.Add(new OptionalValueParameter<StringArray>("EquipmentNames", EquipmentNamesDescription, null, false));
+      Parameters.Add(new OptionalValueParameter<StringArray>("LocationNames", LocationNamesDescription, null, false));
 
       WeightsParameter.ReactOnValueToStringChangedAndValueItemImageChanged = false;
@@ -223,108 +238,89 @@
 
     private void Parameterize() {
-      Evaluator.WeightsParameter.ActualName = WeightsParameter.Name;
-      Evaluator.DistancesParameter.ActualName = DistancesParameter.Name;
-      Evaluator.InstallationCostsParameter.ActualName = InstallationCostsParameter.Name;
-      Evaluator.TransportationCostsParameter.ActualName = TransportationCostsParameter.Name;
-      Evaluator.DemandsParameter.ActualName = DemandsParameter.Name;
-      Evaluator.CapacitiesParameter.ActualName = CapacitiesParameter.Name;
-      Evaluator.AssignmentParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
-
-      SolutionCreator.DemandsParameter.ActualName = DemandsParameter.Name;
-      SolutionCreator.CapacitiesParameter.ActualName = CapacitiesParameter.Name;
-
-      foreach (var op in Operators.OfType<IEquipmentAwareGQAPOperator>()) {
+
+      var operators = Operators.Union(new IOperator[] { SolutionCreator, Evaluator }).ToArray();
+
+      foreach (var op in operators.OfType<IAssignmentAwareGQAPOperator>()) {
+        op.AssignmentParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
+      }
+      foreach (var op in operators.OfType<IAssignmentsAwareGQAPOperator>()) {
+        op.AssignmentParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
+      }
+      foreach (var op in operators.OfType<IBestKnownQualityAwareGQAPOperator>()) {
+        op.BestKnownQualityParameter.ActualName = BestKnownQualityParameter.Name;
+      }
+      foreach (var op in operators.OfType<IBestKnownSolutionAwareGQAPOperator>()) {
+        op.BestKnownSolutionParameter.ActualName = BestKnownSolutionParameter.Name;
+      }
+      foreach (var op in operators.OfType<ICapacitiesAwareGQAPOperator>()) {
+        op.CapacitiesParameter.ActualName = CapacitiesParameter.Name;
+      }
+      foreach (var op in operators.OfType<IDemandsAwareGQAPOperator>()) {
         op.DemandsParameter.ActualName = DemandsParameter.Name;
       }
-      foreach (var op in Operators.OfType<IGQAPCrossover>()) {
+      foreach (var op in operators.OfType<IDistancesAwareGQAPOperator>()) {
+        op.DistancesParameter.ActualName = DistancesParameter.Name;
+      }
+      foreach (var op in operators.OfType<IEquipmentNamesAwareGQAPOperator>()) {
+        op.EquipmentNamesParameter.ActualName = EquipmentNamesParameter.Name;
+      }
+      foreach (var op in operators.OfType<IGQAPCrossover>()) {
         op.ParentsParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
         op.ChildParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
       }
-      foreach (var op in Operators.OfType<IGQAPEvaluationOperator>()) {
-        op.AssignmentParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
-        op.TransportationCostsParameter.ActualName = TransportationCostsParameter.Name;
+      foreach (var op in operators.OfType<IInstallationCostsAwareGQAPOperator>()) {
+        op.InstallationCostsParameter.ActualName = InstallationCostsParameter.Name;
+      }
+      foreach (var op in operators.OfType<ILocationNamesAwareGQAPOperator>()) {
+        op.LocationNamesParameter.ActualName = LocationNamesParameter.Name;
+      }
+      var moveEvaluator = operators.OfType<IGQAPMoveEvaluator>().FirstOrDefault();
+      foreach (var op in operators.OfType<IGQAPMoveEvaluator>()) { // synchronize all move evaluators
+        if (moveEvaluator != null) {
+          op.MoveQualityParameter.ActualName = moveEvaluator.MoveQualityParameter.ActualName;
+          op.MoveFlowDistanceQualityParameter.ActualName = moveEvaluator.MoveFlowDistanceQualityParameter.ActualName;
+          op.MoveInstallationQualityParameter.ActualName = moveEvaluator.MoveInstallationQualityParameter.ActualName;
+          op.MoveOverbookedCapacityParameter.ActualName = moveEvaluator.MoveOverbookedCapacityParameter.ActualName;
+        }
+      }
+      foreach (var op in operators.OfType<IMoveQualityAwareGQAPOperator>()) {
+        if (moveEvaluator != null) {
+          op.MoveQualityParameter.ActualName = moveEvaluator.MoveQualityParameter.ActualName;
+          op.MoveFlowDistanceQualityParameter.ActualName = moveEvaluator.MoveFlowDistanceQualityParameter.ActualName;
+          op.MoveInstallationQualityParameter.ActualName = moveEvaluator.MoveInstallationQualityParameter.ActualName;
+          op.MoveOverbookedCapacityParameter.ActualName = moveEvaluator.MoveOverbookedCapacityParameter.ActualName;
+        }
+        op.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      }
+      foreach (var op in operators.OfType<IOverbookedCapacityPenaltyAwareGQAPOperator>()) {
         op.OverbookedCapacityPenaltyParameter.ActualName = OverbookedCapacityPenaltyParameter.Name;
-        op.WeightsParameter.ActualName = WeightsParameter.Name;
-        op.DistancesParameter.ActualName = DistancesParameter.Name;
-        op.InstallationCostsParameter.ActualName = InstallationCostsParameter.Name;
-        op.DemandsParameter.ActualName = DemandsParameter.Name;
-        op.CapacitiesParameter.ActualName = CapacitiesParameter.Name;
-      }
-      foreach (var op in Operators.OfType<IGQAPLocalImprovementOperator>()) {
-        op.AssignmentParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
+      }
+      foreach (var op in operators.OfType<IQualitiesAwareGQAPOperator>()) {
         op.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
         op.FlowDistanceQualityParameter.ActualName = Evaluator.FlowDistanceQualityParameter.ActualName;
         op.InstallationQualityParameter.ActualName = Evaluator.InstallationQualityParameter.ActualName;
         op.OverbookedCapacityParameter.ActualName = Evaluator.OverbookedCapacityParameter.ActualName;
+        op.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      }
+      foreach (var op in operators.OfType<IQualityAwareGQAPOperator>()) {
+        op.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+        op.FlowDistanceQualityParameter.ActualName = Evaluator.FlowDistanceQualityParameter.ActualName;
+        op.InstallationQualityParameter.ActualName = Evaluator.InstallationQualityParameter.ActualName;
+        op.OverbookedCapacityParameter.ActualName = Evaluator.OverbookedCapacityParameter.ActualName;
+        op.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      }
+      foreach (var op in operators.OfType<ITransportationCostsAwareGQAPOperator>()) {
         op.TransportationCostsParameter.ActualName = TransportationCostsParameter.Name;
-        op.OverbookedCapacityPenaltyParameter.ActualName = OverbookedCapacityPenaltyParameter.Name;
+      }
+      foreach (var op in operators.OfType<IWeightsAwareGQAPOperator>()) {
         op.WeightsParameter.ActualName = WeightsParameter.Name;
-        op.DistancesParameter.ActualName = DistancesParameter.Name;
-        op.InstallationCostsParameter.ActualName = InstallationCostsParameter.Name;
-        op.DemandsParameter.ActualName = DemandsParameter.Name;
-        op.CapacitiesParameter.ActualName = CapacitiesParameter.Name;
-      }
-      foreach (var op in Operators.OfType<IGQAPManipulator>()) {
-        op.AssignmentParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
-      }
-      foreach (var op in Operators.OfType<IGQAPMerger>()) {
-        op.AssignmentParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
-        op.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
-        op.MaximizationParameter.ActualName = MaximizationParameter.Name;
-      }
-      foreach (var op in Operators.OfType<IGQAPMoveOperator>()) {
-        op.AssignmentParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
-      }
-      foreach (var op in Operators.OfType<ILocationAwareGQAPOperator>()) {
-        op.CapacitiesParameter.ActualName = CapacitiesParameter.Name;
-      }
-
-      foreach (var op in Operators.OfType<IIntegerVectorCrossover>()) {
+      }
+
+      foreach (var op in operators.OfType<IIntegerVectorCrossover>()) {
         op.ParentsParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
         op.ChildParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
       }
-      foreach (var op in Operators.OfType<IIntegerVectorManipulator>()) {
+      foreach (var op in operators.OfType<IIntegerVectorManipulator>()) {
         op.IntegerVectorParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
-      }
-
-      if (BestSolutionAnalyzer != null) {
-        BestSolutionAnalyzer.MaximizationParameter.ActualName = MaximizationParameter.Name;
-        BestSolutionAnalyzer.DistancesParameter.ActualName = DistancesParameter.Name;
-        BestSolutionAnalyzer.WeightsParameter.ActualName = WeightsParameter.Name;
-        BestSolutionAnalyzer.InstallationCostsParameter.ActualName = InstallationCostsParameter.Name;
-        BestSolutionAnalyzer.DemandsParameter.ActualName = DemandsParameter.Name;
-        BestSolutionAnalyzer.CapacitiesParameter.ActualName = CapacitiesParameter.Name;
-        BestSolutionAnalyzer.TransportationCostsParameter.ActualName = TransportationCostsParameter.Name;
-        BestSolutionAnalyzer.OverbookedCapacityPenaltyParameter.ActualName = OverbookedCapacityPenaltyParameter.Name;
-        BestSolutionAnalyzer.AssignmentParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
-        BestSolutionAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
-        BestSolutionAnalyzer.FlowDistanceQualityParameter.ActualName = Evaluator.FlowDistanceQualityParameter.ActualName;
-        BestSolutionAnalyzer.InstallationQualityParameter.ActualName = Evaluator.InstallationQualityParameter.ActualName;
-        BestSolutionAnalyzer.OverbookedCapacityParameter.ActualName = Evaluator.OverbookedCapacityParameter.ActualName;
-        BestSolutionAnalyzer.ResultsParameter.ActualName = "Results";
-        BestSolutionAnalyzer.BestKnownQualityParameter.ActualName = BestKnownQualityParameter.Name;
-        BestSolutionAnalyzer.BestKnownSolutionParameter.ActualName = BestKnownSolutionParameter.Name;
-        BestSolutionAnalyzer.EquipmentNamesParameter.ActualName = EquipmentNamesParameter.Name;
-        BestSolutionAnalyzer.LocationNamesParameter.ActualName = LocationNamesParameter.Name;
-      }
-      if (SolutionArchiveAnalyzer != null) {
-        SolutionArchiveAnalyzer.MaximizationParameter.ActualName = MaximizationParameter.Name;
-        SolutionArchiveAnalyzer.DistancesParameter.ActualName = DistancesParameter.Name;
-        SolutionArchiveAnalyzer.WeightsParameter.ActualName = WeightsParameter.Name;
-        SolutionArchiveAnalyzer.InstallationCostsParameter.ActualName = InstallationCostsParameter.Name;
-        SolutionArchiveAnalyzer.DemandsParameter.ActualName = DemandsParameter.Name;
-        SolutionArchiveAnalyzer.CapacitiesParameter.ActualName = CapacitiesParameter.Name;
-        SolutionArchiveAnalyzer.TransportationCostsParameter.ActualName = TransportationCostsParameter.Name;
-        SolutionArchiveAnalyzer.OverbookedCapacityPenaltyParameter.ActualName = OverbookedCapacityPenaltyParameter.Name;
-        SolutionArchiveAnalyzer.AssignmentParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
-        SolutionArchiveAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
-        SolutionArchiveAnalyzer.FlowDistanceQualityParameter.ActualName = Evaluator.FlowDistanceQualityParameter.ActualName;
-        SolutionArchiveAnalyzer.InstallationQualityParameter.ActualName = Evaluator.InstallationQualityParameter.ActualName;
-        SolutionArchiveAnalyzer.OverbookedCapacityParameter.ActualName = Evaluator.OverbookedCapacityParameter.ActualName;
-        SolutionArchiveAnalyzer.ResultsParameter.ActualName = "Results";
-        SolutionArchiveAnalyzer.BestKnownQualityParameter.ActualName = BestKnownQualityParameter.Name;
-        SolutionArchiveAnalyzer.BestKnownSolutionParameter.ActualName = BestKnownSolutionParameter.Name;
-        SolutionArchiveAnalyzer.EquipmentNamesParameter.ActualName = EquipmentNamesParameter.Name;
-        SolutionArchiveAnalyzer.LocationNamesParameter.ActualName = LocationNamesParameter.Name;
       }
     }
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment-3.3.csproj
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment-3.3.csproj	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment-3.3.csproj	(revision 7419)
@@ -99,12 +99,23 @@
     <Compile Include="GQAPIntegerVectorProximityCalculator.cs" />
     <Compile Include="GQAPSolution.cs" />
-    <Compile Include="Interfaces\IGQAPMerger.cs" />
+    <Compile Include="Interfaces\IQualitiesAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\IAssignmentsAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\IBestKnownQualityAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\IBestKnownSolutionAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\ILocationNamesAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\IEquipmentNamesAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\IMoveQualityAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\IGQAPEvaluator.cs" />
+    <Compile Include="Interfaces\IQualityAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\IOverbookedCapacityPenaltyAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\ITransportationCostsAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\IInstallationCostsAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\IDistancesAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\IWeightsAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\IAssignmentAwareGQAPOperator.cs" />
     <Compile Include="Interfaces\IGQAPNMoveEvaluator.cs" />
-    <Compile Include="Interfaces\IEquipmentAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\IDemandsAwareGQAPOperator.cs" />
     <Compile Include="Interfaces\IGQAPCrossover.cs" />
-    <Compile Include="Interfaces\IGQAPEvaluationOperator.cs" />
-    <Compile Include="Interfaces\IGQAPEvaluator.cs" />
     <Compile Include="Interfaces\IGQAPLocalImprovementOperator.cs" />
-    <Compile Include="Interfaces\IGQAPManipulator.cs" />
     <Compile Include="Interfaces\IGQAPMoveEvaluator.cs" />
     <Compile Include="Interfaces\IGQAPMoveOperator.cs" />
@@ -112,5 +123,5 @@
     <Compile Include="Interfaces\IGQAPOperator.cs" />
     <Compile Include="Interfaces\IGQAPSolutionCreator.cs" />
-    <Compile Include="Interfaces\ILocationAwareGQAPOperator.cs" />
+    <Compile Include="Interfaces\ICapacitiesAwareGQAPOperator.cs" />
     <Compile Include="Moves\NMove.cs" />
     <Compile Include="Moves\GQAPMoveGenerator.cs" />
@@ -120,4 +131,5 @@
     <Compile Include="Moves\StochasticNMoveSingleMoveGenerator.cs" />
     <Compile Include="Operators\ApproximateLocalSearch.cs" />
+    <Compile Include="Operators\GQAPPathRelinking.cs" />
     <Compile Include="Operators\GQAPStochasticSolutionCreator.cs" />
     <Compile Include="Operators\DemandEquivalentSwapEquipmentManipluator.cs" />
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IAssignmentAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IAssignmentAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IAssignmentAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface IAssignmentAwareGQAPOperator : IGQAPOperator {
+    ILookupParameter<IntegerVector> AssignmentParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IAssignmentsAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IAssignmentsAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IAssignmentsAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface IAssignmentsAwareGQAPOperator : IGQAPOperator {
+    IScopeTreeLookupParameter<IntegerVector> AssignmentParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IBestKnownQualityAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IBestKnownQualityAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IBestKnownQualityAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface IBestKnownQualityAwareGQAPOperator : IGQAPOperator {
+    ILookupParameter<DoubleValue> BestKnownQualityParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IBestKnownSolutionAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IBestKnownSolutionAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IBestKnownSolutionAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface IBestKnownSolutionAwareGQAPOperator : IGQAPOperator {
+    ILookupParameter<IntegerVector> BestKnownSolutionParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/ICapacitiesAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/ICapacitiesAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/ICapacitiesAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface ICapacitiesAwareGQAPOperator : IGQAPOperator {
+    ILookupParameter<DoubleArray> CapacitiesParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IDemandsAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IDemandsAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IDemandsAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface IDemandsAwareGQAPOperator : IGQAPOperator {
+    ILookupParameter<DoubleArray> DemandsParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IDistancesAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IDistancesAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IDistancesAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface IDistancesAwareGQAPOperator : IGQAPOperator {
+    ILookupParameter<DoubleMatrix> DistancesParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IEquipmentAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IEquipmentAwareGQAPOperator.cs	(revision 7418)
+++ 	(revision )
@@ -1,29 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
-  public interface IEquipmentAwareGQAPOperator : IGQAPOperator {
-    ILookupParameter<DoubleArray> DemandsParameter { get; }
-  }
-}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IEquipmentNamesAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IEquipmentNamesAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IEquipmentNamesAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface IEquipmentNamesAwareGQAPOperator : IGQAPOperator {
+    ILookupParameter<StringArray> EquipmentNamesParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPEvaluationOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPEvaluationOperator.cs	(revision 7418)
+++ 	(revision )
@@ -1,38 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
-
-namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
-  public interface IGQAPEvaluationOperator : IGQAPOperator { // full evaluators as well as move evaluators
-    ILookupParameter<DoubleMatrix> WeightsParameter { get; }
-    ILookupParameter<DoubleMatrix> DistancesParameter { get; }
-    ILookupParameter<DoubleMatrix> InstallationCostsParameter { get; }
-    ILookupParameter<DoubleArray> DemandsParameter { get; }
-    ILookupParameter<DoubleArray> CapacitiesParameter { get; }
-    ILookupParameter<IntegerVector> AssignmentParameter { get; }
-
-    IValueLookupParameter<DoubleValue> TransportationCostsParameter { get; }
-    IValueLookupParameter<DoubleValue> OverbookedCapacityPenaltyParameter { get; }
-  }
-}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPEvaluator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPEvaluator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPEvaluator.cs	(revision 7419)
@@ -25,5 +25,6 @@
 
 namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
-  public interface IGQAPEvaluator : IGQAPEvaluationOperator, ISingleObjectiveEvaluator {
+  public interface IGQAPEvaluator : ISingleObjectiveEvaluator {
+    ILookupParameter<BoolValue> MaximizationParameter { get; }
     ILookupParameter<DoubleValue> FlowDistanceQualityParameter { get; }
     ILookupParameter<DoubleValue> InstallationQualityParameter { get; }
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPLocalImprovementOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPLocalImprovementOperator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPLocalImprovementOperator.cs	(revision 7419)
@@ -22,23 +22,9 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
-  public interface IGQAPLocalImprovementOperator : IGQAPOperator, ILocalImprovementOperator {
-    ILookupParameter<DoubleValue> QualityParameter { get; }
-    ILookupParameter<DoubleValue> FlowDistanceQualityParameter { get; }
-    ILookupParameter<DoubleValue> InstallationQualityParameter { get; }
-    ILookupParameter<DoubleValue> OverbookedCapacityParameter { get; }
+  public interface IGQAPLocalImprovementOperator : ILocalImprovementOperator {
     IValueLookupParameter<IntValue> MaximumCandidateListSizeParameter { get; }
-    IValueLookupParameter<IntValue> MaximumSampleSizeParameter { get; }
-    ILookupParameter<IntegerVector> AssignmentParameter { get; }
-    ILookupParameter<DoubleMatrix> WeightsParameter { get; }
-    ILookupParameter<DoubleMatrix> DistancesParameter { get; }
-    ILookupParameter<DoubleMatrix> InstallationCostsParameter { get; }
-    ILookupParameter<DoubleArray> DemandsParameter { get; }
-    ILookupParameter<DoubleArray> CapacitiesParameter { get; }
-    IValueLookupParameter<DoubleValue> TransportationCostsParameter { get; }
-    IValueLookupParameter<DoubleValue> OverbookedCapacityPenaltyParameter { get; }
   }
 }
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPManipulator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPManipulator.cs	(revision 7418)
+++ 	(revision )
@@ -1,31 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Core;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
-using HeuristicLab.Optimization;
-
-namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
-  public interface IGQAPManipulator : IGQAPOperator, IManipulator {
-    ILookupParameter<IRandom> RandomParameter { get; }
-    ILookupParameter<IntegerVector> AssignmentParameter { get; }
-  }
-}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPMerger.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPMerger.cs	(revision 7418)
+++ 	(revision )
@@ -1,33 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
-using HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common;
-
-namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
-  public interface IGQAPMerger : IMerger, IGQAPOperator {
-    ILookupParameter<IntegerVector> AssignmentParameter { get; }
-    ILookupParameter<DoubleValue> QualityParameter { get; }
-    IValueLookupParameter<BoolValue> MaximizationParameter { get; }
-  }
-}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPMoveEvaluator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPMoveEvaluator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPMoveEvaluator.cs	(revision 7419)
@@ -25,8 +25,9 @@
 
 namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
-  public interface IGQAPMoveEvaluator : IGQAPEvaluationOperator, ISingleObjectiveMoveEvaluator {
-    ILookupParameter<DoubleValue> FlowDistanceQualityParameter { get; }
-    ILookupParameter<DoubleValue> InstallationQualityParameter { get; }
-    ILookupParameter<DoubleValue> OverbookedCapacityParameter { get; }
+  public interface IGQAPMoveEvaluator : IGQAPMoveOperator, ISingleObjectiveMoveEvaluator {
+    ILookupParameter<BoolValue> MaximizationParameter { get; }
+    ILookupParameter<DoubleValue> MoveFlowDistanceQualityParameter { get; }
+    ILookupParameter<DoubleValue> MoveInstallationQualityParameter { get; }
+    ILookupParameter<DoubleValue> MoveOverbookedCapacityParameter { get; }
   }
 }
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPMoveOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPMoveOperator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPMoveOperator.cs	(revision 7419)
@@ -20,11 +20,7 @@
 #endregion
 
-using HeuristicLab.Core;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
-  public interface IGQAPMoveOperator : IGQAPOperator, IMoveOperator {
-    ILookupParameter<IntegerVector> AssignmentParameter { get; }
-  }
+  public interface IGQAPMoveOperator : IMoveOperator { }
 }
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPSolutionCreator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPSolutionCreator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPSolutionCreator.cs	(revision 7419)
@@ -25,5 +25,5 @@
 
 namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
-  public interface IGQAPSolutionCreator : IGQAPOperator, ISolutionCreator, ILocationAwareGQAPOperator, IEquipmentAwareGQAPOperator {
+  public interface IGQAPSolutionCreator : ISolutionCreator {
     ILookupParameter<IntegerVector> AssignmentParameter { get; }
   }
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IInstallationCostsAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IInstallationCostsAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IInstallationCostsAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface IInstallationCostsAwareGQAPOperator : IGQAPOperator {
+    ILookupParameter<DoubleMatrix> InstallationCostsParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/ILocationAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/ILocationAwareGQAPOperator.cs	(revision 7418)
+++ 	(revision )
@@ -1,29 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
-  public interface ILocationAwareGQAPOperator : IGQAPOperator {
-    ILookupParameter<DoubleArray> CapacitiesParameter { get; }
-  }
-}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/ILocationNamesAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/ILocationNamesAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/ILocationNamesAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface ILocationNamesAwareGQAPOperator : IGQAPOperator {
+    ILookupParameter<StringArray> LocationNamesParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IMoveQualityAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IMoveQualityAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IMoveQualityAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,33 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface IMoveQualityAwareGQAPOperator : IGQAPMoveOperator {
+    ILookupParameter<BoolValue> MaximizationParameter { get; }
+    ILookupParameter<DoubleValue> MoveQualityParameter { get; }
+    ILookupParameter<DoubleValue> MoveFlowDistanceQualityParameter { get; }
+    ILookupParameter<DoubleValue> MoveInstallationQualityParameter { get; }
+    ILookupParameter<DoubleValue> MoveOverbookedCapacityParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IOverbookedCapacityPenaltyAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IOverbookedCapacityPenaltyAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IOverbookedCapacityPenaltyAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface IOverbookedCapacityPenaltyAwareGQAPOperator : IGQAPOperator {
+    IValueLookupParameter<DoubleValue> OverbookedCapacityPenaltyParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IQualitiesAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IQualitiesAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IQualitiesAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,33 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface IQualitiesAwareGQAPOperator : IGQAPOperator {
+    ILookupParameter<BoolValue> MaximizationParameter { get; }
+    IScopeTreeLookupParameter<DoubleValue> QualityParameter { get; }
+    IScopeTreeLookupParameter<DoubleValue> FlowDistanceQualityParameter { get; }
+    IScopeTreeLookupParameter<DoubleValue> InstallationQualityParameter { get; }
+    IScopeTreeLookupParameter<DoubleValue> OverbookedCapacityParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IQualityAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IQualityAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IQualityAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,33 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface IQualityAwareGQAPOperator : IGQAPOperator {
+    ILookupParameter<BoolValue> MaximizationParameter { get; }
+    ILookupParameter<DoubleValue> QualityParameter { get; }
+    ILookupParameter<DoubleValue> FlowDistanceQualityParameter { get; }
+    ILookupParameter<DoubleValue> InstallationQualityParameter { get; }
+    ILookupParameter<DoubleValue> OverbookedCapacityParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/ITransportationCostsAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/ITransportationCostsAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/ITransportationCostsAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface ITransportationCostsAwareGQAPOperator : IGQAPOperator {
+    IValueLookupParameter<DoubleValue> TransportationCostsParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IWeightsAwareGQAPOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IWeightsAwareGQAPOperator.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IWeightsAwareGQAPOperator.cs	(revision 7419)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
+  public interface IWeightsAwareGQAPOperator : IGQAPOperator {
+    ILookupParameter<DoubleMatrix> WeightsParameter { get; }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/GQAPMoveGenerator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/GQAPMoveGenerator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/GQAPMoveGenerator.cs	(revision 7419)
@@ -31,5 +31,5 @@
   [Item("GQAPMoveGenerator", "Base class for move generators for the Generalized Quadratic Assignment Problem.")]
   [StorableClass]
-  public abstract class GQAPMoveGenerator : SingleSuccessorOperator, IMoveGenerator, IGQAPMoveOperator {
+  public abstract class GQAPMoveGenerator : SingleSuccessorOperator, IAssignmentAwareGQAPOperator, IMoveGenerator, IGQAPMoveOperator {
 
     public ILookupParameter<IntegerVector> AssignmentParameter {
@@ -42,5 +42,5 @@
     public GQAPMoveGenerator()
       : base() {
-      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", "The current equipment-location assignment."));
+      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", GQAPSolutionCreator.AssignmentDescription));
     }
   }
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/GQAPNMoveGenerator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/GQAPNMoveGenerator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/GQAPNMoveGenerator.cs	(revision 7419)
@@ -34,4 +34,8 @@
   public abstract class GQAPNMoveGenerator : GQAPMoveGenerator, IGQAPNMoveOperator {
 
+    #region Parameter Descriptions
+    public static readonly string MoveDescription = "Moves represent changes to the current solution. The n-move changes the assignment of up to or exactly n equipments.";
+    #endregion
+
     public ILookupParameter<NMove> MoveParameter {
       get { return (ILookupParameter<NMove>)Parameters["Move"]; }
@@ -46,5 +50,5 @@
     public GQAPNMoveGenerator()
       : base() {
-      Parameters.Add(new LookupParameter<NMove>("Move", "The move to generate."));
+      Parameters.Add(new LookupParameter<NMove>("Move", MoveDescription));
       Parameters.Add(new ValueLookupParameter<IntValue>("N", "The maximum number of equipment(s) that should be moved.", new IntValue(2)));
     }
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/NMoveMaker.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/NMoveMaker.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/NMoveMaker.cs	(revision 7419)
@@ -32,5 +32,5 @@
   [Item("NMoveMaker", "Performs an n-move.")]
   [StorableClass]
-  public class NMoveMaker : SingleSuccessorOperator, IGQAPNMoveOperator, IMoveMaker {
+  public class NMoveMaker : SingleSuccessorOperator, IAssignmentAwareGQAPOperator, IQualityAwareGQAPOperator, IMoveQualityAwareGQAPOperator, IGQAPNMoveOperator, IMoveMaker {
 
     public ILookupParameter<IntegerVector> AssignmentParameter {
@@ -39,4 +39,13 @@
     public ILookupParameter<NMove> MoveParameter {
       get { return (ILookupParameter<NMove>)Parameters["Move"]; }
+    }
+    ILookupParameter<BoolValue> IQualityAwareGQAPOperator.MaximizationParameter {
+      get { return MaximizationParameter; }
+    }
+    ILookupParameter<BoolValue> IMoveQualityAwareGQAPOperator.MaximizationParameter {
+      get { return MaximizationParameter; }
+    }
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
     public ILookupParameter<DoubleValue> QualityParameter {
@@ -70,14 +79,15 @@
     public NMoveMaker()
       : base() {
-      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", "The equipment-location assignment vector."));
-      Parameters.Add(new LookupParameter<NMove>("Move", "The move to perform."));
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The solution quality."));
-      Parameters.Add(new LookupParameter<DoubleValue>("FlowDistanceQuality", "The quality regarding the flow-distance criteria."));
-      Parameters.Add(new LookupParameter<DoubleValue>("InstallationQuality", "The quality regarding the installation costs."));
-      Parameters.Add(new LookupParameter<DoubleValue>("OverbookedCapacity", "The sum of the overbooked capacities relative to the capacity of each location."));
-      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the move if it would be applied."));
-      Parameters.Add(new LookupParameter<DoubleValue>("MoveFlowDistanceQuality", "The quality of the move regarding the flow-distance criteria."));
-      Parameters.Add(new LookupParameter<DoubleValue>("MoveInstallationQuality", "The quality of the move regarding the installation costs."));
-      Parameters.Add(new LookupParameter<DoubleValue>("MoveOverbookedCapacity", "The sum of the overbooked capacities of the move relative to the capacity of each location."));
+      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", GQAPSolutionCreator.AssignmentDescription));
+      Parameters.Add(new LookupParameter<NMove>("Move", GQAPNMoveGenerator.MoveDescription));
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", GeneralizedQuadraticAssignmentProblem.MaximizationDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", GQAPEvaluator.QualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("FlowDistanceQuality", GQAPEvaluator.FlowDistanceQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("InstallationQuality", GQAPEvaluator.InstallationQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("OverbookedCapacity", GQAPEvaluator.OverbookedCapacityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", GQAPNMoveEvaluator.MoveQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveFlowDistanceQuality", GQAPNMoveEvaluator.MoveFlowDistanceQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveInstallationQuality", GQAPNMoveEvaluator.MoveInstallationQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveOverbookedCapacity", GQAPNMoveEvaluator.MoveOverbookedCapacityDescription));
     }
 
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/StochasticNMoveMultiMoveGenerator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/StochasticNMoveMultiMoveGenerator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/StochasticNMoveMultiMoveGenerator.cs	(revision 7419)
@@ -32,11 +32,11 @@
   [Item("Stochastic n-move MultiMoveGenerator", "Randomly samples a number of n-moves.")]
   [StorableClass]
-  public class StochasticNMoveMultiMoveGenerator : GQAPNMoveGenerator, ILocationAwareGQAPOperator, IMultiMoveGenerator, IStochasticOperator {
+  public class StochasticNMoveMultiMoveGenerator : GQAPNMoveGenerator, ICapacitiesAwareGQAPOperator, IStochasticOperator, IMultiMoveGenerator {
 
+    public ILookupParameter<DoubleArray> CapacitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Capacities"]; }
+    }
     public ILookupParameter<IRandom> RandomParameter {
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public ILookupParameter<DoubleArray> CapacitiesParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters["Capacities"]; }
     }
     public IValueLookupParameter<IntValue> SampleSizeParameter {
@@ -50,5 +50,5 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator that should be used."));
-      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", "Capacities of the locations."));
+      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", GeneralizedQuadraticAssignmentProblem.CapacitiesDescription));
       Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));
     }
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/StochasticNMoveSingleMoveGenerator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/StochasticNMoveSingleMoveGenerator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/StochasticNMoveSingleMoveGenerator.cs	(revision 7419)
@@ -32,11 +32,11 @@
   [Item("Stochastic n-move SingleMoveGenerator", "Randomly samples a single n-move.")]
   [StorableClass]
-  public class StochasticNMoveSingleMoveGenerator : GQAPNMoveGenerator, ILocationAwareGQAPOperator, ISingleMoveGenerator, IStochasticOperator {
+  public class StochasticNMoveSingleMoveGenerator : GQAPNMoveGenerator, ICapacitiesAwareGQAPOperator, IStochasticOperator, ISingleMoveGenerator {
 
+    public ILookupParameter<DoubleArray> CapacitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Capacities"]; }
+    }
     public ILookupParameter<IRandom> RandomParameter {
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public ILookupParameter<DoubleArray> CapacitiesParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters["Capacities"]; }
     }
 
@@ -47,5 +47,5 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator that should be used."));
-      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", "Capacities of the locations."));
+      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", GeneralizedQuadraticAssignmentProblem.CapacitiesDescription));
     }
 
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/ApproximateLocalSearch.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/ApproximateLocalSearch.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/ApproximateLocalSearch.cs	(revision 7419)
@@ -33,9 +33,10 @@
 
 namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment.Operators {
-  [Item("ApproximateLocalSearch", @"The approximate local search is described in Mateus, G., Resende, M., and Silva, R. 2011. GRASP with path-relinking for the generalized quadratic assignment problem. Journal of Heuristics 17, Springer Netherlands, pp. 527-565.
-
-The implementation differs slightly from Mateus et al. in that the maximumIterations parameter defines a cap on the number of steps that the local search can perform. While the maxSampleSize parameter corresponds to the maxItr parameter defined by Mateus et al.")]
+  [Item("ApproximateLocalSearch", "The approximate local search is described in Mateus, G., Resende, M., and Silva, R. 2011. GRASP with path-relinking for the generalized quadratic assignment problem. Journal of Heuristics 17, Springer Netherlands, pp. 527-565.")]
   [StorableClass]
-  public class ApproximateLocalSearch : SingleSuccessorOperator, IGQAPLocalImprovementOperator, IStochasticOperator {
+  public class ApproximateLocalSearch : SingleSuccessorOperator, IDemandsAwareGQAPOperator, ICapacitiesAwareGQAPOperator,
+    IWeightsAwareGQAPOperator, IDistancesAwareGQAPOperator, IInstallationCostsAwareGQAPOperator,
+    ITransportationCostsAwareGQAPOperator, IOverbookedCapacityPenaltyAwareGQAPOperator,
+    IAssignmentAwareGQAPOperator, IQualityAwareGQAPOperator, IGQAPLocalImprovementOperator, IStochasticOperator {
     public IProblem Problem { get; set; }
     public Type ProblemType {
@@ -43,60 +44,60 @@
     }
 
+    public ILookupParameter<DoubleArray> DemandsParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Demands"]; }
+    }
+    public ILookupParameter<DoubleArray> CapacitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Capacities"]; }
+    }
+    public ILookupParameter<DoubleMatrix> WeightsParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Weights"]; }
+    }
+    public ILookupParameter<DoubleMatrix> DistancesParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Distances"]; }
+    }
+    public ILookupParameter<DoubleMatrix> InstallationCostsParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["InstallationCosts"]; }
+    }
+    public IValueLookupParameter<DoubleValue> TransportationCostsParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["TransportationCosts"]; }
+    }
+    public IValueLookupParameter<DoubleValue> OverbookedCapacityPenaltyParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["OverbookedCapacityPenalty"]; }
+    }
+    public ILookupParameter<IntegerVector> AssignmentParameter {
+      get { return (ILookupParameter<IntegerVector>)Parameters["Assignment"]; }
+    }
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> FlowDistanceQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["FlowDistanceQuality"]; }
+    }
+    public ILookupParameter<DoubleValue> InstallationQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["InstallationQuality"]; }
+    }
+    public ILookupParameter<DoubleValue> OverbookedCapacityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["OverbookedCapacity"]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
+    }
+    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
+    }
     public ILookupParameter<IRandom> RandomParameter {
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
-    }
-    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
-      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
-    }
-    public ILookupParameter<DoubleValue> QualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
-    }
-    public ILookupParameter<DoubleValue> FlowDistanceQualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["FlowDistanceQuality"]; }
-    }
-    public ILookupParameter<DoubleValue> InstallationQualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["InstallationQuality"]; }
-    }
-    public ILookupParameter<DoubleValue> OverbookedCapacityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["OverbookedCapacity"]; }
+    public IValueLookupParameter<IntValue> MaximumCandidateListSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumCandidateListSize"]; }
+    }
+    public IValueLookupParameter<PercentValue> OneMoveProbabilityParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters["OneMoveProbability"]; }
     }
     public ILookupParameter<ResultCollection> ResultsParameter {
       get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
-    }
-    public IValueLookupParameter<IntValue> MaximumCandidateListSizeParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumCandidateListSize"]; }
-    }
-    public IValueLookupParameter<IntValue> MaximumSampleSizeParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumSampleSize"]; }
-    }
-    public ILookupParameter<IntegerVector> AssignmentParameter {
-      get { return (ILookupParameter<IntegerVector>)Parameters["Assignment"]; }
-    }
-    public ILookupParameter<DoubleMatrix> WeightsParameter {
-      get { return (ILookupParameter<DoubleMatrix>)Parameters["Weights"]; }
-    }
-    public ILookupParameter<DoubleMatrix> DistancesParameter {
-      get { return (ILookupParameter<DoubleMatrix>)Parameters["Distances"]; }
-    }
-    public ILookupParameter<DoubleMatrix> InstallationCostsParameter {
-      get { return (ILookupParameter<DoubleMatrix>)Parameters["InstallationCosts"]; }
-    }
-    public ILookupParameter<DoubleArray> DemandsParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters["Demands"]; }
-    }
-    public ILookupParameter<DoubleArray> CapacitiesParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters["Capacities"]; }
-    }
-    public IValueLookupParameter<DoubleValue> TransportationCostsParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters["TransportationCosts"]; }
-    }
-    public IValueLookupParameter<DoubleValue> OverbookedCapacityPenaltyParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters["OverbookedCapacityPenalty"]; }
-    }
-    public IValueLookupParameter<PercentValue> OneMoveProbabilityParameter {
-      get { return (IValueLookupParameter<PercentValue>)Parameters["OneMoveProbability"]; }
     }
 
@@ -106,23 +107,23 @@
     public ApproximateLocalSearch()
       : base() {
-      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new LookupParameter<DoubleArray>("Demands", GeneralizedQuadraticAssignmentProblem.DemandsDescription));
+      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", GeneralizedQuadraticAssignmentProblem.CapacitiesDescription));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("Weights", GeneralizedQuadraticAssignmentProblem.WeightsDescription));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("Distances", GeneralizedQuadraticAssignmentProblem.DistancesDescription));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("InstallationCosts", GeneralizedQuadraticAssignmentProblem.InstallationCostsDescription));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("TransportationCosts", GeneralizedQuadraticAssignmentProblem.TransportationCostsDescription));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("OverbookedCapacityPenalty", GeneralizedQuadraticAssignmentProblem.OverbookedCapacityPenaltyDescription));
+      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", GQAPSolutionCreator.AssignmentDescription));
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", GeneralizedQuadraticAssignmentProblem.MaximizationDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", GQAPEvaluator.QualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("FlowDistanceQuality", GQAPEvaluator.FlowDistanceQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("InstallationQuality", GQAPEvaluator.InstallationQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("OverbookedCapacity", GQAPEvaluator.OverbookedCapacityDescription));
       Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of iterations that should be performed."));
       Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of evaluated solution equivalents."));
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The solution quality."));
-      Parameters.Add(new LookupParameter<DoubleValue>("FlowDistanceQuality", "The quality regarding the flow-distance criteria."));
-      Parameters.Add(new LookupParameter<DoubleValue>("InstallationQuality", "The quality regarding the installation costs."));
-      Parameters.Add(new LookupParameter<DoubleValue>("OverbookedCapacity", "The sum of the overbooked capacities relative to the capacity of each location."));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumCandidateListSize", "The maximum number of candidates that should be found in each step.", new IntValue(10)));
+      Parameters.Add(new ValueLookupParameter<PercentValue>("OneMoveProbability", "The probability for performing a 1-move, which is the opposite of performing a 2-move.", new PercentValue(.5)));
       Parameters.Add(new LookupParameter<ResultCollection>("Results", "The result collection that stores the results."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumCandidateListSize", "The maximum number of candidates that should be found in each step.", new IntValue(10)));
-      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumSampleSize", "The maximum number of candidates that should be sampled in each step.", new IntValue(100)));
-      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", "The equipment-location assignment vector."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("Weights", "The weights matrix describes the flows between the equipments."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("Distances", "The distances matrix describes the distances between the locations at which the equipment can be installed."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("InstallationCosts", "The installation costs matrix describes the installation costs of installing equipment i at location j."));
-      Parameters.Add(new LookupParameter<DoubleArray>("Demands", "The demands vector describes the space requirements of the equipments."));
-      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", "The capacities vector describes the available space at the locations."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("TransportationCosts", "The transportation cost represents the flow-unit per distance-unit cost factor. This value can also be set to 1 if these costs are factored into the weights matrix already."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("OverbookedCapacityPenalty", "The multiplier for the constraint violation when added to the quality."));
-      Parameters.Add(new ValueLookupParameter<PercentValue>("OneMoveProbability", "The probability for performing a 1-move, which is the opposite of performing a 2-move.", new PercentValue(.5)));
     }
 
@@ -143,6 +144,5 @@
     /// <param name="overbookedCapacity">The sum of the overbooked capacities relative to the capacity of each location.</param>
     /// <param name="maxCLS">The maximum number of candidates that should be found in each step.</param>
-    /// <param name="maxSampleSize">The maximum number of candidates that should be sampled in each step.</param>
-    /// <param name="maximumIterations">The maximum number of iterations that should be performed.</param>
+    /// <param name="maximumIterations">The maximum number of iterations that should be performed each time the candidate list is generated.</param>
     /// <param name="weights">The weights matrix describes the flows between the equipments.</param>
     /// <param name="distances">The distances matrix describes the distances between the locations at which the equipment can be installed.</param>
@@ -155,9 +155,9 @@
     public static void Apply(IRandom random, IntegerVector assignment,
       DoubleValue quality, DoubleValue flowDistanceQuality, DoubleValue installationQuality, DoubleValue overbookedCapacity,
-      IntValue maxCLS, IntValue maxSampleSize, IntValue maximumIterations,
+      IntValue maxCLS, IntValue maximumIterations,
       DoubleMatrix weights, DoubleMatrix distances, DoubleMatrix installationCosts, DoubleArray demands, DoubleArray capacities,
       DoubleValue transportationCosts, DoubleValue overbookedCapacityPenalty, PercentValue oneMoveProbability) {
 
-      for (int i = 0; i < maximumIterations.Value; i++) {
+      while (true) {
         int count = 0;
         var CLS = new List<Tuple<NMove, double, double, double, double>>();
@@ -180,5 +180,5 @@
           }
           count++;
-        } while (CLS.Count < maxCLS.Value && count < maxSampleSize.Value);
+        } while (CLS.Count < maxCLS.Value && count < maximumIterations.Value);
 
         if (CLS.Count == 0)
@@ -211,5 +211,4 @@
         OverbookedCapacityParameter.ActualValue,
         MaximumCandidateListSizeParameter.ActualValue,
-        MaximumSampleSizeParameter.ActualValue,
         MaximumIterationsParameter.ActualValue,
         WeightsParameter.ActualValue, DistancesParameter.ActualValue,
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/DemandEquivalentSwapEquipmentManipluator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/DemandEquivalentSwapEquipmentManipluator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/DemandEquivalentSwapEquipmentManipluator.cs	(revision 7419)
@@ -35,11 +35,11 @@
   [Item("DemandEquivalentSwapEquipmentManipluator", "Swaps equipment X from location A with as much equipments from location B that the demand of X is less than or equal to the demand of the swapped equipments in B.")]
   [StorableClass]
-  public class DemandEquivalentSwapEquipmentManipluator : GQAPManipulator, ILocationAwareGQAPOperator, IEquipmentAwareGQAPOperator {
+  public class DemandEquivalentSwapEquipmentManipluator : GQAPManipulator, IDemandsAwareGQAPOperator, ICapacitiesAwareGQAPOperator {
 
+    public ILookupParameter<DoubleArray> DemandsParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Demands"]; }
+    }
     public ILookupParameter<DoubleArray> CapacitiesParameter {
       get { return (ILookupParameter<DoubleArray>)Parameters["Capacities"]; }
-    }
-    public ILookupParameter<DoubleArray> DemandsParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters["Demands"]; }
     }
 
@@ -49,6 +49,6 @@
     public DemandEquivalentSwapEquipmentManipluator()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", "The capacities vector describes the available space at the locations."));
-      Parameters.Add(new LookupParameter<DoubleArray>("Demands", "The demands vector describes the space requirements of the equipments."));
+      Parameters.Add(new LookupParameter<DoubleArray>("Demands", GeneralizedQuadraticAssignmentProblem.DemandsDescription));
+      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", GeneralizedQuadraticAssignmentProblem.CapacitiesDescription));
     }
 
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/DiscreteLocationCrossover.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/DiscreteLocationCrossover.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/DiscreteLocationCrossover.cs	(revision 7419)
@@ -33,5 +33,5 @@
   [Item("DiscreteLocationCrossover", "Combines the assignment to locations from various parents.")]
   [StorableClass]
-  public class DiscreteLocationCrossover : GQAPCrossover, ILocationAwareGQAPOperator {
+  public class DiscreteLocationCrossover : GQAPCrossover, ICapacitiesAwareGQAPOperator {
 
     public ILookupParameter<DoubleArray> CapacitiesParameter {
@@ -45,5 +45,5 @@
     public DiscreteLocationCrossover()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", "The capacities vector describes the available space at the locations."));
+      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", GeneralizedQuadraticAssignmentProblem.CapacitiesDescription));
     }
 
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GQAPCrossover.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GQAPCrossover.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GQAPCrossover.cs	(revision 7419)
@@ -36,7 +36,5 @@
       get { return false; }
     }
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
+
     public IScopeTreeLookupParameter<IntegerVector> ParentsParameter {
       get { return (ScopeTreeLookupParameter<IntegerVector>)Parameters["Parents"]; }
@@ -44,4 +42,7 @@
     public ILookupParameter<IntegerVector> ChildParameter {
       get { return (ILookupParameter<IntegerVector>)Parameters["Child"]; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
 
@@ -51,7 +52,7 @@
     protected GQAPCrossover()
       : base() {
-      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
       Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>("Parents", "The parent vectors which should be crossed.", "Assignment"));
       Parameters.Add(new LookupParameter<IntegerVector>("Child", "The child vector resulting from the crossover.", "Assignment"));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
     }
 
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GQAPManipulator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GQAPManipulator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GQAPManipulator.cs	(revision 7419)
@@ -31,13 +31,14 @@
   [Item("GQAPManipulator", "A base class for operators that manipulate assignment vectors of the GeneralizedQuadraticAssignment problems.")]
   [StorableClass]
-  public abstract class GQAPManipulator : SingleSuccessorOperator, IGQAPManipulator, IStochasticOperator {
+  public abstract class GQAPManipulator : SingleSuccessorOperator, IAssignmentAwareGQAPOperator, IManipulator, IStochasticOperator {
     public override bool CanChangeName {
       get { return false; }
     }
+
+    public ILookupParameter<IntegerVector> AssignmentParameter {
+      get { return (ILookupParameter<IntegerVector>)Parameters["Assignment"]; }
+    }
     public ILookupParameter<IRandom> RandomParameter {
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public ILookupParameter<IntegerVector> AssignmentParameter {
-      get { return (ILookupParameter<IntegerVector>)Parameters["IntegerVector"]; }
     }
 
@@ -47,6 +48,6 @@
     protected GQAPManipulator()
       : base() {
+      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", GQAPSolutionCreator.AssignmentDescription));
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new LookupParameter<IntegerVector>("IntegerVector", "The assignment vector which should be manipulated."));
     }
 
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GQAPPathRelinking.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GQAPPathRelinking.cs	(revision 7419)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GQAPPathRelinking.cs	(revision 7419)
@@ -0,0 +1,48 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment.Operators {
+  [Item("GQAPPathRelinking", "Operator that performs path relinking between two solutions.")]
+  [StorableClass]
+  public class GQAPPathRelinking : GQAPCrossover {
+
+    [StorableConstructor]
+    protected GQAPPathRelinking(bool deserializing) : base(deserializing) { }
+    protected GQAPPathRelinking(GQAPPathRelinking original, Cloner cloner) : base(original, cloner) { }
+    public GQAPPathRelinking()
+      : base() {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GQAPPathRelinking(this, cloner);
+    }
+
+    protected override IntegerVector Cross(IRandom random, ItemArray<IntegerVector> parents) {
+      throw new NotImplementedException();
+    }
+  }
+}
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GQAPSolutionCreator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GQAPSolutionCreator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GQAPSolutionCreator.cs	(revision 7419)
@@ -31,14 +31,18 @@
   [Item("GQAPSolutionCreator", "Base class for solution creators of the Generalized Quadratic Assignment Problem.")]
   [StorableClass]
-  public abstract class GQAPSolutionCreator : SingleSuccessorOperator, IGQAPSolutionCreator {
+  public abstract class GQAPSolutionCreator : SingleSuccessorOperator, IDemandsAwareGQAPOperator, ICapacitiesAwareGQAPOperator, IGQAPSolutionCreator {
+
+    #region Parameter Descriptions
+    public static readonly string AssignmentDescription = "The vector that encodes the assignment.";
+    #endregion
 
     public ILookupParameter<IntegerVector> AssignmentParameter {
       get { return (ILookupParameter<IntegerVector>)Parameters["Assignment"]; }
     }
+    public ILookupParameter<DoubleArray> DemandsParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Demands"]; }
+    }
     public ILookupParameter<DoubleArray> CapacitiesParameter {
       get { return (ILookupParameter<DoubleArray>)Parameters["Capacities"]; }
-    }
-    public ILookupParameter<DoubleArray> DemandsParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters["Demands"]; }
     }
 
@@ -49,7 +53,7 @@
     public GQAPSolutionCreator()
       : base() {
-      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", "Creates an assignment for the Generalized Quadratic Assignment Problem."));
-      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", "The capacities vector describes the available space at the locations."));
-      Parameters.Add(new LookupParameter<DoubleArray>("Demands", "The demands vector describes the space requirements of the equipments."));
+      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", AssignmentDescription));
+      Parameters.Add(new LookupParameter<DoubleArray>("Demands", GeneralizedQuadraticAssignmentProblem.DemandsDescription));
+      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", GeneralizedQuadraticAssignmentProblem.CapacitiesDescription));
     }
 
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/NMoveShakingOperator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/NMoveShakingOperator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/NMoveShakingOperator.cs	(revision 7419)
@@ -32,11 +32,11 @@
   [Item("NMoveShakingOperator", "Performs a number of shaking operations that increase in strength.")]
   [StorableClass]
-  public class NMoveShakingOperator : SingleSuccessorOperator, ILocationAwareGQAPOperator, IGQAPOperator, IMultiNeighborhoodShakingOperator, IStochasticOperator {
+  public class NMoveShakingOperator : SingleSuccessorOperator, IAssignmentAwareGQAPOperator, ICapacitiesAwareGQAPOperator, IMultiNeighborhoodShakingOperator, IStochasticOperator {
 
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
-    }
     public ILookupParameter<IntegerVector> AssignmentParameter {
       get { return (ILookupParameter<IntegerVector>)Parameters["Assignment"]; }
+    }
+    public ILookupParameter<DoubleArray> CapacitiesParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Capacities"]; }
     }
     public IValueLookupParameter<IntValue> CurrentNeighborhoodIndexParameter {
@@ -46,6 +46,6 @@
       get { return (ILookupParameter<IntValue>)Parameters["NeighborhoodCount"]; }
     }
-    public ILookupParameter<DoubleArray> CapacitiesParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters["Capacities"]; }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
     }
 
@@ -54,9 +54,9 @@
     protected NMoveShakingOperator(NMoveShakingOperator original, Cloner cloner) : base(original, cloner) { }
     public NMoveShakingOperator() {
-      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
-      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", "The equipment-location assignment vector."));
+      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", GQAPSolutionCreator.AssignmentDescription));
+      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", GeneralizedQuadraticAssignmentProblem.CapacitiesDescription));
       Parameters.Add(new ValueLookupParameter<IntValue>("CurrentNeighborhoodIndex", "The index of the operator that should be applied (k)."));
       Parameters.Add(new LookupParameter<IntValue>("NeighborhoodCount", "The number of operators that are available."));
-      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", "The capacities vector describes the available space at the locations."));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
     }
 
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/QualitySimilarityMerger.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/QualitySimilarityMerger.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/QualitySimilarityMerger.cs	(revision 7419)
@@ -29,20 +29,30 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common;
 
 namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment.Operators {
   [Item("QualitySimilarityMerger", "Merges two populations by using quality and similarity information to maintain a population of high quality, but also diverse solutions.")]
   [StorableClass]
-  public class QualitySimilarityMerger : SingleSuccessorOperator, IGQAPMerger {
+  public class QualitySimilarityMerger : SingleSuccessorOperator, IAssignmentAwareGQAPOperator, IQualityAwareGQAPOperator, IMerger {
     public ILookupParameter<IntegerVector> AssignmentParameter {
       get { return (ILookupParameter<IntegerVector>)Parameters["Assignment"]; }
+    }
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
     public ILookupParameter<DoubleValue> QualityParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
+    public ILookupParameter<DoubleValue> FlowDistanceQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["FlowDistanceQuality"]; }
+    }
+    public ILookupParameter<DoubleValue> InstallationQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["InstallationQuality"]; }
+    }
+    public ILookupParameter<DoubleValue> OverbookedCapacityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["OverbookedCapacity"]; }
+    }
     public ILookupParameter<IntValue> PopulationSizeParameter {
       get { return (ILookupParameter<IntValue>)Parameters["PopulationSize"]; }
-    }
-    public IValueLookupParameter<BoolValue> MaximizationParameter {
-      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
     }
 
@@ -52,8 +62,11 @@
     public QualitySimilarityMerger()
       : base() {
-      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", "The equipment-location assignment."));
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of a solution."));
+      Parameters.Add(new LookupParameter<IntegerVector>("Assignment", GQAPSolutionCreator.AssignmentDescription));
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", GeneralizedQuadraticAssignmentProblem.MaximizationDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", GQAPEvaluator.QualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("FlowDistanceQuality", GQAPEvaluator.FlowDistanceQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("InstallationQuality", GQAPEvaluator.InstallationQualityDescription));
+      Parameters.Add(new LookupParameter<DoubleValue>("OverbookedCapacity", GQAPEvaluator.OverbookedCapacityDescription));
       Parameters.Add(new LookupParameter<IntValue>("PopulationSize", "The size of the population that should not be surpassed."));
-      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is to be maximized, false otherwise."));
     }
 
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/RelocateEquipmentManipluator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/RelocateEquipmentManipluator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/RelocateEquipmentManipluator.cs	(revision 7419)
@@ -35,5 +35,5 @@
   [Item("RelocateEquipmentManipluator", "Relocates a random equipment from an overstuffed location to a random one with space or a random equipment if constraints are satisfied.")]
   [StorableClass]
-  public class RelocateEquipmentManipluator : GQAPManipulator, ILocationAwareGQAPOperator, IEquipmentAwareGQAPOperator {
+  public class RelocateEquipmentManipluator : GQAPManipulator, IDemandsAwareGQAPOperator, ICapacitiesAwareGQAPOperator {
 
     public ILookupParameter<DoubleArray> CapacitiesParameter {
@@ -49,6 +49,6 @@
     public RelocateEquipmentManipluator()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", "The capacities vector describes the available space at the locations."));
-      Parameters.Add(new LookupParameter<DoubleArray>("Demands", "The demands vector describes the space requirements of the equipments."));
+      Parameters.Add(new LookupParameter<DoubleArray>("Demands", GeneralizedQuadraticAssignmentProblem.DemandsDescription));
+      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", GeneralizedQuadraticAssignmentProblem.CapacitiesDescription));
     }
 
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/SwapLocationManipulator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/SwapLocationManipulator.cs	(revision 7418)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/SwapLocationManipulator.cs	(revision 7419)
@@ -33,5 +33,5 @@
   [Item("SwapLocationManipluator", "Swaps two locations by exchanging all equipments between the locations.")]
   [StorableClass]
-  public class SwapLocationManipluator : GQAPManipulator, ILocationAwareGQAPOperator {
+  public class SwapLocationManipluator : GQAPManipulator, ICapacitiesAwareGQAPOperator {
 
     public ILookupParameter<DoubleArray> CapacitiesParameter {
@@ -44,5 +44,5 @@
     public SwapLocationManipluator()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", "The capacities vector describes the available space at the locations."));
+      Parameters.Add(new LookupParameter<DoubleArray>("Capacities", GeneralizedQuadraticAssignmentProblem.CapacitiesDescription));
     }
 
