source: stable/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/VRPProblemInstance.cs @ 15219

Last change on this file since 15219 was 15219, checked in by abeham, 3 years ago

#2696, #2790: merged revisions 15072, 15083, 15168 to stable

File size: 14.0 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Linq;
25using HeuristicLab.Common;
26using HeuristicLab.Core;
27using HeuristicLab.Data;
28using HeuristicLab.Parameters;
29using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
30using HeuristicLab.Problems.VehicleRouting.Encodings.General;
31using HeuristicLab.Problems.VehicleRouting.Interfaces;
32
33namespace HeuristicLab.Problems.VehicleRouting.ProblemInstances {
34  [Item("VRPProblemInstance", "Represents a VRP instance.")]
35  [StorableClass]
36  public abstract class VRPProblemInstance : ParameterizedNamedItem, IVRPProblemInstance, IStatefulItem {
37    IVRPEvaluator moveEvaluator;
38
39    private object locker = new object();
40
41    public IVRPEvaluator MoveEvaluator {
42      get {
43        lock (locker) {
44          if (evaluator == null)
45            return null;
46          else {
47            if (moveEvaluator == null) {
48              moveEvaluator = evaluator.Clone() as IVRPEvaluator;
49
50              foreach (IParameter parameter in moveEvaluator.Parameters) {
51                if (parameter is ILookupParameter
52                  && parameter != moveEvaluator.ProblemInstanceParameter
53                  && parameter != moveEvaluator.VRPToursParameter) {
54                  (parameter as ILookupParameter).ActualName =
55                    VRPMoveEvaluator.MovePrefix +
56                    (parameter as ILookupParameter).ActualName;
57                }
58              }
59            }
60
61            return moveEvaluator;
62          }
63        }
64      }
65    }
66
67    protected abstract IEnumerable<IOperator> GetOperators();
68    protected abstract IEnumerable<IOperator> GetAnalyzers();
69
70    public IEnumerable<IOperator> Operators {
71      get {
72        return GetOperators().Union(GetAnalyzers());
73      }
74    }
75
76    protected ValueParameter<DoubleMatrix> CoordinatesParameter {
77      get { return (ValueParameter<DoubleMatrix>)Parameters["Coordinates"]; }
78    }
79    protected OptionalValueParameter<DoubleMatrix> DistanceMatrixParameter {
80      get { return (OptionalValueParameter<DoubleMatrix>)Parameters["DistanceMatrix"]; }
81    }
82    protected ValueParameter<BoolValue> UseDistanceMatrixParameter {
83      get { return (ValueParameter<BoolValue>)Parameters["UseDistanceMatrix"]; }
84    }
85    protected ValueParameter<IntValue> VehiclesParameter {
86      get { return (ValueParameter<IntValue>)Parameters["Vehicles"]; }
87    }
88    protected ValueParameter<DoubleArray> DemandParameter {
89      get { return (ValueParameter<DoubleArray>)Parameters["Demand"]; }
90    }
91
92    protected IValueParameter<DoubleValue> FleetUsageFactorParameter {
93      get { return (IValueParameter<DoubleValue>)Parameters["EvalFleetUsageFactor"]; }
94    }
95    protected IValueParameter<DoubleValue> DistanceFactorParameter {
96      get { return (IValueParameter<DoubleValue>)Parameters["EvalDistanceFactor"]; }
97    }
98
99    public DoubleMatrix Coordinates {
100      get { return CoordinatesParameter.Value; }
101      set { CoordinatesParameter.Value = value; }
102    }
103
104    public DoubleMatrix DistanceMatrix {
105      get { return DistanceMatrixParameter.Value; }
106      set { DistanceMatrixParameter.Value = value; }
107    }
108    public BoolValue UseDistanceMatrix {
109      get { return UseDistanceMatrixParameter.Value; }
110      set { UseDistanceMatrixParameter.Value = value; }
111    }
112    public IntValue Vehicles {
113      get { return VehiclesParameter.Value; }
114      set { VehiclesParameter.Value = value; }
115    }
116    public DoubleArray Demand {
117      get { return DemandParameter.Value; }
118      set { DemandParameter.Value = value; }
119    }
120    public virtual IntValue Cities {
121      get { return new IntValue(Demand.Length); }
122    }
123
124    public DoubleValue FleetUsageFactor {
125      get { return FleetUsageFactorParameter.Value; }
126      set { FleetUsageFactorParameter.Value = value; }
127    }
128    public DoubleValue DistanceFactor {
129      get { return DistanceFactorParameter.Value; }
130      set { DistanceFactorParameter.Value = value; }
131    }
132
133    protected virtual double CalculateDistance(int start, int end) {
134      double distance = 0.0;
135
136      distance =
137          Math.Sqrt(
138            Math.Pow(Coordinates[start, 0] - Coordinates[end, 0], 2) +
139            Math.Pow(Coordinates[start, 1] - Coordinates[end, 1], 2));
140
141      return distance;
142    }
143
144    private DoubleMatrix CreateDistanceMatrix() {
145      DoubleMatrix distanceMatrix = new DoubleMatrix(Coordinates.Rows, Coordinates.Rows);
146
147      for (int i = 0; i < distanceMatrix.Rows; i++) {
148        for (int j = 0; j < distanceMatrix.Columns; j++) {
149          double distance = CalculateDistance(i, j);
150
151          distanceMatrix[i, j] = distance;
152        }
153      }
154
155      return distanceMatrix;
156    }
157
158    public virtual double[] GetCoordinates(int city) {
159      double[] coordinates = new double[Coordinates.Columns];
160
161      for (int i = 0; i < Coordinates.Columns; i++) {
162        coordinates[i] = Coordinates[city, i];
163      }
164
165      return coordinates;
166    }
167
168    public virtual double GetDemand(int city) {
169      return Demand[city];
170    }
171
172    //cache for performance improvement
173    private DoubleMatrix distanceMatrix = null;
174    private IVRPEvaluator evaluator = null;
175
176    public IVRPEvaluator SolutionEvaluator {
177      get {
178        return evaluator;
179      }
180
181      set {
182        lock (locker) {
183          moveEvaluator = null;
184          evaluator = value;
185          EvalBestKnownSolution();
186        }
187      }
188    }
189
190    public virtual double GetDistance(int start, int end, IVRPEncoding solution) {
191      if (distanceMatrix == null && UseDistanceMatrix.Value) {
192        distanceMatrix = DistanceMatrix ?? CreateDistanceMatrix();
193      }
194
195      if (distanceMatrix != null) return distanceMatrix[start, end];
196      return CalculateDistance(start, end);
197    }
198
199    public virtual double GetInsertionDistance(int start, int customer, int end, IVRPEncoding solution,
200      out double startDistance, out double endDistance) {
201      double distance = GetDistance(start, end, solution);
202
203      startDistance = GetDistance(start, customer, solution);
204      endDistance = GetDistance(customer, end, solution);
205
206      double newDistance = startDistance + endDistance;
207
208      return newDistance - distance;
209    }
210
211    public bool Feasible(IVRPEncoding solution) {
212      return evaluator.Feasible(
213        evaluator.Evaluate(
214          this, solution));
215    }
216
217    public bool TourFeasible(Tour tour, IVRPEncoding solution) {
218      return evaluator.Feasible(
219        evaluator.EvaluateTour(
220        this, tour, solution));
221    }
222
223    public VRPEvaluation Evaluate(IVRPEncoding solution) {
224      return evaluator.Evaluate(this, solution);
225    }
226
227    public VRPEvaluation EvaluateTour(Tour tour, IVRPEncoding solution) {
228      return evaluator.EvaluateTour(this, tour, solution);
229    }
230
231    public bool Feasible(VRPEvaluation eval) {
232      return evaluator.Feasible(eval);
233    }
234
235    public double GetInsertionCosts(VRPEvaluation eval, IVRPEncoding solution, int customer, int tour, int index, out bool feasible) {
236      return evaluator.GetInsertionCosts(this, solution, eval, customer, tour, index, out feasible);
237    }
238
239
240    public event EventHandler EvaluationChanged;
241
242    protected void EvalBestKnownSolution() {
243      EventHandler tmp = EvaluationChanged;
244      if (tmp != null)
245        tmp(this, null);
246    }
247
248    protected abstract IVRPEvaluator Evaluator { get; }
249    protected abstract IVRPCreator Creator { get; }
250
251    [StorableConstructor]
252    protected VRPProblemInstance(bool deserializing) : base(deserializing) { }
253
254    public VRPProblemInstance()
255      : base() {
256      Parameters.Add(new ValueParameter<DoubleMatrix>("Coordinates", "The x- and y-Coordinates of the cities.", new DoubleMatrix()));
257      Parameters.Add(new OptionalValueParameter<DoubleMatrix>("DistanceMatrix", "The matrix which contains the distances between the cities."));
258      Parameters.Add(new ValueParameter<BoolValue>("UseDistanceMatrix", "True if a distance matrix should be calculated and used for evaluation, otherwise false.", new BoolValue(true)));
259      Parameters.Add(new ValueParameter<IntValue>("Vehicles", "The number of vehicles.", new IntValue(0)));
260      Parameters.Add(new ValueParameter<DoubleArray>("Demand", "The demand of each customer.", new DoubleArray()));
261
262      Parameters.Add(new ValueParameter<DoubleValue>("EvalFleetUsageFactor", "The fleet usage factor considered in the evaluation.", new DoubleValue(0)));
263      Parameters.Add(new ValueParameter<DoubleValue>("EvalDistanceFactor", "The distance factor considered in the evaluation.", new DoubleValue(1)));
264
265      evaluator = Evaluator;
266      AttachEventHandlers();
267    }
268
269    protected VRPProblemInstance(VRPProblemInstance original, Cloner cloner)
270      : base(original, cloner) {
271      evaluator = Evaluator;
272      AttachEventHandlers();
273    }
274
275    [StorableHook(HookType.AfterDeserialization)]
276    private void AfterDeserialization() {
277      evaluator = Evaluator;
278      AttachEventHandlers();
279    }
280
281    private void AttachEventHandlers() {
282      CoordinatesParameter.ValueChanged += CoordinatesParameter_ValueChanged;
283      Coordinates.Reset += Coordinates_Changed;
284      Coordinates.ItemChanged += Coordinates_Changed;
285      DemandParameter.ValueChanged += DemandParameter_ValueChanged;
286      Demand.Reset += Demand_Changed;
287      Demand.ItemChanged += Demand_Changed;
288      VehiclesParameter.ValueChanged += VehiclesParameter_ValueChanged;
289      VehiclesParameter.Value.ValueChanged += Vehicles_Changed;
290      DistanceFactorParameter.ValueChanged += DistanceFactorParameter_ValueChanged;
291      DistanceFactorParameter.Value.ValueChanged += DistanceFactor_ValueChanged;
292      FleetUsageFactorParameter.ValueChanged += FleetUsageFactorParameter_ValueChanged;
293      FleetUsageFactorParameter.Value.ValueChanged += FleetUsageFactor_ValueChanged;
294      DistanceMatrixParameter.ValueChanged += DistanceMatrixParameter_ValueChanged;
295      if (DistanceMatrix != null) {
296        DistanceMatrix.ItemChanged += DistanceMatrix_ItemChanged;
297        DistanceMatrix.Reset += DistanceMatrix_Reset;
298      }
299      UseDistanceMatrixParameter.ValueChanged += UseDistanceMatrixParameter_ValueChanged;
300      UseDistanceMatrix.ValueChanged += UseDistanceMatrix_ValueChanged;
301    }
302
303    public virtual void InitializeState() {
304    }
305
306    public virtual void ClearState() {
307    }
308
309    #region Event handlers
310    private void CoordinatesParameter_ValueChanged(object sender, EventArgs e) {
311      if (distanceMatrix != null) distanceMatrix = null;
312      if (DistanceMatrix != null && DistanceMatrix.Rows != Coordinates.Rows) DistanceMatrix = null;
313      Coordinates.Reset += Coordinates_Changed;
314      Coordinates.ItemChanged += Coordinates_Changed;
315      EvalBestKnownSolution();
316    }
317    private void Coordinates_Changed(object sender, EventArgs e) {
318      if (distanceMatrix != null) distanceMatrix = null;
319      if (DistanceMatrix != null && DistanceMatrix.Rows != Coordinates.Rows) DistanceMatrix = null;
320      EvalBestKnownSolution();
321    }
322    private void DemandParameter_ValueChanged(object sender, EventArgs e) {
323      Demand.Reset += Demand_Changed;
324      Demand.ItemChanged += Demand_Changed;
325      EvalBestKnownSolution();
326    }
327    private void Demand_Changed(object sender, EventArgs e) {
328      EvalBestKnownSolution();
329    }
330    private void VehiclesParameter_ValueChanged(object sender, EventArgs e) {
331      Vehicles.ValueChanged += Vehicles_Changed;
332      EvalBestKnownSolution();
333    }
334    private void Vehicles_Changed(object sender, EventArgs e) {
335      EvalBestKnownSolution();
336    }
337    void DistanceFactorParameter_ValueChanged(object sender, EventArgs e) {
338      DistanceFactorParameter.Value.ValueChanged += DistanceFactor_ValueChanged;
339      EvalBestKnownSolution();
340    }
341    void DistanceFactor_ValueChanged(object sender, EventArgs e) {
342      EvalBestKnownSolution();
343    }
344    void FleetUsageFactorParameter_ValueChanged(object sender, EventArgs e) {
345      FleetUsageFactorParameter.Value.ValueChanged += FleetUsageFactor_ValueChanged;
346      EvalBestKnownSolution();
347    }
348    void FleetUsageFactor_ValueChanged(object sender, EventArgs e) {
349      EvalBestKnownSolution();
350    }
351    void DistanceMatrixParameter_ValueChanged(object sender, EventArgs e) {
352      if (DistanceMatrix != null) {
353        DistanceMatrix.ItemChanged += DistanceMatrix_ItemChanged;
354        DistanceMatrix.Reset += DistanceMatrix_Reset;
355      }
356      distanceMatrix = DistanceMatrix;
357      EvalBestKnownSolution();
358    }
359    void DistanceMatrix_Reset(object sender, EventArgs e) {
360      EvalBestKnownSolution();
361    }
362    void DistanceMatrix_ItemChanged(object sender, EventArgs<int, int> e) {
363      distanceMatrix = DistanceMatrix;
364      EvalBestKnownSolution();
365    }
366    void UseDistanceMatrixParameter_ValueChanged(object sender, EventArgs e) {
367      UseDistanceMatrix.ValueChanged += UseDistanceMatrix_ValueChanged;
368      if (!UseDistanceMatrix.Value)
369        distanceMatrix = null;
370      EvalBestKnownSolution();
371    }
372    void UseDistanceMatrix_ValueChanged(object sender, EventArgs e) {
373      if (!UseDistanceMatrix.Value)
374        distanceMatrix = null;
375      EvalBestKnownSolution();
376    }
377    #endregion
378  }
379}
Note: See TracBrowser for help on using the repository browser.