Changeset 7412

Timestamp:

01/25/12 18:32:44 (13 years ago)

Author:

abeham

Message:

#1614: worked on GQAP and GRASP+PR

Location:

branches/GeneralizedQAP

Files:

• . (modified) (1 prop)
• GeneralizedQAP.sln (modified) (2 diffs)
• GeneralizedQAP.vsmdi (added)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/GRASPWithPathRelinking.cs (modified) (10 diffs)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/GRASPWithPathRelinkingMainLoop.cs (modified) (6 diffs)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common-3.3.csproj (modified) (1 diff)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common/3.3/IMerger.cs (modified) (1 diff)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common/3.3/IntegerVectorEqualityComparer.cs (added)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3 (modified) (1 prop)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/GQAPAssignmentView.Designer.cs (modified) (3 diffs)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/GQAPAssignmentView.cs (modified) (1 diff)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views-3.3.csproj (modified) (3 diffs)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Analyzers/BestGQAPSolutionAnalyzer.cs (modified) (1 diff)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Evaluators/GQAPEvaluator.cs (modified) (5 diffs)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Evaluators/GQAPNMoveEvaluator.cs (modified) (5 diffs)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/GQAPIntegerVectorProximityCalculator.cs (added)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/GeneralizedQuadraticAssignmentProblem.cs (modified) (5 diffs)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment-3.3.csproj (modified) (2 diffs)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPEvaluationOperator.cs (modified) (1 diff)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPEvaluator.cs (modified) (1 diff)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPLocalImprovementOperator.cs (modified) (2 diffs)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPMerger.cs (added)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPMoveEvaluator.cs (modified) (1 diff)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/NMoveMaker.cs (modified) (3 diffs)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/StochasticNMoveMultiMoveGenerator.cs (modified) (1 diff)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/StochasticNMoveSingleMoveGenerator.cs (modified) (2 diffs)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/ApproximateLocalSearch.cs (modified) (8 diffs)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GreedyRandomizedSolutionCreator.cs (modified) (1 diff)
• HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/QualitySimilarityMerger.cs (added)
• Local.testsettings (added)
• TraceAndTestImpact.testsettings (added)
• UnitTests (added)
• UnitTests/GQAPNMoveEvaluatorTest.cs (added)
• UnitTests/Properties (added)
• UnitTests/Properties/AssemblyInfo.cs (added)
• UnitTests/UnitTests.csproj (added)

branches/GeneralizedQAP

@@ -1 +1 @@
 *.suo
+TestResults

@@ -1 +1 @@
 *.suo
+TestResults

branches/GeneralizedQAP/GeneralizedQAP.sln

@@ -10 +10 @@
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common-3.3", "HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common\3.3\HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common-3.3.csproj", "{DA367BE5-4F53-4243-933B-32AAB86189D5}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitTests", "UnitTests\UnitTests.csproj", "{68C6C157-08DA-414F-9256-CCCA13038399}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{7275B9B0-0E8D-471E-9F64-067E1F85BB71}"
+  ProjectSection(SolutionItems) = preProject
+    GeneralizedQAP.vsmdi = GeneralizedQAP.vsmdi
+    Local.testsettings = Local.testsettings
+    TraceAndTestImpact.testsettings = TraceAndTestImpact.testsettings
+  EndProjectSection
+EndProject
 Global
+  GlobalSection(TestCaseManagementSettings) = postSolution
+    CategoryFile = GeneralizedQAP.vsmdi
+  EndGlobalSection
   GlobalSection(SolutionConfigurationPlatforms) = preSolution
     Debug|Any CPU = Debug|Any CPU
@@ -52 +64 @@
     {DA367BE5-4F53-4243-933B-32AAB86189D5}.Release|x64.ActiveCfg = Release|Any CPU
     {DA367BE5-4F53-4243-933B-32AAB86189D5}.Release|x86.ActiveCfg = Release|Any CPU
+    {68C6C157-08DA-414F-9256-CCCA13038399}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+    {68C6C157-08DA-414F-9256-CCCA13038399}.Debug|Any CPU.Build.0 = Debug|Any CPU
+    {68C6C157-08DA-414F-9256-CCCA13038399}.Debug|x64.ActiveCfg = Debug|Any CPU
+    {68C6C157-08DA-414F-9256-CCCA13038399}.Debug|x86.ActiveCfg = Debug|Any CPU
+    {68C6C157-08DA-414F-9256-CCCA13038399}.Release|Any CPU.ActiveCfg = Release|Any CPU
+    {68C6C157-08DA-414F-9256-CCCA13038399}.Release|Any CPU.Build.0 = Release|Any CPU
+    {68C6C157-08DA-414F-9256-CCCA13038399}.Release|x64.ActiveCfg = Release|Any CPU
+    {68C6C157-08DA-414F-9256-CCCA13038399}.Release|x86.ActiveCfg = Release|Any CPU
   EndGlobalSection
   GlobalSection(SolutionProperties) = preSolution

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/GRASPWithPathRelinking.cs

@@ -61 +61 @@
       get { return (IValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
     }
+    public IValueParameter<IntValue> MaximumIterationsParameter {
+      get { return (IValueParameter<IntValue>)Parameters["MaximumIterations"]; }
+    }
     private IFixedValueParameter<IntValue> EliteSetSizeParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters["EliteSetSize"]; }
@@ -76 +79 @@
       get { return (ConstrainedValueParameter<ICrossover>)Parameters["PathRelinking"]; }
     }
-    public ConstrainedValueParameter<IMerger> EliteSetReplacerParameter {
+    public ConstrainedValueParameter<IMerger> EliteSetMergerParameter {
       get { return (ConstrainedValueParameter<IMerger>)Parameters["EliteSetMerger"]; }
     }
@@ -106 +109 @@
       get { return (RandomCreator)OperatorGraph.InitialOperator; }
     }
-    #endregion
+    private GRASPWithPathRelinkingMainLoop MainLoop {
+      get { return RandomCreator.Successor as GRASPWithPathRelinkingMainLoop; }
+    }
+    #endregion
+
+    [Storable]
+    private BestAverageWorstQualityAnalyzer analyzer;
 
     [StorableConstructor]
@@ -112 +121 @@
     private GRASPWithPathRelinking(GRASPWithPathRelinking original, Cloner cloner)
       : base(original, cloner) {
+      analyzer = cloner.Clone(original.analyzer);
       RegisterEventHandlers();
     }
