Free cookie consent management tool by TermsFeed Policy Generator

source: branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs @ 8322

Last change on this file since 8322 was 8322, checked in by jkarder, 12 years ago

#1331:
File size: 32.5 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2012 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.Optimization;
29using HeuristicLab.Parameters;
30using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
31using HeuristicLab.PluginInfrastructure;
32using HeuristicLab.Problems.VehicleRouting.Encodings.Alba;
33using HeuristicLab.Problems.VehicleRouting.Encodings.General;
34using HeuristicLab.Problems.VehicleRouting.Encodings.Prins;
35
36namespace HeuristicLab.Problems.VehicleRouting {
37  [Item("Vehicle Routing Problem", "Represents a Vehicle Routing Problem.")]
38  [StorableClass]
39  public sealed class VehicleRoutingProblem : SingleObjectiveHeuristicOptimizationProblem<IVRPEvaluator, IVRPCreator>, IStorableContent {
40    public string Filename { get; set; }
41
42    #region Parameter Properties
43    public ValueParameter<DoubleMatrix> CoordinatesParameter {
44      get { return (ValueParameter<DoubleMatrix>)Parameters["Coordinates"]; }
45    }
46    public OptionalValueParameter<DoubleMatrix> DistanceMatrixParameter {
47      get { return (OptionalValueParameter<DoubleMatrix>)Parameters["DistanceMatrix"]; }
48    }
49    public ValueParameter<BoolValue> UseDistanceMatrixParameter {
50      get { return (ValueParameter<BoolValue>)Parameters["UseDistanceMatrix"]; }
51    }
52    public ValueParameter<IntValue> VehiclesParameter {
53      get { return (ValueParameter<IntValue>)Parameters["Vehicles"]; }
54    }
55    public ValueParameter<DoubleValue> CapacityParameter {
56      get { return (ValueParameter<DoubleValue>)Parameters["Capacity"]; }
57    }
58    public ValueParameter<DoubleArray> DemandParameter {
59      get { return (ValueParameter<DoubleArray>)Parameters["Demand"]; }
60    }
61    public ValueParameter<DoubleArray> ReadyTimeParameter {
62      get { return (ValueParameter<DoubleArray>)Parameters["ReadyTime"]; }
63    }
64    public ValueParameter<DoubleArray> DueTimeParameter {
65      get { return (ValueParameter<DoubleArray>)Parameters["DueTime"]; }
66    }
67    public ValueParameter<DoubleArray> ServiceTimeParameter {
68      get { return (ValueParameter<DoubleArray>)Parameters["ServiceTime"]; }
69    }
70    public IValueParameter<DoubleValue> FleetUsageFactorParameter {
71      get { return (IValueParameter<DoubleValue>)Parameters["EvalFleetUsageFactor"]; }
72    }
73    public IValueParameter<DoubleValue> TimeFactorParameter {
74      get { return (IValueParameter<DoubleValue>)Parameters["EvalTimeFactor"]; }
75    }
76    public IValueParameter<DoubleValue> DistanceFactorParameter {
77      get { return (IValueParameter<DoubleValue>)Parameters["EvalDistanceFactor"]; }
78    }
79    public IValueParameter<DoubleValue> OverloadPenaltyParameter {
80      get { return (IValueParameter<DoubleValue>)Parameters["EvalOverloadPenalty"]; }
81    }
82    public IValueParameter<DoubleValue> TardinessPenaltyParameter {
83      get { return (IValueParameter<DoubleValue>)Parameters["EvalTardinessPenalty"]; }
84    }
85    public OptionalValueParameter<IVRPEncoding> BestKnownSolutionParameter {
86      get { return (OptionalValueParameter<IVRPEncoding>)Parameters["BestKnownSolution"]; }
87    }
88    #endregion
89
90    #region Properties
91    public DoubleMatrix Coordinates {
92      get { return CoordinatesParameter.Value; }
93      set { CoordinatesParameter.Value = value; }
94    }
95    public DoubleMatrix DistanceMatrix {
96      get { return DistanceMatrixParameter.Value; }
97      set { DistanceMatrixParameter.Value = value; }
98    }
99    public BoolValue UseDistanceMatrix {
100      get { return UseDistanceMatrixParameter.Value; }
101      set { UseDistanceMatrixParameter.Value = value; }
102    }
103    public IntValue Vehicles {
104      get { return VehiclesParameter.Value; }
105      set { VehiclesParameter.Value = value; }
106    }
107    public DoubleValue Capacity {
108      get { return CapacityParameter.Value; }
109      set { CapacityParameter.Value = value; }
110    }
111    public DoubleArray Demand {
112      get { return DemandParameter.Value; }
113      set { DemandParameter.Value = value; }
114    }
115    public DoubleArray ReadyTime {
116      get { return ReadyTimeParameter.Value; }
117      set { ReadyTimeParameter.Value = value; }
118    }
119    public DoubleArray DueTime {
120      get { return DueTimeParameter.Value; }
121      set { DueTimeParameter.Value = value; }
122    }
123    public DoubleArray ServiceTime {
124      get { return ServiceTimeParameter.Value; }
125      set { ServiceTimeParameter.Value = value; }
126    }
127    public IVRPEncoding BestKnownSolution {
128      get { return BestKnownSolutionParameter.Value; }
129      set { BestKnownSolutionParameter.Value = value; }
130    }
131    private BestVRPSolutionAnalyzer BestVRPSolutionAnalyzer {
132      get { return Operators.OfType<BestVRPSolutionAnalyzer>().FirstOrDefault(); }
133    }
134    private BestAverageWorstVRPToursAnalyzer BestAverageWorstVRPToursAnalyzer {
135      get { return Operators.OfType<BestAverageWorstVRPToursAnalyzer>().FirstOrDefault(); }
136    }
137    #endregion
138
139    // BackwardsCompatibility3.3
140    #region Backwards compatible code, remove with 3.4
141    [Obsolete]
142    [Storable(Name = "operators")]
143    private IEnumerable<IOperator> oldOperators {
144      get { return null; }
145      set {
146        if (value != null && value.Any())
147          Operators.AddRange(value);
148      }
149    }
150    #endregion
151
152    [StorableConstructor]
153    private VehicleRoutingProblem(bool deserializing) : base(deserializing) { }
154    private VehicleRoutingProblem(VehicleRoutingProblem original, Cloner cloner)
155      : base(original, cloner) {
156      RegisterEventHandlers();
157    }
158    public VehicleRoutingProblem()
159      : base(new VRPEvaluator(), new RandomCreator()) {
160      Parameters.Add(new ValueParameter<DoubleMatrix>("Coordinates", "The x- and y-Coordinates of the cities.", new DoubleMatrix()));
161      Parameters.Add(new OptionalValueParameter<DoubleMatrix>("DistanceMatrix", "The matrix which contains the distances between the cities."));
162      Parameters.Add(new ValueParameter<BoolValue>("UseDistanceMatrix", "True if a distance matrix should be calculated and used for evaluation, otherwise false.", new BoolValue(true)));
163      Parameters.Add(new ValueParameter<IntValue>("Vehicles", "The number of vehicles.", new IntValue(0)));
164      Parameters.Add(new ValueParameter<DoubleValue>("Capacity", "The capacity of each vehicle.", new DoubleValue(0)));
165      Parameters.Add(new ValueParameter<DoubleArray>("Demand", "The demand of each customer.", new DoubleArray()));
166      Parameters.Add(new ValueParameter<DoubleArray>("ReadyTime", "The ready time of each customer.", new DoubleArray()));
167      Parameters.Add(new ValueParameter<DoubleArray>("DueTime", "The due time of each customer.", new DoubleArray()));
168      Parameters.Add(new ValueParameter<DoubleArray>("ServiceTime", "The service time of each customer.", new DoubleArray()));
169      Parameters.Add(new OptionalValueParameter<IVRPEncoding>("BestKnownSolution", "The best known solution of this VRP instance."));
170      Parameters.Add(new ValueParameter<DoubleValue>("EvalFleetUsageFactor", "The fleet usage factor considered in the evaluation.", new DoubleValue(100)));
171      Parameters.Add(new ValueParameter<DoubleValue>("EvalTimeFactor", "The time factor considered in the evaluation.", new DoubleValue(0)));
172      Parameters.Add(new ValueParameter<DoubleValue>("EvalDistanceFactor", "The distance factor considered in the evaluation.", new DoubleValue(1)));
173      Parameters.Add(new ValueParameter<DoubleValue>("EvalOverloadPenalty", "The overload penalty considered in the evaluation.", new DoubleValue(100)));
174      Parameters.Add(new ValueParameter<DoubleValue>("EvalTardinessPenalty", "The tardiness penalty considered in the evaluation.", new DoubleValue(100)));
175
176      Maximization.Value = false;
177      MaximizationParameter.Hidden = true;
178
179      SolutionCreator.VRPToursParameter.ActualName = "VRPTours";
180      Evaluator.QualityParameter.ActualName = "VRPQuality";
181
182      InitializeRandomVRPInstance();
183
184      ParameterizeSolutionCreator();
185      ParameterizeEvaluator();
186
187      InitializeOperators();
188      RegisterEventHandlers();
189    }
190
191    public override IDeepCloneable Clone(Cloner cloner) {
192      return new VehicleRoutingProblem(this, cloner);
193    }
194
195    #region Events
196    protected override void OnSolutionCreatorChanged() {
197      base.OnSolutionCreatorChanged();
198      ParameterizeSolutionCreator();
199      ParameterizeEvaluator();
200      ParameterizeAnalyzer();
201      ParameterizeOperators();
202    }
203    protected override void OnEvaluatorChanged() {
204      base.OnEvaluatorChanged();
205      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
206      ParameterizeEvaluator();
207      UpdateMoveEvaluators();
208      ParameterizeAnalyzer();
209    }
210    private void VehiclesValue_ValueChanged(object sender, EventArgs e) {
211      ParameterizeSolutionCreator();
212    }
213    private void CoordinatesParameter_ValueChanged(object sender, EventArgs e) {
214      Coordinates.ItemChanged += new EventHandler<EventArgs<int, int>>(Coordinates_ItemChanged);
215      Coordinates.Reset += new EventHandler(Coordinates_Reset);
216      ParameterizeSolutionCreator();
217      ClearDistanceMatrix();
218
219      BestKnownSolution = null;
220    }
221    private void Coordinates_ItemChanged(object sender, EventArgs<int, int> e) {
222      ClearDistanceMatrix();
223
224      BestKnownSolution = null;
225    }
226    private void Coordinates_Reset(object sender, EventArgs e) {
227      ParameterizeSolutionCreator();
228      ClearDistanceMatrix();
229
230      BestKnownSolution = null;
231    }
232    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
233      ParameterizeAnalyzer();
234    }
235
236    void DistanceFactor_ValueChanged(object sender, EventArgs e) {
237      DistanceFactorParameter.Value.ValueChanged += new EventHandler(DistanceFactorValue_ValueChanged);
238      EvalBestKnownSolution();
239    }
240    void DistanceFactorValue_ValueChanged(object sender, EventArgs e) {
241      EvalBestKnownSolution();
242    }
243    void FleetUsageFactor_ValueChanged(object sender, EventArgs e) {
244      FleetUsageFactorParameter.Value.ValueChanged += new EventHandler(FleetUsageFactorValue_ValueChanged);
245      EvalBestKnownSolution();
246    }
247    void FleetUsageFactorValue_ValueChanged(object sender, EventArgs e) {
248      EvalBestKnownSolution();
249    }
250    void OverloadPenalty_ValueChanged(object sender, EventArgs e) {
251      OverloadPenaltyParameter.Value.ValueChanged += new EventHandler(OverloadPenaltyValue_ValueChanged);
252      EvalBestKnownSolution();
253    }
254    void OverloadPenaltyValue_ValueChanged(object sender, EventArgs e) {
255      EvalBestKnownSolution();
256    }
257    void TardinessPenalty_ValueChanged(object sender, EventArgs e) {
258      TardinessPenaltyParameter.Value.ValueChanged += new EventHandler(TardinessPenaltyValue_ValueChanged);
259      EvalBestKnownSolution();
260    }
261    void TardinessPenaltyValue_ValueChanged(object sender, EventArgs e) {
262      EvalBestKnownSolution();
263    }
264    void TimeFactor_ValueChanged(object sender, EventArgs e) {
265      TimeFactorParameter.Value.ValueChanged += new EventHandler(TimeFactorValue_ValueChanged);
266      EvalBestKnownSolution();
267    }
268    void TimeFactorValue_ValueChanged(object sender, EventArgs e) {
269      EvalBestKnownSolution();
270    }
271    void DistanceMatrixParameter_ValueChanged(object sender, EventArgs e) {
272      if (DistanceMatrix != null) {
273        DistanceMatrix.ItemChanged += new EventHandler<EventArgs<int, int>>(DistanceMatrix_ItemChanged);
274        DistanceMatrix.Reset += new EventHandler(DistanceMatrix_Reset);
275      }
276      EvalBestKnownSolution();
277    }
278    void DistanceMatrix_Reset(object sender, EventArgs e) {
279      EvalBestKnownSolution();
280    }
281    void DistanceMatrix_ItemChanged(object sender, EventArgs<int, int> e) {
282      EvalBestKnownSolution();
283    }
284    void UseDistanceMatrixParameter_ValueChanged(object sender, EventArgs e) {
285      UseDistanceMatrix.ValueChanged += new EventHandler(UseDistanceMatrix_ValueChanged);
286      EvalBestKnownSolution();
287    }
288    void UseDistanceMatrix_ValueChanged(object sender, EventArgs e) {
289      EvalBestKnownSolution();
290    }
291    void CapacityParameter_ValueChanged(object sender, EventArgs e) {
292      Capacity.ValueChanged += new EventHandler(Capacity_ValueChanged);
293      BestKnownSolution = null;
294    }
295    void Capacity_ValueChanged(object sender, EventArgs e) {
296      BestKnownSolution = null;
297    }
298    void DemandParameter_ValueChanged(object sender, EventArgs e) {
299      Demand.ItemChanged += new EventHandler<EventArgs<int>>(Demand_ItemChanged);
300      Demand.Reset += new EventHandler(Demand_Reset);
301      BestKnownSolution = null;
302    }
303    void Demand_Reset(object sender, EventArgs e) {
304      BestKnownSolution = null;
305    }
306    void Demand_ItemChanged(object sender, EventArgs<int> e) {
307      BestKnownSolution = null;
308    }
309    void DueTimeParameter_ValueChanged(object sender, EventArgs e) {
310      DueTime.ItemChanged += new EventHandler<EventArgs<int>>(DueTime_ItemChanged);
311      DueTime.Reset += new EventHandler(DueTime_Reset);
312      BestKnownSolution = null;
313    }
314    void DueTime_Reset(object sender, EventArgs e) {
315      BestKnownSolution = null;
316    }
317    void DueTime_ItemChanged(object sender, EventArgs<int> e) {
318      BestKnownSolution = null;
319    }
320    void ReadyTimeParameter_ValueChanged(object sender, EventArgs e) {
321      ReadyTime.ItemChanged += new EventHandler<EventArgs<int>>(ReadyTime_ItemChanged);
322      ReadyTime.Reset += new EventHandler(ReadyTime_Reset);
323      BestKnownSolution = null;
324    }
325    void ReadyTime_Reset(object sender, EventArgs e) {
326      BestKnownSolution = null;
327    }
328    void ReadyTime_ItemChanged(object sender, EventArgs<int> e) {
329      BestKnownSolution = null;
330    }
331    void ServiceTimeParameter_ValueChanged(object sender, EventArgs e) {
332      ServiceTime.ItemChanged += new EventHandler<EventArgs<int>>(ServiceTime_ItemChanged);
333      ServiceTime.Reset += new EventHandler(ServiceTime_Reset);
334      BestKnownSolution = null;
335    }
336    void ServiceTime_Reset(object sender, EventArgs e) {
337      BestKnownSolution = null;
338    }
339    void ServiceTime_ItemChanged(object sender, EventArgs<int> e) {
340      BestKnownSolution = null;
341    }
342    void VehiclesParameter_ValueChanged(object sender, EventArgs e) {
343      Vehicles.ValueChanged += new EventHandler(Vehicles_ValueChanged);
344      BestKnownSolution = null;
345    }
346    void Vehicles_ValueChanged(object sender, EventArgs e) {
347      BestKnownSolution = null;
348    }
349    void BestKnownSolutionParameter_ValueChanged(object sender, EventArgs e) {
350      EvalBestKnownSolution();
351    }
352    #endregion
353
354    #region Helpers
355    [StorableHook(HookType.AfterDeserialization)]
356    private void AfterDeserialization() {
357      // BackwardsCompatibility3.3
358      #region Backwards compatible code, remove with 3.4
359      if (!Parameters.ContainsKey("BestKnownSolution")) {
360        Parameters.Add(new OptionalValueParameter<IVRPEncoding>("BestKnownSolution", "The best known solution of this TSP instance."));
361      }
362      #endregion
363
364      RegisterEventHandlers();
365    }
366
367    private void RegisterEventHandlers() {
368      CoordinatesParameter.ValueChanged += new EventHandler(CoordinatesParameter_ValueChanged);
369      Coordinates.ItemChanged += new EventHandler<EventArgs<int, int>>(Coordinates_ItemChanged);
370      Coordinates.Reset += new EventHandler(Coordinates_Reset);
371
372      Vehicles.ValueChanged += new EventHandler(VehiclesValue_ValueChanged);
373
374      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
375
376      DistanceFactorParameter.ValueChanged += new EventHandler(DistanceFactor_ValueChanged);
377      DistanceFactorParameter.Value.ValueChanged += new EventHandler(DistanceFactorValue_ValueChanged);
378      FleetUsageFactorParameter.ValueChanged += new EventHandler(FleetUsageFactor_ValueChanged);
379      FleetUsageFactorParameter.Value.ValueChanged += new EventHandler(FleetUsageFactorValue_ValueChanged);
380      OverloadPenaltyParameter.ValueChanged += new EventHandler(OverloadPenalty_ValueChanged);
381      OverloadPenaltyParameter.Value.ValueChanged += new EventHandler(OverloadPenaltyValue_ValueChanged);
382      TardinessPenaltyParameter.ValueChanged += new EventHandler(TardinessPenalty_ValueChanged);
383      TardinessPenaltyParameter.Value.ValueChanged += new EventHandler(TardinessPenaltyValue_ValueChanged);
384      TimeFactorParameter.ValueChanged += new EventHandler(TimeFactor_ValueChanged);
385      TimeFactorParameter.Value.ValueChanged += new EventHandler(TimeFactorValue_ValueChanged);
386
387      DistanceMatrixParameter.ValueChanged += new EventHandler(DistanceMatrixParameter_ValueChanged);
388      UseDistanceMatrixParameter.ValueChanged += new EventHandler(UseDistanceMatrixParameter_ValueChanged);
389      UseDistanceMatrix.ValueChanged += new EventHandler(UseDistanceMatrix_ValueChanged);
390
391      CapacityParameter.ValueChanged += new EventHandler(CapacityParameter_ValueChanged);
392      Capacity.ValueChanged += new EventHandler(Capacity_ValueChanged);
393      DemandParameter.ValueChanged += new EventHandler(DemandParameter_ValueChanged);
394      Demand.ItemChanged += new EventHandler<EventArgs<int>>(Demand_ItemChanged);
395      Demand.Reset += new EventHandler(Demand_Reset);
396      DueTimeParameter.ValueChanged += new EventHandler(DueTimeParameter_ValueChanged);
397      DueTime.ItemChanged += new EventHandler<EventArgs<int>>(DueTime_ItemChanged);
398      DueTime.Reset += new EventHandler(DueTime_Reset);
399      ReadyTimeParameter.ValueChanged += new EventHandler(ReadyTimeParameter_ValueChanged);
400      ReadyTime.ItemChanged += new EventHandler<EventArgs<int>>(ReadyTime_ItemChanged);
401      ReadyTime.Reset += new EventHandler(ReadyTime_Reset);
402      ServiceTimeParameter.ValueChanged += new EventHandler(ServiceTimeParameter_ValueChanged);
403      ServiceTime.ItemChanged += new EventHandler<EventArgs<int>>(ServiceTime_ItemChanged);
404      ServiceTime.Reset += new EventHandler(ServiceTime_Reset);
405      VehiclesParameter.ValueChanged += new EventHandler(VehiclesParameter_ValueChanged);
406      Vehicles.ValueChanged += new EventHandler(Vehicles_ValueChanged);
407
408      BestKnownSolutionParameter.ValueChanged += new EventHandler(BestKnownSolutionParameter_ValueChanged);
409    }
410
411    private void InitializeOperators() {
412      Operators.Add(new VRPImprovementOperator());
413      Operators.Add(new VRPPathRelinker());
414      Operators.Add(new VRPSimilarityCalculator());
415
416      Operators.Add(new BestVRPSolutionAnalyzer());
417      Operators.Add(new BestAverageWorstVRPToursAnalyzer());
418      ParameterizeAnalyzer();
419      Operators.AddRange(ApplicationManager.Manager.GetInstances<IVRPOperator>().Cast<IOperator>().OrderBy(op => op.Name));
420      ParameterizeOperators();
421      UpdateMoveEvaluators();
422    }
423    private void UpdateMoveEvaluators() {
424      ParameterizeOperators();
425      OnOperatorsChanged();
426    }
427    private void ParameterizeSolutionCreator() {
428      SolutionCreator.VehiclesParameter.ActualName = VehiclesParameter.Name;
429      SolutionCreator.CoordinatesParameter.ActualName = CoordinatesParameter.Name;
430      Evaluator.DistanceMatrixParameter.ActualName = DistanceMatrixParameter.Name;
431      Evaluator.UseDistanceMatrixParameter.ActualName = UseDistanceMatrixParameter.Name;
432      SolutionCreator.CapacityParameter.ActualName = CapacityParameter.Name;
433      SolutionCreator.DemandParameter.ActualName = DemandParameter.Name;
434      SolutionCreator.ReadyTimeParameter.ActualName = ReadyTimeParameter.Name;
435      SolutionCreator.DueTimeParameter.ActualName = DueTimeParameter.Name;
436      SolutionCreator.ServiceTimeParameter.ActualName = ServiceTimeParameter.Name;
437    }
438    private void ParameterizeEvaluator() {
439      Evaluator.VRPToursParameter.ActualName = SolutionCreator.VRPToursParameter.ActualName;
440      Evaluator.CoordinatesParameter.ActualName = CoordinatesParameter.Name;
441      Evaluator.DistanceMatrixParameter.ActualName = DistanceMatrixParameter.Name;
442      Evaluator.UseDistanceMatrixParameter.ActualName = UseDistanceMatrixParameter.Name;
443      Evaluator.VehiclesParameter.ActualName = VehiclesParameter.Name;
444      Evaluator.CapacityParameter.ActualName = CapacityParameter.Name;
445      Evaluator.DemandParameter.ActualName = DemandParameter.Name;
446      Evaluator.ReadyTimeParameter.ActualName = ReadyTimeParameter.Name;
447      Evaluator.DueTimeParameter.ActualName = DueTimeParameter.Name;
448      Evaluator.ServiceTimeParameter.ActualName = ServiceTimeParameter.Name;
449      Evaluator.FleetUsageFactor.ActualName = FleetUsageFactorParameter.Name;
450      Evaluator.TimeFactor.ActualName = TimeFactorParameter.Name;
451      Evaluator.DistanceFactor.ActualName = DistanceFactorParameter.Name;
452      Evaluator.OverloadPenalty.ActualName = OverloadPenaltyParameter.Name;
453      Evaluator.TardinessPenalty.ActualName = TardinessPenaltyParameter.Name;
454    }
455    private void ParameterizeAnalyzer() {
456      BestVRPSolutionAnalyzer.CoordinatesParameter.ActualName = CoordinatesParameter.Name;
457      BestVRPSolutionAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
458      BestVRPSolutionAnalyzer.DistanceParameter.ActualName = Evaluator.DistanceParameter.ActualName;
459      BestVRPSolutionAnalyzer.OverloadParameter.ActualName = Evaluator.OverloadParameter.ActualName;
460      BestVRPSolutionAnalyzer.TardinessParameter.ActualName = Evaluator.TardinessParameter.ActualName;
461      BestVRPSolutionAnalyzer.TravelTimeParameter.ActualName = Evaluator.TravelTimeParameter.ActualName;
462      BestVRPSolutionAnalyzer.VehiclesUtilizedParameter.ActualName = Evaluator.VehcilesUtilizedParameter.ActualName;
463      BestVRPSolutionAnalyzer.VRPToursParameter.ActualName = SolutionCreator.VRPToursParameter.ActualName;
464      BestVRPSolutionAnalyzer.ResultsParameter.ActualName = "Results";
465
466      BestAverageWorstVRPToursAnalyzer.DistanceParameter.ActualName = Evaluator.DistanceParameter.ActualName;
467      BestAverageWorstVRPToursAnalyzer.OverloadParameter.ActualName = Evaluator.OverloadParameter.ActualName;
468      BestAverageWorstVRPToursAnalyzer.TardinessParameter.ActualName = Evaluator.TardinessParameter.ActualName;
469      BestAverageWorstVRPToursAnalyzer.TravelTimeParameter.ActualName = Evaluator.TravelTimeParameter.ActualName;
470      BestAverageWorstVRPToursAnalyzer.VehiclesUtilizedParameter.ActualName = Evaluator.VehcilesUtilizedParameter.ActualName;
471      BestAverageWorstVRPToursAnalyzer.ResultsParameter.ActualName = "Results";
472    }
473    private void ParameterizeOperators() {
474      foreach (IVRPOperator op in Operators.OfType<IVRPOperator>()) {
475        if (op.CoordinatesParameter != null) op.CoordinatesParameter.ActualName = CoordinatesParameter.Name;
476        if (op.DistanceMatrixParameter != null) op.DistanceMatrixParameter.ActualName = DistanceMatrixParameter.Name;
477        if (op.UseDistanceMatrixParameter != null) op.UseDistanceMatrixParameter.ActualName = UseDistanceMatrixParameter.Name;
478        if (op.VehiclesParameter != null) op.VehiclesParameter.ActualName = VehiclesParameter.Name;
479        if (op.CapacityParameter != null) op.CapacityParameter.ActualName = CapacityParameter.Name;
480        if (op.DemandParameter != null) op.DemandParameter.ActualName = DemandParameter.Name;
481        if (op.ReadyTimeParameter != null) op.ReadyTimeParameter.ActualName = ReadyTimeParameter.Name;
482        if (op.DueTimeParameter != null) op.DueTimeParameter.ActualName = DueTimeParameter.Name;
483        if (op.ServiceTimeParameter != null) op.ServiceTimeParameter.ActualName = ServiceTimeParameter.Name;
484      }
485
486      foreach (IVRPMoveOperator op in Operators.OfType<IVRPMoveOperator>()) {
487        op.VRPToursParameter.ActualName = SolutionCreator.VRPToursParameter.ActualName;
488      }
489
490      foreach (IPrinsOperator op in Operators.OfType<IPrinsOperator>()) {
491        op.FleetUsageFactor.ActualName = FleetUsageFactorParameter.Name;
492        op.TimeFactor.ActualName = TimeFactorParameter.Name;
493        op.DistanceFactor.ActualName = DistanceFactorParameter.Name;
494        op.OverloadPenalty.ActualName = OverloadPenaltyParameter.Name;
495        op.TardinessPenalty.ActualName = TardinessPenaltyParameter.Name;
496      }
497
498      foreach (IVRPMoveEvaluator op in Operators.OfType<IVRPMoveEvaluator>()) {
499        op.FleetUsageFactor.ActualName = FleetUsageFactorParameter.Name;
500        op.TimeFactor.ActualName = TimeFactorParameter.Name;
501        op.DistanceFactor.ActualName = DistanceFactorParameter.Name;
502        op.OverloadPenalty.ActualName = OverloadPenaltyParameter.Name;
503        op.TardinessPenalty.ActualName = TardinessPenaltyParameter.Name;
504        op.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
505        op.VRPToursParameter.ActualName = SolutionCreator.VRPToursParameter.ActualName;
506      }
507      string translocationMove = Operators.OfType<IMoveGenerator>().OfType<IAlbaTranslocationMoveOperator>().First().TranslocationMoveParameter.ActualName;
508      foreach (IAlbaTranslocationMoveOperator op in Operators.OfType<IAlbaTranslocationMoveOperator>())
509        op.TranslocationMoveParameter.ActualName = translocationMove;
510
511      foreach (IVRPCrossover op in Operators.OfType<IVRPCrossover>()) {
512        op.ParentsParameter.ActualName = SolutionCreator.VRPToursParameter.ActualName;
513        op.ChildParameter.ActualName = SolutionCreator.VRPToursParameter.ActualName;
514      }
515
516      foreach (IVRPManipulator op in Operators.OfType<IVRPManipulator>()) {
517        op.VRPToursParameter.ActualName = SolutionCreator.VRPToursParameter.ActualName;
518      }
519
520      foreach (IVRPMultiNeighborhoodShakingOperator op in Operators.OfType<IVRPMultiNeighborhoodShakingOperator>()) {
521        op.VRPToursParameter.ActualName = SolutionCreator.VRPToursParameter.ActualName;
522      }
523      foreach (ISingleObjectiveImprovementOperator op in Operators.OfType<ISingleObjectiveImprovementOperator>()) {
524        op.SolutionParameter.ActualName = SolutionCreator.VRPToursParameter.ActualName;
525        op.SolutionParameter.Hidden = true;
526      }
527      foreach (ISingleObjectivePathRelinker op in Operators.OfType<ISingleObjectivePathRelinker>()) {
528        op.ParentsParameter.ActualName = SolutionCreator.VRPToursParameter.ActualName;
529        op.ParentsParameter.Hidden = true;
530      }
531      foreach (VRPSimilarityCalculator op in Operators.OfType<VRPSimilarityCalculator>()) {
532        op.SolutionVariableName = SolutionCreator.VRPToursParameter.ActualName;
533        op.QualityVariableName = Evaluator.QualityParameter.ActualName;
534      }
535    }
536    private void ClearDistanceMatrix() {
537      DistanceMatrixParameter.Value = null;
538    }
539    #endregion
540
541    public void ImportFromSolomon(string solomonFileName) {
542      SolomonParser parser = new SolomonParser(solomonFileName);
543      parser.Parse();
544
545      this.Name = parser.ProblemName;
546
547      BestKnownSolution = null;
548      Coordinates = new DoubleMatrix(parser.Coordinates);
549      Vehicles.Value = parser.Vehicles;
550      Capacity.Value = parser.Capacity;
551      Demand = new DoubleArray(parser.Demands);
552      ReadyTime = new DoubleArray(parser.Readytimes);
553      DueTime = new DoubleArray(parser.Duetimes);
554      ServiceTime = new DoubleArray(parser.Servicetimes);
555
556      OnReset();
557    }
558
559    public void ImportFromTSPLib(string tspFileName) {
560      TSPLIBParser parser = new TSPLIBParser(tspFileName);
561      parser.Parse();
562
563      this.Name = parser.Name;
564      int problemSize = parser.Demands.Length;
565
566      BestKnownSolution = null;
567      Coordinates = new DoubleMatrix(parser.Vertices);
568      if (parser.Vehicles != -1)
569        Vehicles.Value = parser.Vehicles;
570      else
571        Vehicles.Value = problemSize - 1;
572      Capacity.Value = parser.Capacity;
573      Demand = new DoubleArray(parser.Demands);
574      ReadyTime = new DoubleArray(problemSize);
575      DueTime = new DoubleArray(problemSize);
576      ServiceTime = new DoubleArray(problemSize);
577
578      for (int i = 0; i < problemSize; i++) {
579        ReadyTime[i] = 0;
580        DueTime[i] = int.MaxValue;
581        ServiceTime[i] = 0;
582      }
583
584      if (parser.Distance != -1) {
585        DueTime[0] = parser.Distance;
586      }
587
588      if (parser.Depot != 1)
589        ErrorHandling.ShowErrorDialog(new Exception("Invalid depot specification"));
590
591      if (parser.WeightType != TSPLIBParser.TSPLIBEdgeWeightType.EUC_2D)
592        ErrorHandling.ShowErrorDialog(new Exception("Invalid weight type"));
593
594      OnReset();
595    }
596
597    private void EvalBestKnownSolution() {
598      if (BestKnownSolution != null) {
599        //call evaluator
600        IValueParameter<DoubleMatrix> distMatrix = new ValueLookupParameter<DoubleMatrix>("DistMatrix",
601          DistanceMatrix);
602
603        TourEvaluation eval = VRPEvaluator.Evaluate(
604          BestKnownSolution,
605          Vehicles,
606          DueTime,
607          ServiceTime,
608          ReadyTime,
609          Demand,
610          Capacity,
611          FleetUsageFactorParameter.Value,
612          TimeFactorParameter.Value,
613          DistanceFactorParameter.Value,
614          OverloadPenaltyParameter.Value,
615          TardinessPenaltyParameter.Value,
616          Coordinates,
617          distMatrix,
618          UseDistanceMatrix);
619
620        DistanceMatrix = distMatrix.Value;
621
622        BestKnownQuality = new DoubleValue(eval.Quality);
623      } else {
624        BestKnownQuality = null;
625      }
626    }
627
628    public void ImportSolution(string solutionFileName) {
629      SolutionParser parser = new SolutionParser(solutionFileName);
630      parser.Parse();
631
632      HeuristicLab.Problems.VehicleRouting.Encodings.Potvin.PotvinEncoding encoding = new Encodings.Potvin.PotvinEncoding();
633
634      int cities = 0;
635      foreach (List<int> route in parser.Routes) {
636        Encodings.Tour tour = new Encodings.Tour();
637        tour.Cities.AddRange(route);
638        cities += tour.Cities.Count;
639
640        encoding.Tours.Add(tour);
641      }
642
643      if (cities != Coordinates.Rows - 1)
644        ErrorHandling.ShowErrorDialog(new Exception("The optimal solution does not seem to correspond  with the problem data."));
645      else
646        BestKnownSolutionParameter.Value = encoding;
647    }
648
649    public void ImportFromORLib(string orFileName) {
650      ORLIBParser parser = new ORLIBParser(orFileName);
651      parser.Parse();
652
653      this.Name = parser.Name;
654      int problemSize = parser.Demands.Length;
655
656      BestKnownSolution = null;
657      Coordinates = new DoubleMatrix(parser.Vertices);
658      Vehicles.Value = problemSize - 1;
659      Capacity.Value = parser.Capacity;
660      Demand = new DoubleArray(parser.Demands);
661      ReadyTime = new DoubleArray(problemSize);
662      DueTime = new DoubleArray(problemSize);
663      ServiceTime = new DoubleArray(problemSize);
664
665      ReadyTime[0] = 0;
666      DueTime[0] = parser.MaxRouteTime;
667      ServiceTime[0] = 0;
668
669      for (int i = 1; i < problemSize; i++) {
670        ReadyTime[i] = 0;
671        DueTime[i] = int.MaxValue;
672        ServiceTime[i] = parser.ServiceTime;
673      }
674
675      OnReset();
676    }
677
678    private void InitializeRandomVRPInstance() {
679      System.Random rand = new System.Random();
680
681      int cities = 100;
682
683      Coordinates = new DoubleMatrix(cities + 1, 2);
684      Demand = new DoubleArray(cities + 1);
685      DueTime = new DoubleArray(cities + 1);
686      ReadyTime = new DoubleArray(cities + 1);
687      ServiceTime = new DoubleArray(cities + 1);
688
689      Vehicles.Value = 100;
690      Capacity.Value = 200;
691
692      for (int i = 0; i <= cities; i++) {
693        Coordinates[i, 0] = rand.Next(0, 100);
694        Coordinates[i, 1] = rand.Next(0, 100);
695
696        if (i == 0) {
697          Demand[i] = 0;
698          DueTime[i] = Int16.MaxValue;
699          ReadyTime[i] = 0;
700          ServiceTime[i] = 0;
701        } else {
702          Demand[i] = rand.Next(10, 50);
703          DueTime[i] = rand.Next((int)Math.Ceiling(VRPUtilities.CalculateDistance(0, i, Coordinates)), 1200);
704          ReadyTime[i] = DueTime[i] - rand.Next(0, 100);
705          ServiceTime[i] = 90;
706        }
707      }
708    }
709  }
710}
Note: See TracBrowser for help on using the repository browser.