Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Analyzers/BestGQAPSolutionAnalyzer.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Analyzers/BestGQAPSolutionAnalyzer.cs	(revision 7413)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Analyzers/BestGQAPSolutionAnalyzer.cs	(revision 7415)
@@ -29,4 +29,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common;
 
 namespace HeuristicLab.Problems.GeneralizedQuadraticAssignment {
@@ -51,4 +52,19 @@
       get { return (LookupParameter<DoubleMatrix>)Parameters["Weights"]; }
     }
+    public LookupParameter<DoubleMatrix> InstallationCostsParameter {
+      get { return (LookupParameter<DoubleMatrix>)Parameters["InstallationCosts"]; }
+    }
+    public LookupParameter<DoubleArray> DemandsParameter {
+      get { return (LookupParameter<DoubleArray>)Parameters["Demands"]; }
+    }
+    public LookupParameter<DoubleArray> CapacitiesParameter {
+      get { return (LookupParameter<DoubleArray>)Parameters["Capacities"]; }
+    }
+    public LookupParameter<DoubleValue> TransportationCostsParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["TransportationCosts"]; }
+    }
+    public LookupParameter<DoubleValue> OverbookedCapacityPenaltyParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["OverbookedCapacityPenalty"]; }
+    }
     public ScopeTreeLookupParameter<IntegerVector> AssignmentParameter {
       get { return (ScopeTreeLookupParameter<IntegerVector>)Parameters["Assignment"]; }
@@ -56,4 +72,13 @@
     public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
       get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> FlowDistanceQualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["FlowDistanceQuality"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> InstallationQualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["InstallationQuality"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> OverbookedCapacityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["OverbookedCapacity"]; }
     }
     public LookupParameter<GQAPAssignment> BestSolutionParameter {
@@ -86,7 +111,15 @@
       Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem."));
       Parameters.Add(new LookupParameter<DoubleMatrix>("Distances", "The distances between the locations."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("Weights", "The weights between the facilities."));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("Weights", "The weights between the equipments."));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("InstallationCosts", "The cost of installing equipment x at location y."));
+      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 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."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("FlowDistanceQuality", "The flow-distance qualities of the GQAP solutions which should be analyzed."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("InstallationQuality", "The installation qualities of the GQAP solutions which should be analyzed."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("OverbookedCapacity", "The overbooked capacities of the GQAP solutions which should be analyzed."));
       Parameters.Add(new LookupParameter<GQAPAssignment>("BestSolution", "The best GQAP solution."));
       Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the best GQAP solution should be stored."));
@@ -109,39 +142,56 @@
 
     public override IOperation Apply() {
-      DoubleMatrix distances = DistancesParameter.ActualValue;
-      DoubleMatrix weights = WeightsParameter.ActualValue;
-      ItemArray<IntegerVector> assignments = AssignmentParameter.ActualValue;
-      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
-      ResultCollection results = ResultsParameter.ActualValue;
-      bool max = MaximizationParameter.ActualValue.Value;
-      DoubleValue bestKnownQuality = BestKnownQualityParameter.ActualValue;
-
-      var sorted = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).ToArray();
-      if (max) sorted = sorted.Reverse().ToArray();
-      int i = sorted.First().index;
-
-      if (bestKnownQuality == null
-          || max && qualities[i].Value > bestKnownQuality.Value
-          || !max && qualities[i].Value < bestKnownQuality.Value) {
-        // if there isn't a best-known quality or we improved the best-known quality we'll add the current solution as best-known
-        BestKnownQualityParameter.ActualValue = new DoubleValue(qualities[i].Value);
-        BestKnownSolutionParameter.ActualValue = (IntegerVector)assignments[i].Clone();
+      var assignments = AssignmentParameter.ActualValue;
+      var qualities = QualityParameter.ActualValue;
+      var equipmentNames = EquipmentNamesParameter.ActualValue;
+      var locationNames = LocationNamesParameter.ActualValue;
+      var flowDistanceQualities = FlowDistanceQualityParameter.ActualValue;
+      var installationQualities = InstallationQualityParameter.ActualValue;
+      var overbookedCapacities = OverbookedCapacityParameter.ActualValue;
+      var distances = DistancesParameter.ActualValue;
+      var weights = WeightsParameter.ActualValue;
+      var installationCosts = InstallationCostsParameter.ActualValue;
+      var demands = DemandsParameter.ActualValue;
+      var capacities = CapacitiesParameter.ActualValue;
+      var transportationCosts = TransportationCostsParameter.ActualValue;
+      var overbookedCapacityPenalty = OverbookedCapacityPenaltyParameter.ActualValue;
+      var results = ResultsParameter.ActualValue;
+      var maximization = MaximizationParameter.ActualValue.Value;
+      var bestKnownQuality = BestKnownQualityParameter.ActualValue;
+
+      int bestIndex;
+      var tmp = qualities.Select((x, index) => new { Index = index, Value = x.Value });
+      if (maximization) bestIndex = tmp.SelectMax(x => x.Value).Index;
+      else bestIndex = tmp.SelectMin(x => x.Value).Index;
+
+      if (bestKnownQuality == null || HasSolutionImproved(bestKnownQuality.Value, qualities[bestIndex].Value, maximization)) {
+        BestKnownQualityParameter.ActualValue = new DoubleValue(qualities[bestIndex].Value);
+        BestKnownSolutionParameter.ActualValue = (IntegerVector)assignments[bestIndex].Clone();
       }
 
       GQAPAssignment assignment = BestSolutionParameter.ActualValue;
       if (assignment == null) {
-        StringArray equipmentNames = EquipmentNamesParameter.ActualValue;
-        StringArray locationNames = LocationNamesParameter.ActualValue;
-        assignment = new GQAPAssignment(weights, (IntegerVector)assignments[i].Clone(), new DoubleValue(qualities[i].Value), equipmentNames, locationNames);
+        assignment = new GQAPAssignment((IntegerVector)assignments[bestIndex].Clone(), (DoubleValue)qualities[bestIndex].Clone(),
+          equipmentNames, locationNames, distances, weights, installationCosts, demands, capacities, transportationCosts,
+          overbookedCapacityPenalty, flowDistanceQualities[bestIndex], installationQualities[bestIndex], overbookedCapacities[bestIndex]);
         assignment.Distances = distances;
         BestSolutionParameter.ActualValue = assignment;
         results.Add(new Result("Best GQAP Solution", assignment));
       } else {
-        if (max && assignment.Quality.Value < qualities[i].Value ||
-          !max && assignment.Quality.Value > qualities[i].Value) {
+        if (HasSolutionImproved(assignment.Quality.Value, qualities[bestIndex].Value, maximization)) {
+          assignment.Assignment = (IntegerVector)assignments[bestIndex].Clone();
+          assignment.Quality = (DoubleValue)qualities[bestIndex].Clone();
+          assignment.EquipmentNames = equipmentNames;
+          assignment.LocationNames = locationNames;
           assignment.Distances = distances;
           assignment.Weights = weights;
-          assignment.Assignment = (IntegerVector)assignments[i].Clone();
-          assignment.Quality.Value = qualities[i].Value;
+          assignment.InstallationCosts = installationCosts;
+          assignment.Demands = demands;
+          assignment.Capacities = capacities;
+          assignment.TransportationCosts = transportationCosts;
+          assignment.OverbookedCapacityPenalty = overbookedCapacityPenalty;
+          assignment.FlowDistanceQuality = (DoubleValue)flowDistanceQualities[bestIndex].Clone();
+          assignment.InstallationQuality = (DoubleValue)installationQualities[bestIndex].Clone();
+          assignment.OverbookedCapacity = (DoubleValue)overbookedCapacities[bestIndex].Clone();
         }
       }
@@ -149,4 +199,8 @@
       return base.Apply();
     }
+
+    private static bool HasSolutionImproved(double oldQuality, double quality, bool maximization) {
+      return maximization && oldQuality < quality || !maximization && oldQuality > quality;
+    }
   }
 }
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/GQAPAssignment.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/GQAPAssignment.cs	(revision 7413)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/GQAPAssignment.cs	(revision 7415)
@@ -33,4 +33,48 @@
 
     [Storable]