@@ -119 +129 @@
       Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator."));
       Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each iteration.", new MultiAnalyzer()));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of iterations that the algorithm should run.", new IntValue(1000)));
       Parameters.Add(new FixedValueParameter<IntValue>("EliteSetSize", "The elite set stores the best found solutions.", new IntValue(10)));
-      Parameters.Add(new FixedValueParameter<IntValue>("LocalImprovementMaximumIterations", "The maximum number of iterations performed by the local improvement operator.", new IntValue(100)));
+      Parameters.Add(new FixedValueParameter<IntValue>("LocalImprovementMaximumIterations", "The maximum number of iterations performed by the local improvement operator.", new IntValue(1000)));
       Parameters.Add(new ConstrainedValueParameter<ILocalImprovementOperator>("LocalImprovement", "Performs a local search on the solution."));
-      Parameters.Add(new FixedValueParameter<IntValue>("MinimumEliteSetSize", "(ρ) The minimum amount of elites for performing path relinking.", new IntValue(1)));
+      Parameters.Add(new FixedValueParameter<IntValue>("MinimumEliteSetSize", "(ρ) The minimum amount of elites for performing path relinking.", new IntValue(2)));
       Parameters.Add(new ConstrainedValueParameter<ICrossover>("PathRelinking", "The operator that performs the path relinking."));
       Parameters.Add(new ConstrainedValueParameter<IMerger>("EliteSetMerger", "The operator that merges new solutions into the elite set."));
+
+      analyzer = new BestAverageWorstQualityAnalyzer();
+      Analyzer.Operators.Add(analyzer);
 
       RandomCreator randomCreator = new RandomCreator();
@@ -136 +150 @@
 
       var mainLoop = new GRASPWithPathRelinkingMainLoop();
+      mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
+      mainLoop.EliteSetMergerParameter.ActualName = EliteSetMergerParameter.Name;
+      mainLoop.EliteSetSizeParameter.ActualName = EliteSetSizeParameter.Name;
+      mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
+      mainLoop.LocalImprovementParameter.ActualName = LocalImprovementParameter.Name;
+      mainLoop.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
+      mainLoop.PathRelinkingParameter.ActualName = PathRelinkingParameter.Name;
+      mainLoop.ResultsParameter.ActualName = "Results";
       randomCreator.Successor = mainLoop;
 
@@ -185 +207 @@
       Analyzer.Operators.Clear();
       if (Problem != null) {
-        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>()) {
-          foreach (var param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
+        foreach (IAnalyzer a in Problem.Operators.OfType<IAnalyzer>()) {
+          foreach (var param in a.Parameters.OfType<IScopeTreeLookupParameter>())
             param.Depth = 1;
-          Analyzer.Operators.Add(analyzer);
+          Analyzer.Operators.Add(a);
         }
         InitializeFromInstallation(LocalImprovementParameter, x => x.ProblemType.IsAssignableFrom(Problem.GetType()));
         InitializeFromProblem(PathRelinkingParameter);
-        InitializeFromProblem(EliteSetReplacerParameter);
+        InitializeFromProblem(EliteSetMergerParameter);
       } else {
         LocalImprovementParameter.ValidValues.Clear();
         PathRelinkingParameter.ValidValues.Clear();
-        EliteSetReplacerParameter.ValidValues.Clear();
-      }
+        EliteSetMergerParameter.ValidValues.Clear();
+      }
+      Analyzer.Operators.Add(analyzer);
 
       Parameterize();
@@ -203 +226 @@
 
     private void Parameterize() {
+      if (Problem != null) {
+        MainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+        MainLoop.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
+
+        analyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+      }
       foreach (var localImprovement in LocalImprovementParameter.ValidValues) {
         localImprovement.MaximumIterationsParameter.ActualName = LocalImprovementMaximumIterationsParameter.Name;
@@ -210 +239 @@
           localImprovement.Problem = Problem;
       }
+      foreach (var merger in EliteSetMergerParameter.ValidValues) {
+        merger.PopulationSizeParameter.ActualName = EliteSetSizeParameter.Name;
+      }
     }
 
     private void InitializeFromProblem<T>(ConstrainedValueParameter<T> parameter) where T : class, INamedItem {
-      InitializeFromProblem(parameter, x => true);
+      InitializeFromProblem<T>(parameter, x => true);
     }
     private void InitializeFromProblem<T>(ConstrainedValueParameter<T> parameter, Func<T, bool> condition) where T : class, INamedItem {
@@ -228 +260 @@
     }
     private void InitializeFromInstallation<T>(ConstrainedValueParameter<T> parameter) where T : class, INamedItem {
-      InitializeFromInstallation(parameter, x => true);
+      InitializeFromInstallation<T>(parameter, x => true);
     }
     private void InitializeFromInstallation<T>(ConstrainedValueParameter<T> parameter, Func<T, bool> condition) where T : class, INamedItem {

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Algorithms/3.3/GRASPWithPathRelinkingMainLoop.cs

@@ -89 +89 @@
       variableCreator1.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
 
+      var resultsCollector = new ResultsCollector();
+      resultsCollector.CopyValue = new BoolValue(false);
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Iterations"));
+
       var variableCreator2 = new VariableCreator();
       variableCreator2.Name = "ActualEliteSetSize = 0";
@@ -157 +161 @@
       placeholder2.OperatorParameter.ActualName = PathRelinkingParameter.Name;
 
+      var placeholder3 = new Placeholder();
+      placeholder3.Name = "(Evaluator)";
+      placeholder3.OperatorParameter.ActualName = EvaluatorParameter.Name;
+
       var subScopesRemover = new SubScopesRemover();
       subScopesRemover.RemoveAllSubScopes = true;
@@ -162 +170 @@
       var ssp4 = new SubScopesProcessor();
 
-      var placeholder3 = new Placeholder();
-      placeholder3.Name = "(LocalImprovement)";
-      placeholder3.OperatorParameter.ActualName = LocalImprovementParameter.Name;
-
       var placeholder4 = new Placeholder();
-      placeholder4.Name = "(EliteSetMerger)";
-      placeholder4.OperatorParameter.ActualName = EliteSetMergerParameter.Name;
+      placeholder4.Name = "(LocalImprovement)";
+      placeholder4.OperatorParameter.ActualName = LocalImprovementParameter.Name;
+
+      var placeholder5 = new Placeholder();
+      placeholder5.Name = "(EliteSetMerger)";
+      placeholder5.OperatorParameter.ActualName = EliteSetMergerParameter.Name;
 
       var counter = new IntCounter();
@@ -191 +199 @@
 
       OperatorGraph.InitialOperator = variableCreator1;
-      variableCreator1.Successor = variableCreator2;
+      variableCreator1.Successor = resultsCollector;
+      resultsCollector.Successor = variableCreator2;
       variableCreator2.Successor = subScopesCounter1;
       subScopesCounter1.Successor = comparator1;
@@ -200 +209 @@
       ssp1.Operators.Add(eo1);
       ssp1.Operators.Add(solutionsCreator);
-      ssp1.Successor = placeholder4;
+      ssp1.Successor = placeholder5;
       eo1.Successor = null;
       solutionsCreator.Successor = subScopesCounter2;
@@ -216 +225 @@
       ssp3.Operators.Add(placeholder2);
       ssp3.Successor = null;
-      placeholder2.Successor = subScopesRemover;
+      placeholder2.Successor = placeholder3;
+      placeholder3.Successor = subScopesRemover;
       subScopesRemover.Successor = null;
-      ssp4.Operators.Add(placeholder3);
+      ssp4.Operators.Add(placeholder4);
       ssp4.Successor = null;
-      placeholder4.Successor = counter;
+      placeholder5.Successor = counter;
       counter.Successor = analyzer1;
       analyzer1.Successor = comparator3;

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common-3.3.csproj

@@ -90 +90 @@
     <Compile Include="ExtensionMethods.cs" />
     <Compile Include="IMerger.cs" />
+    <Compile Include="IntegerVectorEqualityComparer.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common/3.3/IMerger.cs

@@ -21 +21 @@
 
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common {
   public interface IMerger : IOperator {
+    ILookupParameter<IntValue> PopulationSizeParameter { get; }
   }
 }

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3

@@ -2 +2 @@
 bin
 obj
+*.user

@@ -2 +2 @@
 bin
 obj
+*.user

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/GQAPAssignmentView.Designer.cs

@@ -56 +56 @@
                   | System.Windows.Forms.AnchorStyles.Left)
                   | System.Windows.Forms.AnchorStyles.Right)));
