Changeset 6607 for branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4

Timestamp:

07/28/11 14:16:21 (13 years ago)

Author:

svonolfe

Message:

Merged changes from trunk (#1561) into branch (#1177)

Location:

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4

Files:

• Analyzer/BestSolution/BestVRPSolutionAnalyzer.cs (modified) (2 diffs)
• Encodings/Alba/Moves/LambdaInterchange/AlbaStochasticLambdaInterchangeMutliMoveGenerator.cs (modified) (1 diff)
• Encodings/General/Moves/VRPMoveMaker.cs (modified) (3 diffs)
• Encodings/Potvin/Creators/IterativeInsertionCreator.cs (modified) (2 diffs)
• Encodings/Potvin/Crossovers/PotvinCrossover.cs (modified) (5 diffs)
• Encodings/Potvin/Crossovers/PotvinRouteBasedCrossover.cs (modified) (2 diffs)
• Encodings/Potvin/Crossovers/PotvinSequenceBasedCrossover.cs (modified) (2 diffs)
• Encodings/Potvin/Manipulators/PotvinManipulator.cs (modified) (3 diffs)
• Encodings/Potvin/Manipulators/PotvinOneLevelExchangeManipulator.cs (modified) (2 diffs)
• Encodings/Potvin/Manipulators/PotvinTwoLevelExchangeManipulator.cs (modified) (2 diffs)
• Encodings/Potvin/Moves/CustomerRelocation/PotvinCustomerRelocationMoveMaker.cs (modified) (1 diff)
• Encodings/Potvin/PotvinEncoding.cs (modified) (3 diffs)
• Encodings/Prins/Manipulators/PrinsLSManipulator.cs (modified) (1 diff)
• Encodings/Prins/PrinsEncoding.cs (modified) (1 diff)
• Encodings/Tour.cs (modified) (2 diffs)
• HeuristicLab.Problems.VehicleRouting-3.4.csproj (modified) (2 diffs)
• Interfaces/IVRPProblemInstance.cs (modified) (2 diffs)
• ProblemInstances/VRPProblemInstance.cs (modified) (7 diffs)

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestSolution/BestVRPSolutionAnalyzer.cs

@@ -153 +153 @@
           else
             results.Add(new Result("Best valid VRP Solution", validSolution));
+
+          results.Add(new Result("Best valid VRP Solution Distance", new DoubleValue(distances[i].Value)));
+          results.Add(new Result("Best valid VRP Solution VehicleUtilization", new DoubleValue(vehiclesUtilizations[i].Value)));
         }
       } else {
@@ -160 +163 @@
             validSolution.Solution = best.Clone() as IVRPEncoding;
             validSolution.Quality.Value = qualities[i].Value;
+            (results["Best valid VRP Solution Distance"].Value as DoubleValue).Value = distances[i].Value;
+            (results["Best valid VRP Solution VehicleUtilization"].Value as DoubleValue).Value = vehiclesUtilizations[i].Value;
           }
         }

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/Moves/LambdaInterchange/AlbaStochasticLambdaInterchangeMutliMoveGenerator.cs

@@ -62 +62 @@
     }
 
-    protected override AlbaLambdaInterchangeMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance, int lambda) {
-      int sampleSize = SampleSizeParameter.ActualValue.Value;
-
+    public static AlbaLambdaInterchangeMove[] GenerateAllMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance, int lambda, int sampleSize, IRandom rand) {
       AlbaLambdaInterchangeMove[] moves = new AlbaLambdaInterchangeMove[sampleSize];
       for (int i = 0; i < sampleSize; i++) {
         moves[i] = AlbaStochasticLambdaInterchangeSingleMoveGenerator.Apply(
-          individual, problemInstance.Cities.Value, lambda, RandomParameter.ActualValue);
+          individual, problemInstance.Cities.Value, lambda, rand);
       }
 
       return moves;
     }
