Changeset 4015 for trunk/sources/HeuristicLab.Problems.VehicleRouting

Timestamp:

07/08/10 11:23:02 (14 years ago)

Author:

svonolfe

Message:

Improved VRP solution view (#1039)

Location:

trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3

Files:

• Analyzers/BestVRPSolutionAnalyzer.cs (modified) (4 diffs)
• Evaluators/VRPEvaluator.cs (modified) (2 diffs)
• MoveEvaluators/VRPMoveEvaluator.cs (modified) (1 diff)
• VRPSolution.cs (modified) (5 diffs)
• VehicleRoutingProblem.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestVRPSolutionAnalyzer.cs

@@ -41 +41 @@
       get { return (ScopeTreeLookupParameter<IVRPEncoding>)Parameters["VRPSolution"]; }
     }
+    public ILookupParameter<DoubleMatrix> DistanceMatrixParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["DistanceMatrix"]; }
+    }
+    public ILookupParameter<BoolValue> UseDistanceMatrixParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["UseDistanceMatrix"]; }
+    }
     public LookupParameter<DoubleMatrix> CoordinatesParameter {
       get { return (LookupParameter<DoubleMatrix>)Parameters["Coordinates"]; }
+    }
+    public ILookupParameter<DoubleArray> ReadyTimeParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["ReadyTime"]; }
+    }
+    public ILookupParameter<DoubleArray> DueTimeParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["DueTime"]; }
+    }
+    public ILookupParameter<DoubleArray> ServiceTimeParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["ServiceTime"]; }
     }
     public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
@@ -73 +88 @@
       Parameters.Add(new ScopeTreeLookupParameter<IVRPEncoding>("VRPSolution", "The VRP solutions which should be evaluated."));
       Parameters.Add(new LookupParameter<DoubleMatrix>("Coordinates", "The x- and y-Coordinates of the cities."));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("DistanceMatrix", "The matrix which contains the distances between the cities."));
+      Parameters.Add(new LookupParameter<BoolValue>("UseDistanceMatrix", "True if a distance matrix should be calculated and used for evaluation, otherwise false."));
+      Parameters.Add(new LookupParameter<DoubleArray>("ReadyTime", "The ready time of each customer."));
+      Parameters.Add(new LookupParameter<DoubleArray>("DueTime", "The due time of each customer."));
+      Parameters.Add(new LookupParameter<DoubleArray>("ServiceTime", "The service time of each customer."));
+
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The qualities of the VRP solutions which should be analyzed."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Distance", "The distances of the VRP solutions which should be analyzed."));
@@ -101 +122 @@
         solution = new VRPSolution(coordinates, best.Clone() as IVRPEncoding, new DoubleValue(qualities[i].Value),
           new DoubleValue(distances[i].Value), new DoubleValue(overloads[i].Value), new DoubleValue(tardinesses[i].Value),
-          new DoubleValue(travelTimes[i].Value), new DoubleValue(vehiclesUtilizations[i].Value));
+          new DoubleValue(travelTimes[i].Value), new DoubleValue(vehiclesUtilizations[i].Value), 
+          DistanceMatrixParameter.ActualValue, UseDistanceMatrixParameter.ActualValue, 
+          ReadyTimeParameter.ActualValue, DueTimeParameter.ActualValue, ServiceTimeParameter.ActualValue);
         BestSolutionParameter.ActualValue = solution;
         results.Add(new Result("Best VRP Solution", solution));
@@ -114 +137 @@
           solution.TravelTime.Value = travelTimes[i].Value;
           solution.VehicleUtilization.Value = vehiclesUtilizations[i].Value;
-
-          if (solution.Quality.Value < solution.Distance.Value) {
-          }
+          solution.DistanceMatrix = DistanceMatrixParameter.ActualValue;
+          solution.UseDistanceMatrix = UseDistanceMatrixParameter.ActualValue;
+          solution.ReadyTime = ReadyTimeParameter.ActualValue;
+          solution.DueTime = DueTimeParameter.ActualValue;
+          solution.ServiceTime = ServiceTimeParameter.ActualValue;
         }
       }

trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Evaluators/VRPEvaluator.cs

@@ -143 +143 @@
     }
 
-    private static double CalculateDistance(int start, int end, DoubleMatrix coordinates) {
-      double distance = 0.0;
-
-      distance =
-          Math.Sqrt(
-            Math.Pow(coordinates[start, 0] - coordinates[end, 0], 2) +
-            Math.Pow(coordinates[start, 1] - coordinates[end, 1], 2));
-
-      return distance;
-    }
-
-    private static DoubleMatrix CreateDistanceMatrix(DoubleMatrix coordinates) 
-    {
-      DoubleMatrix distanceMatrix = new DoubleMatrix(coordinates.Rows, coordinates.Rows);
-
-      for (int i = 0; i < distanceMatrix.Rows; i++) {
-        for (int j = i; j < distanceMatrix.Columns; j++) {
-          double distance = CalculateDistance(i, j, coordinates);
-
-          distanceMatrix[i, j] = distance;
-          distanceMatrix[j, i] = distance;
-        }
-      }
-
-      return distanceMatrix;
-    }
-
-    private static double GetDistance(int start, int end, 
-      DoubleMatrix coordinates, ILookupParameter<DoubleMatrix> distanceMatrix, BoolValue useDistanceMatrix) {
-      double distance = 0.0;
-
-      if (useDistanceMatrix.Value) {
-        if (distanceMatrix.ActualValue == null) {
-          distanceMatrix.ActualValue = CreateDistanceMatrix(coordinates);
-        }
-
-        distance = distanceMatrix.ActualValue[start, end];
-      } else {
-        distance = CalculateDistance(start, end, coordinates);
-      }
-
-      return distance;
-    }
-
     private static TourEvaluation EvaluateTour(Tour tour, DoubleArray dueTimeArray,
       DoubleArray serviceTimeArray, DoubleArray readyTimeArray, DoubleArray demandArray, DoubleValue capacity, 
@@ -210 +166 @@
 
         //drive there
-        double currentDistace = GetDistance(start, end, coordinates, distanceMatrix, useDistanceMatrix);
+        double currentDistace = VehicleRoutingProblem.GetDistance(start, end, coordinates, distanceMatrix, useDistanceMatrix);
         distance += currentDistace;
         time += currentDistace;

trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/MoveEvaluators/VRPMoveEvaluator.cs

@@ -145 +145 @@
       MoveTravelTimeParameter.ActualValue = new DoubleValue(tourEval.TravelTime);
 
-      if (tourEval.Quality < tourEval.Distance) {
-      }
-
       return base.Apply();
     }

trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/VRPSolution.cs

@@ -142 +142 @@
       }
     }
+    [Storable]
+    private DoubleMatrix distanceMatrix;
+    public DoubleMatrix DistanceMatrix {
+      get { return distanceMatrix; }
+      set {
+        if (distanceMatrix != value) {
+          distanceMatrix = value;
+        }
+      }
+    }
+    [Storable]
+    private BoolValue useDistanceMatrix;
+    public BoolValue UseDistanceMatrix {
+      get { return useDistanceMatrix; }
+      set {
+        if (useDistanceMatrix != value) {
+          useDistanceMatrix = value;
+        }
+      }
+    }
+    [Storable]
+    private DoubleArray readyTime;
+    public DoubleArray ReadyTime {
+      get { return readyTime; }
+      set {
+        if (readyTime != value) {
+          readyTime = value;
+        }
+      }
+    }
+    [Storable]
+    private DoubleArray dueTime;
+    public DoubleArray DueTime {
+      get { return dueTime; }
+      set {
+        if (dueTime != value) {
+          dueTime = value;
+        }
+      }
+    }
+    [Storable]
+    private DoubleArray serviceTime;
+    public DoubleArray ServiceTime {
+      get { return serviceTime; }
+      set {
+        if (serviceTime != value) {
+          serviceTime = value;
+        }
+      }
+    }
 
     public VRPSolution() : base() { }