-      this.assignmentTreeView.Location = new System.Drawing.Point(3, 52);
+      this.assignmentTreeView.Location = new System.Drawing.Point(3, 50);
+      this.assignmentTreeView.Margin = new System.Windows.Forms.Padding(3, 6, 3, 3);
       this.assignmentTreeView.Name = "assignmentTreeView";
-      this.assignmentTreeView.Size = new System.Drawing.Size(349, 329);
-      this.assignmentTreeView.TabIndex = 0;
+      this.assignmentTreeView.Size = new System.Drawing.Size(349, 331);
+      this.assignmentTreeView.TabIndex = 3;
       // 
       // label1
@@ -67 +68 @@
       this.label1.Name = "label1";
       this.label1.Size = new System.Drawing.Size(42, 13);
-      this.label1.TabIndex = 1;
+      this.label1.TabIndex = 0;
       this.label1.Text = "Quality:";
       // 
@@ -77 +78 @@
       this.qualityTextBox.Name = "qualityTextBox";
       this.qualityTextBox.Size = new System.Drawing.Size(301, 20);
-      this.qualityTextBox.TabIndex = 2;
+      this.qualityTextBox.TabIndex = 1;
       // 
       // label2
       // 
       this.label2.AutoSize = true;
-      this.label2.Location = new System.Drawing.Point(3, 36);
+      this.label2.Location = new System.Drawing.Point(3, 31);
       this.label2.Name = "label2";
       this.label2.Size = new System.Drawing.Size(64, 13);
-      this.label2.TabIndex = 1;
+      this.label2.TabIndex = 2;
       this.label2.Text = "Assignment:";
       // 

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/GQAPAssignmentView.cs

@@ -66 +66 @@
     protected override void SetEnabledStateOfControls() {
       base.SetEnabledStateOfControls();
-      qualityTextBox.Enabled = !ReadOnly && !Locked && Content != null;
-      assignmentTreeView.Enabled = !ReadOnly && !Locked && Content != null;
+      qualityTextBox.Enabled = false;
+      assignmentTreeView.Enabled = true;
     }
 

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views-3.3.csproj

@@ -38 +38 @@
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
-    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common.Resources-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common.Resources-3-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.Core-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
@@ -49 +53 @@
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
     </Reference>
-    <Reference Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.IntegerVectorEncoding-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.MainForm-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.MainForm-3.3.dll</HintPath>
@@ -56 +62 @@
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.MainForm.WindowsForms-3.3.dll</HintPath>
     </Reference>
-    <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
-    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
-    <Reference Include="HeuristicLab.Parameters-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
-    <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Analyzers/BestGQAPSolutionAnalyzer.cs

@@ -98 +98 @@
 
     [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserializationHook() {
+    private void AfterDeserialization() {
       // BackwardsCompatibility3.3
       #region Backwards compatible code, remove with 3.4

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Evaluators/GQAPEvaluator.cs

@@ -38 +38 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
-    public ILookupParameter<DoubleValue> InfeasibilityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["Infeasibility"]; }
+    public ILookupParameter<DoubleValue> FlowDistanceQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["FlowDistanceQuality"]; }
     }