+    private IntegerVector assignment;
+    public IntegerVector Assignment {
+      get { return assignment; }
+      set {
+        bool changed = (assignment != value);
+        assignment = value;
+        if (changed) OnPropertyChanged("Assignment");
+      }
+    }
+
+    [Storable]
+    private DoubleValue quality;
+    public DoubleValue Quality {
+      get { return quality; }
+      set {
+        bool changed = (quality != value);
+        quality = value;
+        if (changed) OnPropertyChanged("Quality");
+      }
+    }
+
+    [Storable]
+    private StringArray equipmentNames;
+    public StringArray EquipmentNames {
+      get { return equipmentNames; }
+      set {
+        bool changed = (equipmentNames != value);
+        equipmentNames = value;
+        if (changed) OnPropertyChanged("EquipmentNames");
+      }
+    }
+
+    [Storable]
+    private StringArray locationNames;
+    public StringArray LocationNames {
+      get { return locationNames; }
+      set {
+        bool changed = (locationNames != value);
+        locationNames = value;
+        if (changed) OnPropertyChanged("LocationNames");
+      }
+    }
+
+    [Storable]
     private DoubleMatrix distances;
     public DoubleMatrix Distances {
@@ -55,44 +99,88 @@
 
     [Storable]
-    private IntegerVector assignment;
-    public IntegerVector Assignment {
-      get { return assignment; }
-      set {
-        bool changed = (assignment != value);
-        assignment = value;
-        if (changed) OnPropertyChanged("Assignment");
-      }
-    }
-
-    [Storable]
-    private DoubleValue quality;
-    public DoubleValue Quality {
-      get { return quality; }
-      set {
-        bool changed = (quality != value);
-        quality = value;
-        if (changed) OnPropertyChanged("Quality");
-      }
-    }
-
-    [Storable]
-    private StringArray equipmentNames;
-    public StringArray EquipmentNames {
-      get { return equipmentNames; }
-      set {
-        bool changed = (equipmentNames != value);
-        equipmentNames = value;
-        if (changed) OnPropertyChanged("EquipmentNames");
-      }
-    }
-
-    [Storable]
-    private StringArray locationNames;
-    public StringArray LocationNames {
-      get { return locationNames; }
-      set {
-        bool changed = (locationNames != value);
-        locationNames = value;
-        if (changed) OnPropertyChanged("LocationNames");
+    private DoubleMatrix installationCosts;
+    public DoubleMatrix InstallationCosts {
+      get { return installationCosts; }
+      set {
+        bool changed = (installationCosts != value);
+        installationCosts = value;
+        if (changed) OnPropertyChanged("InstallationCosts");
+      }
+    }
+
+    [Storable]
+    private DoubleArray demands;
+    public DoubleArray Demands {
+      get { return demands; }
+      set {
+        bool changed = (demands != value);
+        demands = value;
+        if (changed) OnPropertyChanged("Demands");
+      }
+    }
+
+    [Storable]
+    private DoubleArray capacities;
+    public DoubleArray Capacities {
+      get { return capacities; }
+      set {
+        bool changed = (capacities != value);
+        capacities = value;
+        if (changed) OnPropertyChanged("Capacities");
+      }
+    }
+
+    [Storable]
+    private DoubleValue transportationCosts;
+    public DoubleValue TransportationCosts {
+      get { return transportationCosts; }
+      set {
+        bool changed = (transportationCosts != value);
+        transportationCosts = value;
+        if (changed) OnPropertyChanged("TransportationCosts");
+      }
+    }
+
+    [Storable]
+    private DoubleValue overbookedCapacityPenalty;
+    public DoubleValue OverbookedCapacityPenalty {
+      get { return overbookedCapacityPenalty; }
+      set {
+        bool changed = (overbookedCapacityPenalty != value);
+        overbookedCapacityPenalty = value;
+        if (changed) OnPropertyChanged("OverbookedCapacityPenalty");
+      }
+    }
+
+    [Storable]
+    private DoubleValue flowDistanceQuality;
+    public DoubleValue FlowDistanceQuality {
+      get { return flowDistanceQuality; }
+      set {
+        bool changed = (flowDistanceQuality != value);
+        flowDistanceQuality = value;
+        if (changed) OnPropertyChanged("FlowDistanceQuality");
+      }
+    }
+
+    [Storable]
+    private DoubleValue installationQuality;
+    public DoubleValue InstallationQuality {
+      get { return installationQuality; }
+      set {
+        bool changed = (installationQuality != value);
+        installationQuality = value;
+        if (changed) OnPropertyChanged("InstallationQuality");
+      }
+    }
+
+    [Storable]
+    private DoubleValue overbookedCapacity;
+    public DoubleValue OverbookedCapacity {
+      get { return overbookedCapacity; }
+      set {
+        bool changed = (overbookedCapacity != value);
+        overbookedCapacity = value;
+        if (changed) OnPropertyChanged("OverbookedCapacity");
       }
     }
@@ -102,23 +190,44 @@
     private GQAPAssignment(GQAPAssignment original, Cloner cloner)
       : base(original, cloner) {
-      distances = cloner.Clone(original.distances);
-      weights = cloner.Clone(original.weights);
       assignment = cloner.Clone(original.assignment);
       quality = cloner.Clone(original.quality);
       equipmentNames = cloner.Clone(original.equipmentNames);
       locationNames = cloner.Clone(original.locationNames);
-    }
-    public GQAPAssignment(DoubleMatrix weights, IntegerVector assignment) {
-      this.weights = weights;
+      distances = cloner.Clone(original.distances);
+      weights = cloner.Clone(original.weights);
+      installationCosts = cloner.Clone(original.installationCosts);
+      demands = cloner.Clone(original.demands);
+      capacities = cloner.Clone(original.capacities);
+      transportationCosts = cloner.Clone(original.transportationCosts);
+      overbookedCapacityPenalty = cloner.Clone(original.overbookedCapacityPenalty);
+      flowDistanceQuality = cloner.Clone(original.flowDistanceQuality);
+      installationQuality = cloner.Clone(original.installationQuality);
+      overbookedCapacity = cloner.Clone(original.overbookedCapacity);
+    }
+    public GQAPAssignment(IntegerVector assignment, DoubleValue quality)
+      : base() {
       this.assignment = assignment;
-    }
-    public GQAPAssignment(DoubleMatrix weights, IntegerVector assignment, DoubleValue quality)
-      : this(weights, assignment) {
       this.quality = quality;
     }
-    public GQAPAssignment(DoubleMatrix weights, IntegerVector assignment, DoubleValue quality, StringArray equipmentNames, StringArray locationNames)
-      : this(weights, assignment, quality) {
+    public GQAPAssignment(IntegerVector assignment, DoubleValue quality, StringArray equipmentNames, StringArray locationNames)
+      : this(assignment, quality) {
       this.equipmentNames = equipmentNames;
       this.locationNames = locationNames;
+    }
+    public GQAPAssignment(IntegerVector assignment, DoubleValue quality, StringArray equipmentNames, StringArray locationNames,
+      DoubleMatrix distances, DoubleMatrix weights, DoubleMatrix installationCosts, DoubleArray demands, DoubleArray capacities,
+      DoubleValue transportationCosts, DoubleValue overbookedCapacityPenalty, DoubleValue flowDistanceQuality,
+      DoubleValue installationQuality, DoubleValue overbookedCapacity)
+      : this(assignment, quality, equipmentNames, locationNames) {
+      this.distances = distances;
+      this.weights = weights;
+      this.installationCosts = installationCosts;
+      this.demands = demands;
+      this.capacities = capacities;
+      this.transportationCosts = transportationCosts;
+      this.overbookedCapacityPenalty = overbookedCapacityPenalty;
+      this.flowDistanceQuality = flowDistanceQuality;
+      this.installationQuality = installationQuality;
+      this.overbookedCapacity = overbookedCapacity;
     }
 
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/GeneralizedQuadraticAssignmentProblem.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/GeneralizedQuadraticAssignmentProblem.cs	(revision 7413)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/GeneralizedQuadraticAssignmentProblem.cs	(revision 7415)
@@ -68,4 +68,10 @@
       get { return (OptionalValueParameter<IItem>)Parameters["BestKnownSolution"]; }
     }
+    public OptionalValueParameter<StringArray> EquipmentNamesParameter {
+      get { return (OptionalValueParameter<StringArray>)Parameters["EquipmentNames"]; }
+    }
+    public OptionalValueParameter<StringArray> LocationNamesParameter {
+      get { return (OptionalValueParameter<StringArray>)Parameters["LocationNames"]; }
+    }
     #endregion
 
@@ -99,11 +105,16 @@
       set { TransportationCostsParameter.Value.Value = value; }
     }
+    public StringArray EquipmentNames {
+      get { return EquipmentNamesParameter.Value; }
+      set { EquipmentNamesParameter.Value = value; }
+    }
+    public StringArray LocationNames {
+      get { return LocationNamesParameter.Value; }
+      set { LocationNamesParameter.Value = value; }
+    }
     #endregion
 
-    [Storable]
-    private BestGQAPSolutionAnalyzer bestSolutionAnalyzer;
     public BestGQAPSolutionAnalyzer BestSolutionAnalyzer {
-      get { return bestSolutionAnalyzer; }
-      set { bestSolutionAnalyzer = value; }
+      get { return Operators.OfType<BestGQAPSolutionAnalyzer>().First(); }
     }
 
@@ -112,5 +123,4 @@
     private GeneralizedQuadraticAssignmentProblem(GeneralizedQuadraticAssignmentProblem original, Cloner cloner)
       : base(original, cloner) {
-      bestSolutionAnalyzer = cloner.Clone(original.bestSolutionAnalyzer);
       AttachEventHandlers();
     }
@@ -201,9 +211,9 @@
 
     private void InitializeOperators() {
+      Operators.Add(new BestGQAPSolutionAnalyzer());
+      Operators.AddRange(ApplicationManager.Manager.GetInstances<IGQAPOperator>());
       Operators.AddRange(ApplicationManager.Manager.GetInstances<IIntegerVectorOperator>());
-      Operators.AddRange(ApplicationManager.Manager.GetInstances<IGQAPOperator>());
       Operators.RemoveAll(x => x is ISingleObjectiveMoveEvaluator);
       Operators.AddRange(ApplicationManager.Manager.GetInstances<IGQAPMoveEvaluator>());
-      Operators.Add(new BestGQAPSolutionAnalyzer());
       Parameterize();
     }
@@ -276,11 +286,22 @@
 
       if (BestSolutionAnalyzer != null) {
-        BestSolutionAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+        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.MaximizationParameter.ActualName = MaximizationParameter.Name;
+        BestSolutionAnalyzer.BestKnownSolutionParameter.ActualName = BestKnownSolutionParameter.Name;
+        BestSolutionAnalyzer.EquipmentNamesParameter.ActualName = EquipmentNamesParameter.Name;
+        BestSolutionAnalyzer.LocationNamesParameter.ActualName = LocationNamesParameter.Name;
       }
     }
Index: branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GreedyRandomizedSolutionCreator.cs
===================================================================
--- branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GreedyRandomizedSolutionCreator.cs	(revision 7413)
+++ branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/Operators/GreedyRandomizedSolutionCreator.cs	(revision 7415)
@@ -60,5 +60,5 @@
       while (tries < maxTries) {
         assignment.Clear();
-        capacities.Select((v, i) => slack[i] = v).Enumerate();
+        slack = capacities.Select((v, i) => new { Index = i, Value = v }).ToDictionary(x => x.Index, y => y.Value);
         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)