@@ -147 +197 @@
     public VRPSolution(DoubleMatrix coordinates, IVRPEncoding solution, DoubleValue quality, 
       DoubleValue distance, DoubleValue overload, DoubleValue tardiness, DoubleValue travelTime, 
-      DoubleValue vehicleUtilization)
+      DoubleValue vehicleUtilization, DoubleMatrix distanceMatrix, BoolValue useDistanceMatrix,
+      DoubleArray readyTime, DoubleArray dueTime, DoubleArray serviceTime)
       : base() {
       this.coordinates = coordinates;
@@ -157 +208 @@
       this.travelTime = travelTime;
       this.vehicleUtilization = vehicleUtilization;
+      this.distanceMatrix = distanceMatrix;
+      this.useDistanceMatrix = useDistanceMatrix;
+      this.readyTime = readyTime;
+      this.dueTime = dueTime;
+      this.serviceTime = serviceTime;
       Initialize();
     }
@@ -167 +223 @@
       if (solution != null) RegisterSolutionEvents();
       if (quality != null) RegisterQualityEvents();
+      if (distance != null) RegisterDistanceEvents();
+      if (overload != null) RegisterOverloadEvents();
+      if (tardiness != null) RegisterTardinessEvents();
+      if (travelTime != null) RegisterTravelTimeEvents();
+      if (vehicleUtilization != null) RegisterVehicleUtilizationEvents();
     }
 
@@ -180 +241 @@
       clone.travelTime = (DoubleValue)cloner.Clone(travelTime);
       clone.vehicleUtilization = (DoubleValue)cloner.Clone(vehicleUtilization);
+      clone.distanceMatrix = (DoubleMatrix)cloner.Clone(distanceMatrix);
+      clone.useDistanceMatrix = (BoolValue)cloner.Clone(useDistanceMatrix);
+      clone.readyTime = (DoubleArray)cloner.Clone(readyTime);
+      clone.dueTime = (DoubleArray)cloner.Clone(dueTime);
+      clone.serviceTime = (DoubleArray)cloner.Clone(serviceTime);
       clone.Initialize();
       return clone;

trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs

@@ -222 +222 @@
     }
 
+    private static double CalculateDistance(int start, int end, DoubleMatrix coordinates) {
+      double distance = 0.0;
+
+      distance =
+          Math.Sqrt(
+            Math.Pow(coordinates[start, 0] - coordinates[end, 0], 2) +
+            Math.Pow(coordinates[start, 1] - coordinates[end, 1], 2));
+
+      return distance;
+    }
+
+    private static DoubleMatrix CreateDistanceMatrix(DoubleMatrix coordinates) {
+      DoubleMatrix distanceMatrix = new DoubleMatrix(coordinates.Rows, coordinates.Rows);
+
+      for (int i = 0; i < distanceMatrix.Rows; i++) {
+        for (int j = i; j < distanceMatrix.Columns; j++) {
+          double distance = CalculateDistance(i, j, coordinates);
+
+          distanceMatrix[i, j] = distance;
+          distanceMatrix[j, i] = distance;
+        }
+      }
+
+      return distanceMatrix;
+    }
+
+    public static double GetDistance(int start, int end,
+      DoubleMatrix coordinates, ILookupParameter<DoubleMatrix> distanceMatrix, BoolValue useDistanceMatrix) {
+      double distance = 0.0;
+
+      if (useDistanceMatrix.Value) {
+        if (distanceMatrix.ActualValue == null) {
+          distanceMatrix.ActualValue = CreateDistanceMatrix(coordinates);
+        }
+
+        distance = distanceMatrix.ActualValue[start, end];
+      } else {
+        distance = CalculateDistance(start, end, coordinates);
+      }
+
+      return distance;
+    }
+
+    public static double GetDistance(int start, int end,
+      DoubleMatrix coordinates, DoubleMatrix distanceMatrix, BoolValue useDistanceMatrix) {
+      double distance = 0.0;
+
+      if (useDistanceMatrix.Value) {
+        distance = distanceMatrix[start, end];
+      } else {
+        distance = CalculateDistance(start, end, coordinates);
+      }
+
+      return distance;
+    }
+
     public void ImportFromSolomon(string solomonFileName) {
       SolomonParser parser = new SolomonParser(solomonFileName);