-    public IValueLookupParameter<DoubleValue> PenaltyParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters["Penalty"]; }
+    public ILookupParameter<DoubleValue> InstallationQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["InstallationQuality"]; }
+    }
+    public ILookupParameter<DoubleValue> OverbookedCapacityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["OverbookedCapacity"]; }
+    }
+    public IValueLookupParameter<DoubleValue> TransportationCostsParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["TransportationCosts"]; }
+    }
+    public IValueLookupParameter<DoubleValue> OverbookedCapacityPenaltyParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["OverbookedCapacityPenalty"]; }
     }
     public ILookupParameter<DoubleMatrix> WeightsParameter {
@@ -52 +61 @@
     public ILookupParameter<DoubleMatrix> InstallationCostsParameter {
       get { return (ILookupParameter<DoubleMatrix>)Parameters["InstallationCosts"]; }
-    }
-    public ILookupParameter<DoubleValue> TransportationCostsParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["TransportationCosts"]; }
     }
     public ILookupParameter<DoubleArray> DemandsParameter {
@@ -71 +77 @@
     public GQAPEvaluator()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality a.k.a. fitness of the solution."));
-      Parameters.Add(new LookupParameter<DoubleValue>("Infeasibility", "The infeasibility describes the sum of the overbooked capacities."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("Penalty", "The multiplier for the constraint violation when added to the quality.", new DoubleValue(1000)));
+      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<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<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."));
@@ -87 +95 @@
     }
 
-    public static DoubleValue Evaluate(IntegerVector assignment, DoubleMatrix weights, DoubleMatrix distances,
-      DoubleMatrix installCosts, double transportCosts, DoubleArray demands, DoubleArray capacities,
-      out double infeasibility) {
-      double quality = 0;
+    public static double Evaluate(IntegerVector assignment, DoubleMatrix weights, DoubleMatrix distances,
+                                  DoubleMatrix installCosts, DoubleArray demands, DoubleArray capacities,
+                                  DoubleValue transportationCosts, DoubleValue overbookedCapacityPenalty) {
+      double flowDistanceQuality, installationQuality, overbookedCapacity;
+      Evaluate(assignment, weights, distances, installCosts, demands, capacities,
+        out flowDistanceQuality, out installationQuality, out overbookedCapacity);
+      return GetCombinedQuality(flowDistanceQuality, installationQuality, overbookedCapacity,
+        transportationCosts.Value, overbookedCapacityPenalty.Value);
+    }
+
+    public static void Evaluate(IntegerVector assignment, DoubleMatrix weights, DoubleMatrix distances,
+                                DoubleMatrix installCosts, DoubleArray demands, DoubleArray capacities,
+                                out double flowDistanceQuality, out double installationQuality, out double overbookedCapacity) {
+      flowDistanceQuality = 0;
+      installationQuality = 0;
       int len = assignment.Length;
       var slack = (DoubleArray)capacities.Clone();
       for (int i = 0; i < len; i++) {
-        quality += installCosts[i, assignment[i]];
+        installationQuality += installCosts[i, assignment[i]];
         for (int j = 0; j < len; j++) {
-          quality += transportCosts * weights[i, j] * distances[assignment[i], assignment[j]];
+          flowDistanceQuality += weights[i, j] * distances[assignment[i], assignment[j]];
         }
         slack[assignment[i]] -= demands[i];
       }
+      overbookedCapacity = slack.Select((v, i) => new { V = v, Index = i }).Where(x => x.V < 0.0).Select(x => -x.V / capacities[x.Index]).Sum();
+    }
 
-      infeasibility = -slack.Where(x => x < 0).Sum();
-      return new DoubleValue(quality);
+    public static double GetCombinedQuality(double flowDistanceQuality, double installationQuality, double overbookedCapacity,
+      double transportationCosts, double overbookedCapacityPenalty) {
+      return installationQuality
+        + transportationCosts * flowDistanceQuality
+        + overbookedCapacityPenalty * overbookedCapacity;
     }
 
     public override IOperation Apply() {
-      IntegerVector assignment = AssignmentParameter.ActualValue;
-      DoubleMatrix weights = WeightsParameter.ActualValue;
-      DoubleMatrix distances = DistancesParameter.ActualValue;
-      DoubleMatrix installCosts = InstallationCostsParameter.ActualValue;
-      double transportCosts = TransportationCostsParameter.ActualValue.Value;
-      DoubleArray demands = DemandsParameter.ActualValue;
-      DoubleArray capacities = (DoubleArray)CapacitiesParameter.ActualValue.Clone();
-      double penalty = PenaltyParameter.ActualValue.Value;
+      var assignment = AssignmentParameter.ActualValue;
+      var weights = WeightsParameter.ActualValue;
+      var distances = DistancesParameter.ActualValue;
+      var installCosts = InstallationCostsParameter.ActualValue;
+      var demands = DemandsParameter.ActualValue;
+      var capacities = CapacitiesParameter.ActualValue;
+      var transportCosts = TransportationCostsParameter.ActualValue.Value;
+      double penalty = OverbookedCapacityPenaltyParameter.ActualValue.Value;
 
       if (weights.Rows != weights.Columns || distances.Rows != distances.Columns
@@ -120 +144 @@
         throw new InvalidOperationException("ERROR: The problem configuration is not valid! Check the sizes of the weights (NxN), distances (MxM) and installation costs (NxM) matrices as well as the length of the demand (N) and capacities (M) vectors.");
 
-      double infeasibility;
-      var quality = Evaluate(assignment, weights, distances, installCosts, transportCosts, demands, capacities, out infeasibility);
+      double flowDistanceQuality, installationQuality, overbookedCapacity;
+      Evaluate(assignment, weights, distances, installCosts, demands, capacities,
+        out flowDistanceQuality, out installationQuality, out overbookedCapacity);
 
-      InfeasibilityParameter.ActualValue = new DoubleValue(infeasibility);
-      QualityParameter.ActualValue = new DoubleValue(quality.Value + penalty * infeasibility);
+      FlowDistanceQualityParameter.ActualValue = new DoubleValue(flowDistanceQuality);
+      InstallationQualityParameter.ActualValue = new DoubleValue(installationQuality);
+      OverbookedCapacityParameter.ActualValue = new DoubleValue(overbookedCapacity);
+
+      QualityParameter.ActualValue = new DoubleValue(GetCombinedQuality(flowDistanceQuality, installationQuality, overbookedCapacity, transportCosts, penalty));
       return base.Apply();
     }

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Evaluators/GQAPNMoveEvaluator.cs

@@ -44 +44 @@
       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<DoubleValue> MoveQualityParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
     }
-    public ILookupParameter<DoubleValue> MoveInfeasibilityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["MoveInfeasibility"]; }
+    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"]; }
+    }
+    public IValueLookupParameter<DoubleValue> OverbookedCapacityPenaltyParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["OverbookedCapacityPenalty"]; }
     }
     public ILookupParameter<DoubleMatrix> WeightsParameter {
@@ -58 +79 @@
     public ILookupParameter<DoubleMatrix> InstallationCostsParameter {
       get { return (ILookupParameter<DoubleMatrix>)Parameters["InstallationCosts"]; }
-    }
-    public ILookupParameter<DoubleValue> TransportationCostsParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["TransportationCosts"]; }
     }
     public ILookupParameter<DoubleArray> DemandsParameter {
@@ -77 +95 @@
       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>("MoveInfeasibility", "The infeasibility 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<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<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."));
@@ -91 +115 @@
     }
 
