Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs @ 6938

Last change on this file since 6938 was 6938, checked in by abeham, 13 years ago

#1663

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