+
+    protected override AlbaLambdaInterchangeMove[] GenerateMoves(AlbaEncoding individual, IVRPProblemInstance problemInstance, int lambda) {
+      return GenerateAllMoves(individual, problemInstance, lambda, SampleSizeParameter.Value.Value, RandomParameter.ActualValue);
+    }
   }
 }

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/General/Moves/VRPMoveMaker.cs

@@ -74 +74 @@
           
             string resultName = evaluatorParameter.ActualName;
-            if (!this.Parameters.Exists(p => p.Name == resultName)) {
+            if (!this.Parameters.ContainsKey(resultName)) {
               ILookupParameter resultParameter = new LookupParameter<IItem>(resultName);
               resultParameter.ExecutionContext = ExecutionContext;
@@ -82 +82 @@
 
             string moveResultName = VRPMoveEvaluator.MovePrefix + resultName;
-            if (!this.Parameters.Exists(p => p.Name == moveResultName)) {
+            if (!this.Parameters.ContainsKey(moveResultName)) {
               ILookupParameter moveResultParameter = new LookupParameter<IItem>(moveResultName);
               moveResultParameter.ExecutionContext = ExecutionContext; 
@@ -91 +91 @@
             ILookupParameter result = Parameters[resultName] as ILookupParameter;
             ILookupParameter moveResult = Parameters[moveResultName] as ILookupParameter;
-            result.ActualValue = moveResult.ActualValue.Clone() as IItem;
+            result.ActualValue = moveResult.ActualValue;
           }
         }

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Creators/IterativeInsertionCreator.cs

@@ -83 +83 @@
     private static PotvinEncoding CreateSolution(IVRPProblemInstance instance, IRandom random, bool adhereTimeWindows) {
       PotvinEncoding result = new PotvinEncoding(instance);
-      IVRPEvaluator eval = instance.EvaluatorParameter.Value;
 
       List<int> customers = new List<int>();
@@ -105 +104 @@
         currentTour.Stops.Insert(stopIdx, customers[index]);
 
-        CVRPEvaluation evaluation = eval.Evaluate(instance, currentTour) as CVRPEvaluation;
+        CVRPEvaluation evaluation = instance.Evaluate(currentTour) as CVRPEvaluation;
         if (result.Tours.Count < instance.Vehicles.Value && 
-          ((adhereTimeWindows && !eval.Feasible(evaluation)) || ((!adhereTimeWindows) && evaluation.Overload > double.Epsilon))) {
+          ((adhereTimeWindows && !instance.Feasible(evaluation)) || ((!adhereTimeWindows) && evaluation.Overload > double.Epsilon))) {
           currentTour.Stops.RemoveAt(stopIdx);
 

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Crossovers/PotvinCrossover.cs

@@ -39 +39 @@
     }
 
+    public IValueParameter<BoolValue> AllowInfeasibleSolutions {
+      get { return (IValueParameter<BoolValue>)Parameters["AllowInfeasibleSolutions"]; }
+    }
+
     [StorableConstructor]
     protected PotvinCrossover(bool deserializing) : base(deserializing) { }
@@ -44 +48 @@
     public PotvinCrossover() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new ValueParameter<BoolValue>("AllowInfeasibleSolutions", "Indicates if infeasible solutions should be allowed.", new BoolValue(false)));
     }
 
@@ -52 +57 @@
     protected abstract PotvinEncoding Crossover(IRandom random, PotvinEncoding parent1, PotvinEncoding parent2);
 
-    protected bool FindInsertionPlace(PotvinEncoding individual, int city, out int route, out int place) {
+    protected static bool FindInsertionPlace(PotvinEncoding individual, int city, bool allowInfeasible,
+        out int route, out int place) {
       return individual.FindInsertionPlace(
-        city, -1, out route, out place);
+        city, -1, allowInfeasible,
+        out route, out place);
     }
 
@@ -70 +77 @@
     }
 