-    public static DoubleValue Evaluate(NMove move, IntegerVector assignment, DoubleValue quality,
-                                  DoubleArray demands, DoubleArray capacities,
-                                  DoubleMatrix weights, DoubleMatrix distances,
-                                  DoubleMatrix installationCosts,
-                                  DoubleValue transportationCosts,
-                                  out DoubleValue moveInfeasibility) {
-      double moveQuality = quality.Value;
+    public static double Evaluate(NMove move, IntegerVector assignment, DoubleMatrix weights, DoubleMatrix distances, DoubleMatrix installationCosts,
+      DoubleArray demands, DoubleArray capacities, DoubleValue transportationCosts, DoubleValue overbookedCapacityPenalty) {
+      double moveFlowDistanceQuality, moveInstallationQuality, moveOverbookedCapacity;
+      Evaluate(move, assignment, weights, distances, installationCosts, demands, capacities,
+        out moveFlowDistanceQuality, out moveInstallationQuality, out moveOverbookedCapacity);
+      return GQAPEvaluator.GetCombinedQuality(moveFlowDistanceQuality, moveInstallationQuality, moveOverbookedCapacity,
+        transportationCosts.Value, overbookedCapacityPenalty.Value);
+    }
+
+    public static void Evaluate(NMove move, IntegerVector assignment, DoubleMatrix weights, DoubleMatrix distances, DoubleMatrix installationCosts,
+      DoubleArray demands, DoubleArray capacities, out double moveFlowDistanceQuality, out double moveInstallationQuality, out double moveOverbookedCapacity) {
+      moveFlowDistanceQuality = moveInstallationQuality = moveOverbookedCapacity = 0.0;
       int moves = move.N;
       var slack = (DoubleArray)capacities.Clone();
+      var oldSlack = (DoubleArray)slack.Clone();
       Dictionary<int, int> moving = new Dictionary<int, int>();
       for (int i = 0; i < moves; i++) moving.Add(move.Equipments[i], move.Locations[i]);
@@ -106 +136 @@
         int equip = move.Equipments[i];
         int newLoc = move.Locations[i];
-        moveQuality -= installationCosts[equip, assignment[equip]];
-        moveQuality += installationCosts[equip, newLoc];
+        moveInstallationQuality -= installationCosts[equip, assignment[equip]];
+        moveInstallationQuality += installationCosts[equip, newLoc];
         for (int j = 0; j < assignment.Length; j++) {
           if (!moving.ContainsKey(j)) {
-            moveQuality += transportationCosts.Value * weights[equip, j] * (distances[newLoc, assignment[j]] - distances[assignment[equip], assignment[j]]);
-            moveQuality += transportationCosts.Value * weights[j, equip] * (distances[assignment[j], newLoc] - distances[assignment[j], assignment[equip]]);
+            moveFlowDistanceQuality += weights[equip, j] * distances[newLoc, assignment[j]];
+            moveFlowDistanceQuality -= weights[equip, j] * distances[assignment[equip], assignment[j]];
+            moveFlowDistanceQuality += weights[j, equip] * distances[assignment[j], newLoc];
+            moveFlowDistanceQuality -= weights[j, equip] * distances[assignment[j], assignment[equip]];
             if (i == 0) { // only once for each untouched equipment deduct the demand from the capacity
               slack[assignment[j]] -= demands[j];
+              oldSlack[assignment[j]] -= demands[j];
             }
           } else {
-            moveQuality += transportationCosts.Value * weights[equip, j] * (distances[newLoc, moving[j]] - distances[assignment[equip], assignment[j]]);
-            moveQuality += transportationCosts.Value * weights[j, equip] * (distances[moving[j], newLoc] - distances[assignment[j], assignment[equip]]);
+            moveFlowDistanceQuality += weights[equip, j] * distances[newLoc, moving[j]];
+            moveFlowDistanceQuality -= weights[equip, j] * distances[assignment[equip], assignment[j]];
           }
         }
         slack[newLoc] -= demands[equip];
+        oldSlack[assignment[equip]] -= demands[equip];
       }
 
-      moveInfeasibility = new DoubleValue(-slack.Where(x => x < 0).Sum());
-      return new DoubleValue(moveQuality);
-
+      moveOverbookedCapacity = slack.Select((v, i) => new { V = v, Index = i }).Where(x => x.V < 0.0).Select(x => -x.V / capacities[x.Index]).Sum()
+                               - oldSlack.Select((v, i) => new { V = v, Index = i }).Where(x => x.V < 0.0).Select(x => -x.V / capacities[x.Index]).Sum();
     }
 
     public override IOperation Apply() {
-      DoubleValue moveInfeasibility;
-      MoveQualityParameter.ActualValue = Evaluate(MoveParameter.ActualValue,
-                 AssignmentParameter.ActualValue, QualityParameter.ActualValue,
-                 DemandsParameter.ActualValue, CapacitiesParameter.ActualValue,
-                 WeightsParameter.ActualValue, DistancesParameter.ActualValue,
-                 InstallationCostsParameter.ActualValue,
-                 TransportationCostsParameter.ActualValue, out moveInfeasibility);
-      MoveInfeasibilityParameter.ActualValue = moveInfeasibility;
+      double moveFlowDistanceQuality, moveInstallationQuality, moveOverbookedCapacity;
+      double quality = QualityParameter.ActualValue.Value;
+      double transportationCosts = TransportationCostsParameter.ActualValue.Value;
+      double overbookedCapacityPenalty = OverbookedCapacityPenaltyParameter.ActualValue.Value;
+
+      double flowDistanceQuality = FlowDistanceQualityParameter.ActualValue.Value;
+      double installationQuality = InstallationQualityParameter.ActualValue.Value;
+      double overbookedCapacity = OverbookedCapacityParameter.ActualValue.Value;
+
+      Evaluate(MoveParameter.ActualValue,
+               AssignmentParameter.ActualValue,
+               WeightsParameter.ActualValue, DistancesParameter.ActualValue,
+               InstallationCostsParameter.ActualValue,
+               DemandsParameter.ActualValue, CapacitiesParameter.ActualValue,
+               out moveFlowDistanceQuality, out moveInstallationQuality, out moveOverbookedCapacity);
+
+      MoveFlowDistanceQualityParameter.ActualValue = new DoubleValue(flowDistanceQuality + moveFlowDistanceQuality);
+      MoveInstallationQualityParameter.ActualValue = new DoubleValue(installationQuality + moveInstallationQuality);
+      MoveOverbookedCapacityParameter.ActualValue = new DoubleValue(moveOverbookedCapacity);
+
+      MoveQualityParameter.ActualValue = new DoubleValue(GQAPEvaluator.GetCombinedQuality(
+        flowDistanceQuality + moveFlowDistanceQuality,
+        installationQuality + moveInstallationQuality,
+        moveOverbookedCapacity,
+        transportationCosts,
+        overbookedCapacityPenalty));
       return base.Apply();
     }

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/GeneralizedQuadraticAssignmentProblem.cs

@@ -53 +53 @@
       get { return (ValueParameter<DoubleMatrix>)Parameters["InstallationCosts"]; }
     }
+    public ValueParameter<DoubleArray> DemandsParameter {
+      get { return (ValueParameter<DoubleArray>)Parameters["Demands"]; }
+    }
+    public ValueParameter<DoubleArray> CapacitiesParameter {
+      get { return (ValueParameter<DoubleArray>)Parameters["Capacities"]; }
+    }
     public FixedValueParameter<DoubleValue> TransportationCostsParameter {
       get { return (FixedValueParameter<DoubleValue>)Parameters["TransportationCosts"]; }
     }
-    public ValueParameter<DoubleArray> DemandsParameter {
-      get { return (ValueParameter<DoubleArray>)Parameters["Demands"]; }
-    }
-    public ValueParameter<DoubleArray> CapacitiesParameter {
-      get { return (ValueParameter<DoubleArray>)Parameters["Capacities"]; }
+    public FixedValueParameter<DoubleValue> OverbookedCapacityPenaltyParameter {
+      get { return (FixedValueParameter<DoubleValue>)Parameters["OverbookedCapacityPenalty"]; }
     }
     public OptionalValueParameter<IItem> BestKnownSolutionParameter {
@@ -80 +83 @@
       set { InstallationCostsParameter.Value = value; }
     }
+    public DoubleArray Demands {
+      get { return DemandsParameter.Value; }
+      set { DemandsParameter.Value = value; }
+    }
+    public DoubleArray Capacities {
+      get { return CapacitiesParameter.Value; }
+      set { CapacitiesParameter.Value = value; }
+    }
     public double TransportationCosts {
       get { return TransportationCostsParameter.Value.Value; }
       set { TransportationCostsParameter.Value.Value = value; }
     }
-    public DoubleArray Demands {
-      get { return DemandsParameter.Value; }
-      set { DemandsParameter.Value = value; }
-    }
-    public DoubleArray Capacities {
-      get { return CapacitiesParameter.Value; }
-      set { CapacitiesParameter.Value = value; }
+    public double OverbookedCapacityPenalty {
+      get { return TransportationCostsParameter.Value.Value; }
+      set { TransportationCostsParameter.Value.Value = value; }
     }
     #endregion
@@ -114 +121 @@
       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()));
@@ -183 +191 @@
     #region Helpers
     [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserializationHook() {
+    private void AfterDeserialization() {
       AttachEventHandlers();
     }
@@ -220 +228 @@
       }
       foreach (var op in Operators.OfType<IGQAPEvaluationOperator>()) {
+        op.AssignmentParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
+        op.TransportationCostsParameter.ActualName = TransportationCostsParameter.Name;
+        op.OverbookedCapacityPenaltyParameter.ActualName = OverbookedCapacityPenaltyParameter.Name;
         op.WeightsParameter.ActualName = WeightsParameter.Name;
         op.DistancesParameter.ActualName = DistancesParameter.Name;
         op.InstallationCostsParameter.ActualName = InstallationCostsParameter.Name;
-        op.TransportationCostsParameter.ActualName = TransportationCostsParameter.Name;
         op.DemandsParameter.ActualName = DemandsParameter.Name;
         op.CapacitiesParameter.ActualName = CapacitiesParameter.Name;
-        op.AssignmentParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
       }
       foreach (var op in Operators.OfType<IGQAPLocalImprovementOperator>()) {
+        op.AssignmentParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
+        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.TransportationCostsParameter.ActualName = TransportationCostsParameter.Name;
+        op.OverbookedCapacityPenaltyParameter.ActualName = OverbookedCapacityPenaltyParameter.Name;
         op.WeightsParameter.ActualName = WeightsParameter.Name;
         op.DistancesParameter.ActualName = DistancesParameter.Name;
         op.InstallationCostsParameter.ActualName = InstallationCostsParameter.Name;
-        op.TransportationCostsParameter.ActualName = TransportationCostsParameter.Name;
         op.DemandsParameter.ActualName = DemandsParameter.Name;
         op.CapacitiesParameter.ActualName = CapacitiesParameter.Name;
-        op.AssignmentParameter.ActualName = SolutionCreator.AssignmentParameter.ActualName;
-        op.InfeasibilityParameter.ActualName = Evaluator.InfeasibilityParameter.ActualName;
       }
       foreach (var op in Operators.OfType<IGQAPManipulator>()) {
         op.IntegerVectorParameter.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>()) {

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment-3.3.csproj

@@ -94 +94 @@
     <Compile Include="Evaluators\GQAPEvaluator.cs" />
     <Compile Include="GeneralizedQuadraticAssignmentProblem.cs" />
+    <Compile Include="GQAPIntegerVectorProximityCalculator.cs" />
+    <Compile Include="Interfaces\IGQAPMerger.cs" />
     <Compile Include="Interfaces\IGQAPNMoveEvaluator.cs" />
     <Compile Include="Interfaces\IEquipmentAwareGQAPOperator.cs" />
@@ -120 +122 @@
     <Compile Include="Operators\GQAPSolutionCreator.cs" />
     <Compile Include="Operators\GreedyRandomizedSolutionCreator.cs" />
+    <Compile Include="Operators\QualitySimilarityMerger.cs" />
     <Compile Include="Operators\RandomSolutionCreator.cs" />
     <Compile Include="Operators\RelocateEquipmentManipluator.cs" />

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPEvaluationOperator.cs

@@ -29 +29 @@
     ILookupParameter<DoubleMatrix> DistancesParameter { get; }
     ILookupParameter<DoubleMatrix> InstallationCostsParameter { get; }
-    ILookupParameter<DoubleValue> TransportationCostsParameter { get; }
     ILookupParameter<DoubleArray> DemandsParameter { get; }
     ILookupParameter<DoubleArray> CapacitiesParameter { get; }
     ILookupParameter<IntegerVector> AssignmentParameter { get; }
+
+    IValueLookupParameter<DoubleValue> TransportationCostsParameter { get; }
+    IValueLookupParameter<DoubleValue> OverbookedCapacityPenaltyParameter { get; }
   }
 }

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPEvaluator.cs