-    protected bool Repair(IRandom random, PotvinEncoding solution, Tour newTour) {
+    protected static bool RouteUnrouted(PotvinEncoding solution, bool allowInfeasible) {
       bool success = true;
-      
+      int index = 0;
+      while (index < solution.Unrouted.Count && success) {
+        int unrouted = solution.Unrouted[index];
+
+        int route, place;
+        if (FindInsertionPlace(solution, unrouted, allowInfeasible,
+          out route, out place)) {
+          solution.Tours[route].Stops.Insert(place, unrouted);
+        } else {
+          success = false;
+        }
+
+        index++;
+      }
+
+      for (int i = 0; i < index; i++)
+        solution.Unrouted.RemoveAt(0);
+
+      return success;
+    }
+
+    protected static bool Repair(IRandom random, PotvinEncoding solution, Tour newTour, IVRPProblemInstance instance, bool allowInfeasible) {
+      bool success = true;
+
       //remove duplicates from new tour      
       for (int i = 0; i < newTour.Stops.Count; i++) {
@@ -106 +136 @@
       }
 
+      if (!allowInfeasible && !instance.Feasible(newTour))
+        return false;
+
       //route unrouted vehicles
-      int index = 0;
-      while (index < solution.Unrouted.Count && success) {
-        int unrouted = solution.Unrouted[index];
-
-        int route, place;
-        if(FindInsertionPlace(solution, unrouted, out route, out place)) {
-          solution.Tours[route].Stops.Insert(place, unrouted);
-        } else {
-          success = false;
-        }
-
-        index++;
-      }
-
-      for (int i = 0; i < index; i++)
-        solution.Unrouted.RemoveAt(0);
+      success = RouteUnrouted(solution, allowInfeasible);
 
       return success;

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Crossovers/PotvinRouteBasedCrossover.cs

@@ -46 +46 @@
      
     protected override PotvinEncoding Crossover(IRandom random, PotvinEncoding parent1, PotvinEncoding parent2) {
+      bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
+
       PotvinEncoding child = parent2.Clone() as PotvinEncoding;
 
@@ -61 +63 @@
           child.Unrouted.Add(city);
 
-      if (Repair(random, child, replacing))
+      if (Repair(random, child, replacing, ProblemInstance, allowInfeasible) || allowInfeasible)
         return child;
       else {

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Crossovers/PotvinSequenceBasedCrossover.cs

@@ -46 +46 @@
         
     protected override PotvinEncoding Crossover(IRandom random, PotvinEncoding parent1, PotvinEncoding parent2) {
+      bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
+      
       PotvinEncoding child = parent1.Clone() as PotvinEncoding;
       Tour newTour = new Tour();
@@ -76 +78 @@
           child.Unrouted.Add(city);
 
-      if (ProblemInstance.Feasible(newTour) &&
-          Repair(random, child, newTour)) {
+      if (Repair(random, child, newTour, ProblemInstance, allowInfeasible) || allowInfeasible) {
         return child;
       } else {

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinManipulator.cs

@@ -38 +38 @@
     }
 
+    public IValueParameter<BoolValue> AllowInfeasibleSolutions {
+      get { return (IValueParameter<BoolValue>)Parameters["AllowInfeasibleSolutions"]; }
+    }
+
     [StorableConstructor]
     protected PotvinManipulator(bool deserializing) : base(deserializing) { }
@@ -43 +47 @@
     public PotvinManipulator() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new ValueParameter<BoolValue>("AllowInfeasibleSolutions", "Indicates if infeasible solutions should be allowed.", new BoolValue(false)));
     }
 
@@ -78 +83 @@
     }
 
-    protected bool FindInsertionPlace(PotvinEncoding individual, int city, int routeToAvoid, out int route, out int place) {
+    protected bool FindInsertionPlace(PotvinEncoding individual, int city, int routeToAvoid, bool allowInfeasible, out int route, out int place) {
       return individual.FindInsertionPlace(
-        city, routeToAvoid, out route, out place);
+        city, routeToAvoid, allowInfeasible, out route, out place);
     }
     

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinOneLevelExchangeManipulator.cs

@@ -46 +46 @@
     
     protected override void Manipulate(IRandom random, PotvinEncoding individual) {
+      bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
+      
       int selectedIndex = SelectRandomTourBiasedByLength(random, individual);
       Tour route1 =
@@ -54 +56 @@
         int insertedRoute, insertedPlace;
 
-        if (FindInsertionPlace(individual, route1.Stops[i], selectedIndex, out insertedRoute, out insertedPlace)) {
+        if (FindInsertionPlace(individual, route1.Stops[i], selectedIndex, allowInfeasible, out insertedRoute, out insertedPlace)) {
           individual.Tours[insertedRoute].Stops.Insert(insertedPlace, route1.Stops[i]);
           replaced.Add(route1.Stops[i]);

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Manipulators/PotvinTwoLevelExchangeManipulator.cs

@@ -46 +46 @@
 
     protected override void Manipulate(IRandom random, PotvinEncoding individual) {
+      bool allowInfeasible = AllowInfeasibleSolutions.Value.Value;
+      
       int selectedIndex = SelectRandomTourBiasedByLength(random, individual);
       Tour route1 = individual.Tours[selectedIndex];
@@ -65 +67 @@
                 int routeIdx, place;
                 if (FindInsertionPlace(individual,
-                  customer2, selectedIndex, out routeIdx, out place)) {
+                  customer2, selectedIndex, allowInfeasible, out routeIdx, out place)) {
                   individual.Tours[routeIdx].Stops.Insert(place, customer2);
                   route1.Stops.RemoveAt(customer1Position);

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/CustomerRelocation/PotvinCustomerRelocationMoveMaker.cs

@@ -106 +106 @@
 
       //reset move quality
-      VRPEvaluation eval = ProblemInstance.EvaluatorParameter.Value.Evaluate(ProblemInstance, newSolution);
+      VRPEvaluation eval = ProblemInstance.Evaluate(newSolution);
       MoveQualityParameter.ActualValue.Value = eval.Quality;
 
       //update penalty factor
       double sigma = SigmaParameter.Value.Value;
-      if (ProblemInstance.EvaluatorParameter.Value.Feasible(eval)) {
+      if (ProblemInstance.Feasible(eval)) {
         newSolution.PenaltyFactor /= (1 + sigma);
         if (newSolution.PenaltyFactor < MinPenaltyFactorParameter.Value.Value)

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/PotvinEncoding.cs

@@ -80 +80 @@
 
     public double GetTourLength(Tour tour) {
-      double length = 0;
-
-      if (tour.Stops.Count > 0) {
-        List<int> cities = new List<int>();
-        cities.Add(0);
-        foreach (int city in tour.Stops) {
-          cities.Add(city);
-        }
-        cities.Add(0);
-
-        for (int i = 1; i < cities.Count; i++) {
-          length += ProblemInstance.GetDistance(cities[i - 1], cities[i]);
-        }
-      }  
-
-      return length;
+      return tour.GetTourLength(ProblemInstance);
     }
 
@@ -105 +90 @@
         tour.Stops.Insert(i, city);
 
-        VRPEvaluation eval = ProblemInstance.EvaluatorParameter.Value.Evaluate(ProblemInstance, tour);
+        VRPEvaluation eval = ProblemInstance.Evaluate(tour);
         double quality = eval.Quality + eval.Penalty * (PenaltyFactor - 1.0);
 
@@ -122 +107 @@
     }
 
-    public bool FindInsertionPlace(int city, int routeToAvoid, out int route, out int place) {
+    public bool FindInsertionPlace(int city, int routeToAvoid, bool allowInfeasible, out int route, out int place) {
       route = -1;
       place = -1;
-      double minDetour = 0;
+      bool bestFeasible = false;
+      double minDetour = double.MaxValue;
 
       for (int tour = 0; tour < Tours.Count; tour++) {
         if (tour != routeToAvoid) {
-          double length = GetTourLength(Tours[tour]);
+          for (int i = 0; i <= Tours[tour].Stops.Count; i++) {
+            double length = GetTourLength(Tours[tour]);
 
-          for (int i = 0; i <= Tours[tour].Stops.Count; i++) {
             Tours[tour].Stops.Insert(i, city);
 
-            VRPEvaluation eval = ProblemInstance.EvaluatorParameter.Value.Evaluate(
-              ProblemInstance, Tours[tour]);
-            if (ProblemInstance.EvaluatorParameter.Value.Feasible(eval)) {
-              double newLength = eval.Distance;
+            bool feasible = ProblemInstance.Feasible(Tours[tour]);
 
+            if (feasible || allowInfeasible && !bestFeasible) {
+              double newLength = GetTourLength(Tours[tour]);
               double detour = newLength - length;
 
-              if (route <= 0 || detour < minDetour) {
+              if (route < 0 || detour < minDetour || feasible && !bestFeasible) {
                 route = tour;
                 place = i;
                 minDetour = detour;
+
+                if (feasible)
+                  bestFeasible = true;
               }
             }

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsLSManipulator.cs

@@ -49 +49 @@
 
     protected double GetQuality(PrinsEncoding individual) {
-      return ProblemInstance.Evaluate(individual);
+      return ProblemInstance.Evaluate(individual).Quality;
     }
 

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/PrinsEncoding.cs

@@ -61 +61 @@
 
           VRPEvaluation eval =
-            ProblemInstance.EvaluatorParameter.Value.Evaluate(ProblemInstance,
-             tour);
+            ProblemInstance.Evaluate(tour);
 
           double cost = eval.Quality;
-          feasible = ProblemInstance.EvaluatorParameter.Value.Feasible(eval);
+          feasible = ProblemInstance.Feasible(eval);
 
           if (feasible) {

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Tour.cs

@@ -27 +27 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
 
 namespace HeuristicLab.Problems.VehicleRouting {
@@ -46 +47 @@
         this.Stops = new List<int>(original.Stops);
     }
+
+    public double GetTourLength(IVRPProblemInstance instance) {
+      double length = 0;
+
+      if (Stops.Count > 0) {
+        List<int> cities = new List<int>();
+        cities.Add(0);
+        foreach (int city in Stops) {
+          cities.Add(city);
+        }
+        cities.Add(0);
+
+        for (int i = 1; i < cities.Count; i++) {
+          length += instance.GetDistance(cities[i - 1], cities[i]);
+        }
+      }
+
+      return length;
+    }
   }
 }

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/HeuristicLab.Problems.VehicleRouting-3.4.csproj

@@ -128 +128 @@
     <Compile Include="Encodings\Alba\Crossovers\AlbaCrossover.cs" />
     <Compile Include="Encodings\Alba\Crossovers\AlbaPermutationCrossover.cs" />
+    <Compile Include="Encodings\Alba\LocalImprovement\AlbaLambdaInterchangeLocalImprovementOperator.cs" />
     <Compile Include="Encodings\Alba\Manipulators\AlbaCustomerInsertionManipulator.cs" />
     <Compile Include="Encodings\Alba\Manipulators\AlbaCustomerInversionManipulator.cs" />
@@ -194 +195 @@
     <Compile Include="Encodings\Potvin\Creators\IterativeInsertionCreator.cs" />
     <Compile Include="Encodings\Potvin\Crossovers\PotvinCrossover.cs" />
+    <Compile Include="Encodings\Potvin\Crossovers\PotvinInsertionBasedCrossover.cs" />
     <Compile Include="Encodings\Potvin\Crossovers\PotvinRouteBasedCrossover.cs" />
     <Compile Include="Encodings\Potvin\Crossovers\PotvinSequenceBasedCrossover.cs" />

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Interfaces/IVRPProblemInstance.cs

@@ -27 +27 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
 
 namespace HeuristicLab.Problems.VehicleRouting.Interfaces {
@@ -50 +51 @@
     bool Feasible(IVRPEncoding solution);
     bool Feasible(Tour tour);
-    double Evaluate(IVRPEncoding solution);
-    double Evaluate(Tour tour);
+    VRPEvaluation Evaluate(IVRPEncoding solution);
+    VRPEvaluation Evaluate(Tour tour);
+    bool Feasible(VRPEvaluation eval);
   }
 }

branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/VRPProblemInstance.cs

@@ -187 +187 @@
       return distanceMatrix;
     }
-    
+
+    //cache for performance improvement
+    private DoubleMatrix distanceMatrix = null;
+    private IVRPEvaluator evaluator = null;
+
     public double GetDistance(int start, int end) {
       double distance = 0.0;
-      DoubleMatrix distanceMatrix = DistanceMatrix;
-
       if (distanceMatrix == null && UseDistanceMatrix.Value) {
         distanceMatrix = DistanceMatrix = CreateDistanceMatrix();
@@ -205 +207 @@
 
     public bool Feasible(IVRPEncoding solution) {
-      return EvaluatorParameter.Value.Feasible(
-        EvaluatorParameter.Value.Evaluate(
+      return evaluator.Feasible(
+        evaluator.Evaluate(
           this, solution));
     }
 
     public bool Feasible(Tour tour) {
-      return EvaluatorParameter.Value.Feasible(
-        EvaluatorParameter.Value.Evaluate(
+      return evaluator.Feasible(
+        evaluator.Evaluate(
         this, tour));
     }
 
-    public double Evaluate(IVRPEncoding solution) {
-      return EvaluatorParameter.Value.Evaluate(this, solution).Quality;
-    }
-
-    public double Evaluate(Tour tour) {
-      return EvaluatorParameter.Value.Evaluate(this, tour).Quality;
+    public VRPEvaluation Evaluate(IVRPEncoding solution) {
+      return evaluator.Evaluate(this, solution);
+    }
+
+    public VRPEvaluation Evaluate(Tour tour) {
+      return evaluator.Evaluate(this, tour);
+    }
+
+    public bool Feasible(VRPEvaluation eval) {
+      return evaluator.Feasible(eval);
     }
 
@@ -227 +233 @@
       if (BestKnownSolution != null) {
         //call evaluator
-        BestKnownQuality = new DoubleValue(Evaluate(BestKnownSolution.Solution));
+        BestKnownQuality = new DoubleValue(Evaluate(BestKnownSolution.Solution).Quality);
         BestKnownSolution.Quality = BestKnownQuality;
       } else {
@@ -275 +281 @@
       }
       #endregion
-      
+
       AttachEventHandlers();
     }
 
     private void AttachEventHandlers() {
+      evaluator = EvaluatorParameter.Value;
       EvaluatorParameter.ValueChanged += new EventHandler(EvaluatorParameter_ValueChanged);
       BestKnownSolutionParameter.ValueChanged += new EventHandler(BestKnownSolutionParameter_ValueChanged);
@@ -298 +305 @@
     void EvaluatorParameter_ValueChanged(object sender, EventArgs e) {
       moveEvaluator = null;
+      evaluator = EvaluatorParameter.Value;
     }
 
@@ -322 +330 @@
         DistanceMatrix.Reset += new EventHandler(DistanceMatrix_Reset);
       }
+      distanceMatrix = DistanceMatrix;
       EvalBestKnownSolution();
     }
@@ -328 +337 @@
     }
     void DistanceMatrix_ItemChanged(object sender, EventArgs<int, int> e) {
+      distanceMatrix = DistanceMatrix;
       EvalBestKnownSolution();
     }
     void UseDistanceMatrixParameter_ValueChanged(object sender, EventArgs e) {
       UseDistanceMatrix.ValueChanged += new EventHandler(UseDistanceMatrix_ValueChanged);
+      if (!UseDistanceMatrix.Value)
+        distanceMatrix = null;
       EvalBestKnownSolution();
     }
     void UseDistanceMatrix_ValueChanged(object sender, EventArgs e) {
+      if (!UseDistanceMatrix.Value)
+        distanceMatrix = null;
       EvalBestKnownSolution();
     }