@@ -26 +26 @@
 namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
   public interface IGQAPEvaluator : IGQAPEvaluationOperator, ISingleObjectiveEvaluator {
-    ILookupParameter<DoubleValue> InfeasibilityParameter { get; }
+    ILookupParameter<DoubleValue> FlowDistanceQualityParameter { get; }
+    ILookupParameter<DoubleValue> InstallationQualityParameter { get; }
+    ILookupParameter<DoubleValue> OverbookedCapacityParameter { get; }
   }
 }

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPLocalImprovementOperator.cs

@@ -28 +28 @@
   public interface IGQAPLocalImprovementOperator : IGQAPOperator, ILocalImprovementOperator {
     ILookupParameter<DoubleValue> QualityParameter { get; }
-    ILookupParameter<DoubleValue> InfeasibilityParameter { get; }
-    ILookupParameter<ResultCollection> ResultsParameter { get; }
+    ILookupParameter<DoubleValue> FlowDistanceQualityParameter { get; }
+    ILookupParameter<DoubleValue> InstallationQualityParameter { get; }
+    ILookupParameter<DoubleValue> OverbookedCapacityParameter { get; }
     IValueLookupParameter<IntValue> MaximumCandidateListSizeParameter { get; }
     IValueLookupParameter<IntValue> MaximumSampleSizeParameter { get; }
@@ -36 +37 @@
     ILookupParameter<DoubleMatrix> DistancesParameter { get; }
     ILookupParameter<DoubleMatrix> InstallationCostsParameter { get; }
-    ILookupParameter<DoubleValue> TransportationCostsParameter { get; }
     ILookupParameter<DoubleArray> DemandsParameter { get; }
     ILookupParameter<DoubleArray> CapacitiesParameter { get; }
+    IValueLookupParameter<DoubleValue> TransportationCostsParameter { get; }
+    IValueLookupParameter<DoubleValue> OverbookedCapacityPenaltyParameter { get; }
   }
 }

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Interfaces/IGQAPMoveEvaluator.cs

@@ -20 +20 @@
 #endregion
 
+using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
-  public interface IGQAPMoveEvaluator : IGQAPEvaluationOperator, ISingleObjectiveMoveEvaluator { }
+  public interface IGQAPMoveEvaluator : IGQAPEvaluationOperator, ISingleObjectiveMoveEvaluator {
+    ILookupParameter<DoubleValue> FlowDistanceQualityParameter { get; }
+    ILookupParameter<DoubleValue> InstallationQualityParameter { get; }
+    ILookupParameter<DoubleValue> OverbookedCapacityParameter { get; }
+  }
 }

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/NMoveMaker.cs

@@ -42 +42 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
-    public ILookupParameter<DoubleValue> InfeasibilityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["Infeasibility"]; }
+    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<DoubleValue> MoveQualityParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
     }
-    public ILookupParameter<DoubleValue> MoveInfeasibilityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["MoveInfeasibility"]; }
+    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"]; }
     }
 
@@ -60 +72 @@
       Parameters.Add(new LookupParameter<NMove>("Move", "The move to perform."));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The solution quality."));
-      Parameters.Add(new LookupParameter<DoubleValue>("Infeasibility", "The infeasibility of a 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 LookupParameter<DoubleValue>("MoveQuality", "The quality of the move if it would be applied."));
-      Parameters.Add(new LookupParameter<DoubleValue>("MoveInfeasibility", "The infeasibility 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."));
     }
 
@@ -78 +94 @@
       Apply(AssignmentParameter.ActualValue, MoveParameter.ActualValue);
       QualityParameter.ActualValue.Value = MoveQualityParameter.ActualValue.Value;
-      InfeasibilityParameter.ActualValue.Value = MoveInfeasibilityParameter.ActualValue.Value;
+      FlowDistanceQualityParameter.ActualValue.Value = MoveFlowDistanceQualityParameter.ActualValue.Value;
+      InstallationQualityParameter.ActualValue.Value = MoveInstallationQualityParameter.ActualValue.Value;
+      OverbookedCapacityParameter.ActualValue.Value = MoveOverbookedCapacityParameter.ActualValue.Value;
       return base.Apply();
     }

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/StochasticNMoveMultiMoveGenerator.cs

@@ -60 +60 @@
     public static IEnumerable<NMove> Generate(IRandom random, IntegerVector assignment, int n, DoubleArray capacities, int sampleSize) {
       for (int i = 0; i < sampleSize; i++)
-        yield return StochasticNMoveSingleMoveGenerator.Generate(random, assignment, n, capacities);
+        yield return StochasticNMoveSingleMoveGenerator.GenerateUpToN(random, assignment, n, capacities);
     }
 

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Moves/StochasticNMoveSingleMoveGenerator.cs

@@ -54 +54 @@
     }
 
-    public static NMove Generate(IRandom random, IntegerVector assignment, int n, DoubleArray capacities) {
-      int moving = random.Next(n) + 1;
-      int[] equipments = new int[moving], locations = new int[moving];
+    public static NMove GenerateUpToN(IRandom random, IntegerVector assignment, int n, DoubleArray capacities) {
+      return GenerateExactlyN(random, assignment, random.Next(n) + 1, capacities);
+    }
+
+    public static NMove GenerateExactlyN(IRandom random, IntegerVector assignment, int n, DoubleArray capacities) {
+      int[] equipments = new int[n], locations = new int[n];
       HashSet<int> chosenEquipments = new HashSet<int>();
-      for (int i = 0; i < moving; i++) {
+      for (int i = 0; i < n; i++) {
         do {
           equipments[i] = random.Next(assignment.Length);
@@ -71 +74 @@
 
     public override IEnumerable<NMove> GenerateMoves(IntegerVector assignment, int n) {
-      yield return Generate(RandomParameter.ActualValue, assignment, n, CapacitiesParameter.ActualValue);
+      yield return GenerateUpToN(RandomParameter.ActualValue, assignment, n, CapacitiesParameter.ActualValue);
     }
   }

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/ApproximateLocalSearch.cs

@@ -55 +55 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
-    public ILookupParameter<DoubleValue> InfeasibilityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["Infeasibility"]; }
+    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<ResultCollection> ResultsParameter {
@@ -79 +85 @@
       get { return (ILookupParameter<DoubleMatrix>)Parameters["InstallationCosts"]; }
     }
-    public ILookupParameter<DoubleValue> TransportationCostsParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["TransportationCosts"]; }
-    }
     public ILookupParameter<DoubleArray> DemandsParameter {
       get { return (ILookupParameter<DoubleArray>)Parameters["Demands"]; }
@@ -88 +91 @@
       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"]; }
+    }
 
     [StorableConstructor]
@@ -99 +110 @@
       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>("Infeasibility", "The infeasibility describes the sum of the overbooked capacities."));
+      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<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)));
@@ -107 +120 @@
       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<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<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)));
     }
 
@@ -124 +139 @@
     /// <param name="assignment">The equipment-location assignment vector.</param>
     /// <param name="quality">The solution quality.</param>
-    /// <param name="infeasibility">The infeasibility describes the sum of the overbooked capacities.</param>
+    /// <param name="flowDistanceQuality">The quality regarding the flow-distance criteria.</param>
+    /// <param name="installationQuality">The quality regarding the installation costs.</param>
+    /// <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="demands">The demands vector describes the space requirements of the equipments.</param>
-    /// <param name="capacities">The capacities vector describes the available space at the locations.</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>
     /// <param name="installationCosts">The installation costs matrix describes the installation costs of installing equipment i at location j</param>
+    /// <param name="demands">The demands vector describes the space requirements of the equipments.</param>
+    /// <param name="capacities">The capacities vector describes the available space at the locations.</param>
     /// <param name="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.</param>
-    public static void Apply(IRandom random, IntegerVector assignment, DoubleValue quality, DoubleValue infeasibility,
-                             IntValue maxCLS, IntValue maxSampleSize, IntValue maximumIterations,
-                             DoubleArray demands, DoubleArray capacities,
-                             DoubleMatrix weights, DoubleMatrix distances,
-                             DoubleMatrix installationCosts,
-                             DoubleValue transportationCosts) {
+    /// <param name="overbookedCapacityPenalty"></param>
+    /// <param name="oneMoveProbability">The probability for performing a 1-move, which is the opposite of performing a 2-move.</param>
+    public static void Apply(IRandom random, IntegerVector assignment,
+      DoubleValue quality, DoubleValue flowDistanceQuality, DoubleValue installationQuality, DoubleValue overbookedCapacity,
+      IntValue maxCLS, IntValue maxSampleSize, 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++) {
         int count = 0;
-        var CLS = new List<Tuple<NMove, DoubleValue, DoubleValue>>();
+        var CLS = new List<Tuple<NMove, double, double, double, double>>();
         double sum = 0.0;
         do {
-          var move = StochasticNMoveSingleMoveGenerator.Generate(random, assignment, 2, capacities);
-          DoubleValue moveInfeasibility;
-          var moveQuality = GQAPNMoveEvaluator.Evaluate(move, assignment, quality,
-            demands, capacities, weights, distances,
-            installationCosts, transportationCosts, out moveInfeasibility);
-          if (moveInfeasibility.Value <= 0.0 && moveQuality.Value < quality.Value) {
-            CLS.Add(Tuple.Create(move, moveQuality, moveInfeasibility));
-            sum += 1.0 / moveQuality.Value;
+          NMove move;
+          if (random.NextDouble() < oneMoveProbability.Value)
+            move = StochasticNMoveSingleMoveGenerator.GenerateExactlyN(random, assignment, 1, capacities);
+          else move = StochasticNMoveSingleMoveGenerator.GenerateExactlyN(random, assignment, 2, capacities);
+
+          double moveFlowDistanceQuality, moveInstallationQuality, moveOverbookedCapacity;
+          GQAPNMoveEvaluator.Evaluate(move, assignment, weights, distances, installationCosts,
+            demands, capacities, out moveFlowDistanceQuality, out moveInstallationQuality, out moveOverbookedCapacity);
+          double moveQuality = GQAPEvaluator.GetCombinedQuality(moveFlowDistanceQuality, moveInstallationQuality, moveOverbookedCapacity,
+            transportationCosts.Value, overbookedCapacityPenalty.Value);
+
+          if (moveOverbookedCapacity <= 0.0 && moveQuality < 0.0) {
+            CLS.Add(Tuple.Create(move, moveQuality, moveFlowDistanceQuality, moveInstallationQuality, moveOverbookedCapacity));
+            sum += 1.0 / moveQuality;
           }
           count++;
         } while (CLS.Count < maxCLS.Value && count < maxSampleSize.Value);
-        if (CLS.Count == 0) return; // END
+
+        if (CLS.Count == 0)
+          return; // END
         else {
           var ball = random.NextDouble() * sum;
           var selected = CLS.Last();
           foreach (var candidate in CLS) {
-            ball -= 1.0 / candidate.Item2.Value;
+            ball -= 1.0 / candidate.Item2;
             if (ball <= 0.0) {
               selected = candidate;
@@ -168 +195 @@
           }
           NMoveMaker.Apply(assignment, selected.Item1);
-          quality.Value = selected.Item2.Value;
-          infeasibility.Value = selected.Item3.Value;
+          quality.Value += selected.Item2;
+          flowDistanceQuality.Value += selected.Item3;
+          installationQuality.Value += selected.Item4;
+          overbookedCapacity.Value += selected.Item5;
         }
       }
@@ -178 +207 @@
         AssignmentParameter.ActualValue,
         QualityParameter.ActualValue,
-        InfeasibilityParameter.ActualValue,
+        FlowDistanceQualityParameter.ActualValue,
+        InstallationQualityParameter.ActualValue,
+        OverbookedCapacityParameter.ActualValue,
         MaximumCandidateListSizeParameter.ActualValue,
         MaximumSampleSizeParameter.ActualValue,
         MaximumIterationsParameter.ActualValue,
-        DemandsParameter.ActualValue, CapacitiesParameter.ActualValue,
         WeightsParameter.ActualValue, DistancesParameter.ActualValue,
         InstallationCostsParameter.ActualValue,
-        TransportationCostsParameter.ActualValue);
+        DemandsParameter.ActualValue, CapacitiesParameter.ActualValue,
+        TransportationCostsParameter.ActualValue,
+        OverbookedCapacityPenaltyParameter.ActualValue,
+        OneMoveProbabilityParameter.ActualValue);
       return base.Apply();
     }

branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GreedyRandomizedSolutionCreator.cs

@@ -60 +60 @@
       while (tries < maxTries) {
         assignment.Clear();
-        demands.Select((v, i) => slack[i] = v).Enumerate();
+        capacities.Select((v, i) => slack[i] = v).Enumerate();
         HashSet<int> CF = new HashSet<int>(), // set of chosen facilities / equipments
           T = new HashSet<int>(), // set of facilities / equpiments that can be assigned to the set of chosen locations (CL)

@@ -1 +1 @@
 *.suo
+TestResults

@@ -2 +2 @@
 bin
 obj
+*.user