Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestAverageWorstVRPToursAnalyzer.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestAverageWorstVRPToursAnalyzer.cs (revision 4301)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestAverageWorstVRPToursAnalyzer.cs (revision 4301)
@@ -0,0 +1,354 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see .
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Analysis;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+ ///
+ /// An operator which analyzes the best, average and worst quality of solutions in the scope tree.
+ ///
+ [Item("BestAverageWorstVRPToursAnalyzer", "An operator which analyzes the best, average and worst properties of the VRP tours in the scope tree.")]
+ [StorableClass]
+ public sealed class BestAverageWorstVRPToursAnalyzer : AlgorithmOperator, IAnalyzer {
+ #region Parameter properties
+ public ScopeTreeLookupParameter OverloadParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["Overload"]; }
+ }
+ public ValueLookupParameter BestOverloadParameter {
+ get { return (ValueLookupParameter)Parameters["BestOverload"]; }
+ }
+ public ValueLookupParameter CurrentBestOverloadParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentBestOverload"]; }
+ }
+ public ValueLookupParameter CurrentAverageOverloadParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentAverageOverload"]; }
+ }
+ public ValueLookupParameter CurrentWorstOverloadParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentWorstOverload"]; }
+ }
+ public ValueLookupParameter OverloadsParameter {
+ get { return (ValueLookupParameter)Parameters["Overloads"]; }
+ }
+
+ public ScopeTreeLookupParameter TardinessParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["Tardiness"]; }
+ }
+ public ValueLookupParameter BestTardinessParameter {
+ get { return (ValueLookupParameter)Parameters["BestTardiness"]; }
+ }
+ public ValueLookupParameter CurrentBestTardinessParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentBestTardiness"]; }
+ }
+ public ValueLookupParameter CurrentAverageTardinessParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentAverageTardiness"]; }
+ }
+ public ValueLookupParameter CurrentWorstTardinessParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentWorstTardiness"]; }
+ }
+ public ValueLookupParameter TardinessValuesParameter {
+ get { return (ValueLookupParameter)Parameters["TardinessValues"]; }
+ }
+
+ public ScopeTreeLookupParameter DistanceParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["Distance"]; }
+ }
+ public ValueLookupParameter BestDistanceParameter {
+ get { return (ValueLookupParameter)Parameters["BestDistance"]; }
+ }
+ public ValueLookupParameter CurrentBestDistanceParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentBestDistance"]; }
+ }
+ public ValueLookupParameter CurrentAverageDistanceParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentAverageDistance"]; }
+ }
+ public ValueLookupParameter CurrentWorstDistanceParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentWorstDistance"]; }
+ }
+ public ValueLookupParameter DistancesParameter {
+ get { return (ValueLookupParameter)Parameters["Distances"]; }
+ }
+
+ public ScopeTreeLookupParameter TravelTimeParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["TravelTime"]; }
+ }
+ public ValueLookupParameter BestTravelTimeParameter {
+ get { return (ValueLookupParameter)Parameters["BestTravelTime"]; }
+ }
+ public ValueLookupParameter CurrentBestTravelTimeParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentBestTravelTime"]; }
+ }
+ public ValueLookupParameter CurrentAverageTravelTimeParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentAverageTravelTime"]; }
+ }
+ public ValueLookupParameter CurrentWorstTravelTimeParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentWorstTravelTime"]; }
+ }
+ public ValueLookupParameter TravelTimesParameter {
+ get { return (ValueLookupParameter)Parameters["TravelTimes"]; }
+ }
+
+ public ScopeTreeLookupParameter VehiclesUtilizedParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["VehiclesUtilized"]; }
+ }
+ public ValueLookupParameter BestVehiclesUtilizedParameter {
+ get { return (ValueLookupParameter)Parameters["BestVehiclesUtilized"]; }
+ }
+ public ValueLookupParameter CurrentBestVehiclesUtilizedParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentBestVehiclesUtilized"]; }
+ }
+ public ValueLookupParameter CurrentAverageVehiclesUtilizedParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentAverageVehiclesUtilized"]; }
+ }
+ public ValueLookupParameter CurrentWorstVehiclesUtilizedParameter {
+ get { return (ValueLookupParameter)Parameters["CurrentWorstVehiclesUtilized"]; }
+ }
+ public ValueLookupParameter VehiclesUtilizedValuesParameter {
+ get { return (ValueLookupParameter)Parameters["VehiclesUtilizedValues"]; }
+ }
+
+ public ValueLookupParameter ResultsParameter {
+ get { return (ValueLookupParameter)Parameters["Results"]; }
+ }
+ #endregion
+
+ #region Properties
+ private BestVRPToursMemorizer BestMemorizer {
+ get { return (BestVRPToursMemorizer)OperatorGraph.InitialOperator; }
+ }
+ private BestAverageWorstVRPToursCalculator BestAverageWorstCalculator {
+ get { return (BestAverageWorstVRPToursCalculator)BestMemorizer.Successor; }
+ }
+ #endregion
+
+ public BestAverageWorstVRPToursAnalyzer()
+ : base() {
+ #region Create parameters
+ Parameters.Add(new ScopeTreeLookupParameter("Overload", "The overloads of the VRP solutions which should be analyzed."));
+ Parameters.Add(new ValueLookupParameter("BestOverload", "The best overload value."));
+ Parameters.Add(new ValueLookupParameter("CurrentBestOverload", "The current best overload value."));
+ Parameters.Add(new ValueLookupParameter("CurrentAverageOverload", "The current average overload value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("CurrentWorstOverload", "The current worst overload value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("Overloads", "The data table to store the current best, current average, current worst, best and best known overload value."));
+
+ Parameters.Add(new ScopeTreeLookupParameter("Tardiness", "The tardiness of the VRP solutions which should be analyzed."));
+ Parameters.Add(new ValueLookupParameter("BestTardiness", "The best tardiness value."));
+ Parameters.Add(new ValueLookupParameter("CurrentBestTardiness", "The current best tardiness value."));
+ Parameters.Add(new ValueLookupParameter("CurrentAverageTardiness", "The current average tardiness value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("CurrentWorstTardiness", "The current worst tardiness value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("TardinessValues", "The data table to store the current best, current average, current worst, best and best known tardiness value."));
+
+ Parameters.Add(new ScopeTreeLookupParameter("Distance", "The distance of the VRP solutions which should be analyzed."));
+ Parameters.Add(new ValueLookupParameter("BestDistance", "The best distance value."));
+ Parameters.Add(new ValueLookupParameter("CurrentBestDistance", "The current best distance value."));
+ Parameters.Add(new ValueLookupParameter("CurrentAverageDistance", "The current average distance value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("CurrentWorstDistance", "The current worst distance value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("Distances", "The data table to store the current best, current average, current worst, best and best known distance value."));
+
+ Parameters.Add(new ScopeTreeLookupParameter("TravelTime", "The travel time of the VRP solutions which should be analyzed."));
+ Parameters.Add(new ValueLookupParameter("BestTravelTime", "The best travel time value."));
+ Parameters.Add(new ValueLookupParameter("CurrentBestTravelTime", "The current best travel time value."));
+ Parameters.Add(new ValueLookupParameter("CurrentAverageTravelTime", "The current average travel time value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("CurrentWorstTravelTime", "The current worst travel time value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("TravelTimes", "The data table to store the current best, current average, current worst, best and best known travel time value."));
+
+ Parameters.Add(new ScopeTreeLookupParameter("VehiclesUtilized", "The vehicles utilized of the VRP solutions which should be analyzed."));
+ Parameters.Add(new ValueLookupParameter("BestVehiclesUtilized", "The best vehicles utilized value."));
+ Parameters.Add(new ValueLookupParameter("CurrentBestVehiclesUtilized", "The current best vehicles utilized value."));
+ Parameters.Add(new ValueLookupParameter("CurrentAverageVehiclesUtilized", "The current average vehicles utilized value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("CurrentWorstVehiclesUtilized", "The current worst vehicles utilized value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("VehiclesUtilizedValues", "The data table to store the current best, current average, current worst, best and best known vehicles utilized value."));
+
+ Parameters.Add(new ValueLookupParameter("Results", "The results collection where the analysis values should be stored."));
+ #endregion
+
+ #region Create operators
+ BestVRPToursMemorizer bestMemorizer = new BestVRPToursMemorizer();
+ BestAverageWorstVRPToursCalculator calculator = new BestAverageWorstVRPToursCalculator();
+ ResultsCollector resultsCollector = new ResultsCollector();
+
+ //overload
+ bestMemorizer.BestOverloadParameter.ActualName = BestOverloadParameter.Name;
+ bestMemorizer.OverloadParameter.ActualName = OverloadParameter.Name;
+ bestMemorizer.OverloadParameter.Depth = OverloadParameter.Depth;
+
+ calculator.OverloadParameter.ActualName = OverloadParameter.Name;
+ calculator.OverloadParameter.Depth = OverloadParameter.Depth;
+ calculator.BestOverloadParameter.ActualName = CurrentBestOverloadParameter.Name;
+ calculator.AverageOverloadParameter.ActualName = CurrentAverageOverloadParameter.Name;
+ calculator.WorstOverloadParameter.ActualName = CurrentWorstOverloadParameter.Name;
+
+ DataTableValuesCollector overloadDataTablesCollector = new DataTableValuesCollector();
+ overloadDataTablesCollector.CollectedValues.Add(new LookupParameter("BestOverload", null, BestOverloadParameter.Name));
+ overloadDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentBestOverload", null, CurrentBestOverloadParameter.Name));
+ overloadDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentAverageOverload", null, CurrentAverageOverloadParameter.Name));
+ overloadDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentWorstOverload", null, CurrentWorstOverloadParameter.Name));
+ overloadDataTablesCollector.DataTableParameter.ActualName = OverloadsParameter.Name;
+
+ resultsCollector.CollectedValues.Add(new LookupParameter(OverloadsParameter.Name));
+ resultsCollector.CollectedValues.Add(new LookupParameter("BestOverload", null, BestOverloadParameter.Name));
+
+ //tardiness
+ bestMemorizer.BestTardinessParameter.ActualName = BestTardinessParameter.Name;
+ bestMemorizer.TardinessParameter.ActualName = TardinessParameter.Name;
+ bestMemorizer.TardinessParameter.Depth = TardinessParameter.Depth;
+
+ calculator.TardinessParameter.ActualName = TardinessParameter.Name;
+ calculator.TardinessParameter.Depth = TardinessParameter.Depth;
+ calculator.BestTardinessParameter.ActualName = CurrentBestTardinessParameter.Name;
+ calculator.AverageTardinessParameter.ActualName = CurrentAverageTardinessParameter.Name;
+ calculator.WorstTardinessParameter.ActualName = CurrentWorstTardinessParameter.Name;
+
+ DataTableValuesCollector tardinessDataTablesCollector = new DataTableValuesCollector();
+ tardinessDataTablesCollector.CollectedValues.Add(new LookupParameter("BestTardiness", null, BestTardinessParameter.Name));
+ tardinessDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentBestTardiness", null, CurrentBestTardinessParameter.Name));
+ tardinessDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentAverageTardiness", null, CurrentAverageTardinessParameter.Name));
+ tardinessDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentWorstTardiness", null, CurrentWorstTardinessParameter.Name));
+ tardinessDataTablesCollector.DataTableParameter.ActualName = TardinessValuesParameter.Name;
+
+ resultsCollector.CollectedValues.Add(new LookupParameter(TardinessValuesParameter.Name));
+ resultsCollector.CollectedValues.Add(new LookupParameter("BestTardiness", null, BestTardinessParameter.Name));
+
+ //Distance
+ bestMemorizer.BestDistanceParameter.ActualName = BestDistanceParameter.Name;
+ bestMemorizer.DistanceParameter.ActualName = DistanceParameter.Name;
+ bestMemorizer.DistanceParameter.Depth = DistanceParameter.Depth;
+
+ calculator.DistanceParameter.ActualName = DistanceParameter.Name;
+ calculator.DistanceParameter.Depth = DistanceParameter.Depth;
+ calculator.BestDistanceParameter.ActualName = CurrentBestDistanceParameter.Name;
+ calculator.AverageDistanceParameter.ActualName = CurrentAverageDistanceParameter.Name;
+ calculator.WorstDistanceParameter.ActualName = CurrentWorstDistanceParameter.Name;
+
+ DataTableValuesCollector distanceDataTablesCollector = new DataTableValuesCollector();
+ distanceDataTablesCollector.CollectedValues.Add(new LookupParameter("BestDistance", null, BestDistanceParameter.Name));
+ distanceDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentBestDistance", null, CurrentBestDistanceParameter.Name));
+ distanceDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentAverageDistance", null, CurrentAverageDistanceParameter.Name));
+ distanceDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentWorstDistance", null, CurrentWorstDistanceParameter.Name));
+ distanceDataTablesCollector.DataTableParameter.ActualName = DistancesParameter.Name;
+
+ resultsCollector.CollectedValues.Add(new LookupParameter(DistancesParameter.Name));
+ resultsCollector.CollectedValues.Add(new LookupParameter("BestDistance", null, BestDistanceParameter.Name));
+
+ //Travel Time
+ bestMemorizer.BestTravelTimeParameter.ActualName = BestTravelTimeParameter.Name;
+ bestMemorizer.TravelTimeParameter.ActualName = TravelTimeParameter.Name;
+ bestMemorizer.TravelTimeParameter.Depth = TravelTimeParameter.Depth;
+
+ calculator.TravelTimeParameter.ActualName = TravelTimeParameter.Name;
+ calculator.TravelTimeParameter.Depth = TravelTimeParameter.Depth;
+ calculator.BestTravelTimeParameter.ActualName = CurrentBestTravelTimeParameter.Name;
+ calculator.AverageTravelTimeParameter.ActualName = CurrentAverageTravelTimeParameter.Name;
+ calculator.WorstTravelTimeParameter.ActualName = CurrentWorstTravelTimeParameter.Name;
+
+ DataTableValuesCollector travelTimeDataTablesCollector = new DataTableValuesCollector();
+ travelTimeDataTablesCollector.CollectedValues.Add(new LookupParameter("BestTravelTime", null, BestTravelTimeParameter.Name));
+ travelTimeDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentBestTravelTime", null, CurrentBestTravelTimeParameter.Name));
+ travelTimeDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentAverageTravelTime", null, CurrentAverageTravelTimeParameter.Name));
+ travelTimeDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentWorstTravelTime", null, CurrentWorstTravelTimeParameter.Name));
+ travelTimeDataTablesCollector.DataTableParameter.ActualName = TravelTimesParameter.Name;
+
+ resultsCollector.CollectedValues.Add(new LookupParameter(TravelTimesParameter.Name));
+ resultsCollector.CollectedValues.Add(new LookupParameter("BestTravelTime", null, BestTravelTimeParameter.Name));
+
+ //Vehicles Utlized
+ bestMemorizer.BestVehiclesUtilizedParameter.ActualName = BestVehiclesUtilizedParameter.Name;
+ bestMemorizer.VehiclesUtilizedParameter.ActualName = VehiclesUtilizedParameter.Name;
+ bestMemorizer.VehiclesUtilizedParameter.Depth = VehiclesUtilizedParameter.Depth;
+
+ calculator.VehiclesUtilizedParameter.ActualName = VehiclesUtilizedParameter.Name;
+ calculator.VehiclesUtilizedParameter.Depth = VehiclesUtilizedParameter.Depth;
+ calculator.BestVehiclesUtilizedParameter.ActualName = CurrentBestVehiclesUtilizedParameter.Name;
+ calculator.AverageVehiclesUtilizedParameter.ActualName = CurrentAverageVehiclesUtilizedParameter.Name;
+ calculator.WorstVehiclesUtilizedParameter.ActualName = CurrentWorstVehiclesUtilizedParameter.Name;
+
+ DataTableValuesCollector vehiclesUtilizedDataTablesCollector = new DataTableValuesCollector();
+ vehiclesUtilizedDataTablesCollector.CollectedValues.Add(new LookupParameter("BestVehiclesUtilized", null, BestVehiclesUtilizedParameter.Name));
+ vehiclesUtilizedDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentBestVehiclesUtilized", null, CurrentBestVehiclesUtilizedParameter.Name));
+ vehiclesUtilizedDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentAverageVehiclesUtilized", null, CurrentAverageVehiclesUtilizedParameter.Name));
+ vehiclesUtilizedDataTablesCollector.CollectedValues.Add(new LookupParameter("CurrentWorstVehiclesUtilized", null, CurrentWorstVehiclesUtilizedParameter.Name));
+ vehiclesUtilizedDataTablesCollector.DataTableParameter.ActualName = VehiclesUtilizedValuesParameter.Name;
+
+ resultsCollector.CollectedValues.Add(new LookupParameter(VehiclesUtilizedValuesParameter.Name));
+ resultsCollector.CollectedValues.Add(new LookupParameter("BestVehiclesUtilized", null, BestVehiclesUtilizedParameter.Name));
+ #endregion
+
+ #region Create operator graph
+ OperatorGraph.InitialOperator = bestMemorizer;
+ bestMemorizer.Successor = calculator;
+ calculator.Successor = overloadDataTablesCollector;
+ overloadDataTablesCollector.Successor = tardinessDataTablesCollector;
+ tardinessDataTablesCollector.Successor = distanceDataTablesCollector;
+ distanceDataTablesCollector.Successor = travelTimeDataTablesCollector;
+ travelTimeDataTablesCollector.Successor = vehiclesUtilizedDataTablesCollector;
+ vehiclesUtilizedDataTablesCollector.Successor = resultsCollector;
+ resultsCollector.Successor = null;
+ #endregion
+
+ Initialize();
+ }
+ [StorableConstructor]
+ private BestAverageWorstVRPToursAnalyzer(bool deserializing) : base() { }
+
+ [StorableHook(HookType.AfterDeserialization)]
+ private void Initialize() {
+ OverloadParameter.DepthChanged += new EventHandler(OverloadParameter_DepthChanged);
+ TardinessParameter.DepthChanged += new EventHandler(TardinessParameter_DepthChanged);
+ DistanceParameter.DepthChanged += new EventHandler(DistanceParameter_DepthChanged);
+ TravelTimeParameter.DepthChanged += new EventHandler(TravelTimeParameter_DepthChanged);
+ VehiclesUtilizedParameter.DepthChanged += new EventHandler(VehiclesUtilizedParameter_DepthChanged);
+ }
+
+ public override IDeepCloneable Clone(Cloner cloner) {
+ BestAverageWorstVRPToursAnalyzer clone = (BestAverageWorstVRPToursAnalyzer)base.Clone(cloner);
+ clone.Initialize();
+ return clone;
+ }
+
+ void OverloadParameter_DepthChanged(object sender, EventArgs e) {
+ BestAverageWorstCalculator.OverloadParameter.Depth = OverloadParameter.Depth;
+ }
+
+ void TardinessParameter_DepthChanged(object sender, EventArgs e) {
+ BestAverageWorstCalculator.TardinessParameter.Depth = TardinessParameter.Depth;
+ }
+
+ void DistanceParameter_DepthChanged(object sender, EventArgs e) {
+ BestAverageWorstCalculator.DistanceParameter.Depth = DistanceParameter.Depth;
+ }
+
+ void TravelTimeParameter_DepthChanged(object sender, EventArgs e) {
+ BestAverageWorstCalculator.TravelTimeParameter.Depth = TravelTimeParameter.Depth;
+ }
+
+ void VehiclesUtilizedParameter_DepthChanged(object sender, EventArgs e) {
+ BestAverageWorstCalculator.VehiclesUtilizedParameter.Depth = VehiclesUtilizedParameter.Depth;
+ }
+ }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestAverageWorstVRPToursCalculator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestAverageWorstVRPToursCalculator.cs (revision 4301)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestAverageWorstVRPToursCalculator.cs (revision 4301)
@@ -0,0 +1,245 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see .
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+ [Item("BestAverageWorstVRPToursCalculator", "An operator which calculates the current best, average and worst properties of VRP tours in the scope tree.")]
+ [StorableClass]
+ public sealed class BestAverageWorstVRPToursCalculator : SingleSuccessorOperator {
+ public ScopeTreeLookupParameter OverloadParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["Overload"]; }
+ }
+ public ValueLookupParameter BestOverloadParameter {
+ get { return (ValueLookupParameter)Parameters["BestOverload"]; }
+ }
+ public ValueLookupParameter AverageOverloadParameter {
+ get { return (ValueLookupParameter)Parameters["AverageOverload"]; }
+ }
+ public ValueLookupParameter WorstOverloadParameter {
+ get { return (ValueLookupParameter)Parameters["WorstOverload"]; }
+ }
+
+ public ScopeTreeLookupParameter TardinessParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["Tardiness"]; }
+ }
+ public ValueLookupParameter BestTardinessParameter {
+ get { return (ValueLookupParameter)Parameters["BestTardiness"]; }
+ }
+ public ValueLookupParameter AverageTardinessParameter {
+ get { return (ValueLookupParameter)Parameters["AverageTardiness"]; }
+ }
+ public ValueLookupParameter WorstTardinessParameter {
+ get { return (ValueLookupParameter)Parameters["WorstTardiness"]; }
+ }
+
+ public ScopeTreeLookupParameter DistanceParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["Distance"]; }
+ }
+ public ValueLookupParameter BestDistanceParameter {
+ get { return (ValueLookupParameter)Parameters["BestDistance"]; }
+ }
+ public ValueLookupParameter AverageDistanceParameter {
+ get { return (ValueLookupParameter)Parameters["AverageDistance"]; }
+ }
+ public ValueLookupParameter WorstDistanceParameter {
+ get { return (ValueLookupParameter)Parameters["WorstDistance"]; }
+ }
+
+ public ScopeTreeLookupParameter TravelTimeParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["TravelTime"]; }
+ }
+ public ValueLookupParameter BestTravelTimeParameter {
+ get { return (ValueLookupParameter)Parameters["BestTravelTime"]; }
+ }
+ public ValueLookupParameter AverageTravelTimeParameter {
+ get { return (ValueLookupParameter)Parameters["AverageTravelTime"]; }
+ }
+ public ValueLookupParameter WorstTravelTimeParameter {
+ get { return (ValueLookupParameter)Parameters["WorstTravelTime"]; }
+ }
+
+ public ScopeTreeLookupParameter VehiclesUtilizedParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["VehiclesUtilized"]; }
+ }
+ public ValueLookupParameter BestVehiclesUtilizedParameter {
+ get { return (ValueLookupParameter)Parameters["BestVehiclesUtilized"]; }
+ }
+ public ValueLookupParameter AverageVehiclesUtilizedParameter {
+ get { return (ValueLookupParameter)Parameters["AverageVehiclesUtilized"]; }
+ }
+ public ValueLookupParameter WorstVehiclesUtilizedParameter {
+ get { return (ValueLookupParameter)Parameters["WorstVehiclesUtilized"]; }
+ }
+
+ public BestAverageWorstVRPToursCalculator()
+ : base() {
+ Parameters.Add(new ScopeTreeLookupParameter("Distance", "The distances of the VRP solutions which should be analyzed."));
+ Parameters.Add(new ValueLookupParameter("BestDistance", "The best distance value."));
+ Parameters.Add(new ValueLookupParameter("AverageDistance", "The average distance value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("WorstDistance", "The worst distance value of all solutions."));
+
+ Parameters.Add(new ScopeTreeLookupParameter("Overload", "The overloads of the VRP solutions which should be analyzed."));
+ Parameters.Add(new ValueLookupParameter("BestOverload", "The best overload value."));
+ Parameters.Add(new ValueLookupParameter("AverageOverload", "The average overload value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("WorstOverload", "The worst overload value of all solutions."));
+
+ Parameters.Add(new ScopeTreeLookupParameter("Tardiness", "The tardiness of the VRP solutions which should be analyzed."));
+ Parameters.Add(new ValueLookupParameter("BestTardiness", "The best tardiness value."));
+ Parameters.Add(new ValueLookupParameter("AverageTardiness", "The average tardiness value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("WorstTardiness", "The worst tardiness value of all solutions."));
+
+ Parameters.Add(new ScopeTreeLookupParameter("TravelTime", "The travel times of the VRP solutions which should be analyzed."));
+ Parameters.Add(new ValueLookupParameter("BestTravelTime", "The best travel time value."));
+ Parameters.Add(new ValueLookupParameter("AverageTravelTime", "The average travel time value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("WorstTravelTime", "The worst travel time value of all solutions."));
+
+ Parameters.Add(new ScopeTreeLookupParameter("VehiclesUtilized", "The utilized vehicles of the VRP solutions which should be analyzed."));
+ Parameters.Add(new ValueLookupParameter("BestVehiclesUtilized", "The best utilized vehicles value."));
+ Parameters.Add(new ValueLookupParameter("AverageVehiclesUtilized", "The average utilized vehicles value of all solutions."));
+ Parameters.Add(new ValueLookupParameter("WorstVehiclesUtilized", "The worst utilized vehicles value of all solutions."));
+ }
+
+ private void UpdateOverloads() {
+ ItemArray overloads = OverloadParameter.ActualValue;
+ if (overloads.Length > 0) {
+ double min = double.MaxValue, max = double.MinValue, sum = 0.0;
+ for (int i = 0; i < overloads.Length; i++) {
+ if (overloads[i].Value < min) min = overloads[i].Value;
+ if (overloads[i].Value > max) max = overloads[i].Value;
+ sum += overloads[i].Value;
+ }
+
+ DoubleValue best = BestOverloadParameter.ActualValue;
+ if (best == null) BestOverloadParameter.ActualValue = new DoubleValue(min);
+ else best.Value = min;
+ DoubleValue average = AverageOverloadParameter.ActualValue;
+ if (average == null) AverageOverloadParameter.ActualValue = new DoubleValue(sum / overloads.Length);
+ else average.Value = sum / overloads.Length;
+ DoubleValue worst = WorstOverloadParameter.ActualValue;
+ if (worst == null) WorstOverloadParameter.ActualValue = new DoubleValue(max);
+ else worst.Value = max;
+ }
+ }
+
+ private void UpdateTardiness() {
+ ItemArray tardiness = TardinessParameter.ActualValue;
+ if (tardiness.Length > 0) {
+ double min = double.MaxValue, max = double.MinValue, sum = 0.0;
+ for (int i = 0; i < tardiness.Length; i++) {
+ if (tardiness[i].Value < min) min = tardiness[i].Value;
+ if (tardiness[i].Value > max) max = tardiness[i].Value;
+ sum += tardiness[i].Value;
+ }
+
+ DoubleValue best = BestTardinessParameter.ActualValue;
+ if (best == null) BestTardinessParameter.ActualValue = new DoubleValue(min);
+ else best.Value = min;
+ DoubleValue average = AverageTardinessParameter.ActualValue;
+ if (average == null) AverageTardinessParameter.ActualValue = new DoubleValue(sum / tardiness.Length);
+ else average.Value = sum / tardiness.Length;
+ DoubleValue worst = WorstTardinessParameter.ActualValue;
+ if (worst == null) WorstTardinessParameter.ActualValue = new DoubleValue(max);
+ else worst.Value = max;
+ }
+ }
+
+ private void UpdateDistances() {
+ ItemArray distances = DistanceParameter.ActualValue;
+ if (distances.Length > 0) {
+ double min = double.MaxValue, max = double.MinValue, sum = 0.0;
+ for (int i = 0; i < distances.Length; i++) {
+ if (distances[i].Value < min) min = distances[i].Value;
+ if (distances[i].Value > max) max = distances[i].Value;
+ sum += distances[i].Value;
+ }
+
+ DoubleValue best = BestDistanceParameter.ActualValue;
+ if (best == null) BestDistanceParameter.ActualValue = new DoubleValue(min);
+ else best.Value = min;
+ DoubleValue average = AverageDistanceParameter.ActualValue;
+ if (average == null) AverageDistanceParameter.ActualValue = new DoubleValue(sum / distances.Length);
+ else average.Value = sum / distances.Length;
+ DoubleValue worst = WorstDistanceParameter.ActualValue;
+ if (worst == null) WorstDistanceParameter.ActualValue = new DoubleValue(max);
+ else worst.Value = max;
+ }
+ }
+
+ private void UpdateTravelTimes() {
+ ItemArray travelTimes = TravelTimeParameter.ActualValue;
+ if (travelTimes.Length > 0) {
+ double min = double.MaxValue, max = double.MinValue, sum = 0.0;
+ for (int i = 0; i < travelTimes.Length; i++) {
+ if (travelTimes[i].Value < min) min = travelTimes[i].Value;
+ if (travelTimes[i].Value > max) max = travelTimes[i].Value;
+ sum += travelTimes[i].Value;
+ }
+
+ DoubleValue best = BestTravelTimeParameter.ActualValue;
+ if (best == null) BestTravelTimeParameter.ActualValue = new DoubleValue(min);
+ else best.Value = min;
+ DoubleValue average = AverageTravelTimeParameter.ActualValue;
+ if (average == null) AverageTravelTimeParameter.ActualValue = new DoubleValue(sum / travelTimes.Length);
+ else average.Value = sum / travelTimes.Length;
+ DoubleValue worst = WorstTravelTimeParameter.ActualValue;
+ if (worst == null) WorstTravelTimeParameter.ActualValue = new DoubleValue(max);
+ else worst.Value = max;
+ }
+ }
+
+ private void UpdateVehiclesUtilized() {
+ ItemArray vehiclesUtilized = VehiclesUtilizedParameter.ActualValue;
+ if (vehiclesUtilized.Length > 0) {
+ double min = double.MaxValue, max = double.MinValue, sum = 0.0;
+ for (int i = 0; i < vehiclesUtilized.Length; i++) {
+ if (vehiclesUtilized[i].Value < min) min = vehiclesUtilized[i].Value;
+ if (vehiclesUtilized[i].Value > max) max = vehiclesUtilized[i].Value;
+ sum += vehiclesUtilized[i].Value;
+ }
+
+ DoubleValue best = BestVehiclesUtilizedParameter.ActualValue;
+ if (best == null) BestVehiclesUtilizedParameter.ActualValue = new DoubleValue(min);
+ else best.Value = min;
+ DoubleValue average = AverageVehiclesUtilizedParameter.ActualValue;
+ if (average == null) AverageVehiclesUtilizedParameter.ActualValue = new DoubleValue(sum / vehiclesUtilized.Length);
+ else average.Value = sum / vehiclesUtilized.Length;
+ DoubleValue worst = WorstVehiclesUtilizedParameter.ActualValue;
+ if (worst == null) WorstVehiclesUtilizedParameter.ActualValue = new DoubleValue(max);
+ else worst.Value = max;
+ }
+ }
+
+ public override IOperation Apply() {
+ UpdateOverloads();
+ UpdateTardiness();
+ UpdateDistances();
+ UpdateTravelTimes();
+ UpdateVehiclesUtilized();
+
+ return base.Apply();
+ }
+ }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestVRPSolutionAnalyzer.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestVRPSolutionAnalyzer.cs (revision 4300)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestVRPSolutionAnalyzer.cs (revision 4301)
@@ -127,20 +127,14 @@
BestSolutionParameter.ActualValue = solution;
results.Add(new Result("Best VRP Solution", solution));
-
- results.Add(new Result("Best TravelTime", new DoubleValue(travelTimes[i].Value)));
- results.Add(new Result("Best Distance", new DoubleValue(distances[i].Value)));
- results.Add(new Result("Best VehicleUtilization", new DoubleValue(vehiclesUtilizations[i].Value)));
- results.Add(new Result("Best Overload", new DoubleValue(overloads[i].Value)));
- results.Add(new Result("Best Tardiness", new DoubleValue(tardinesses[i].Value)));
} else {
- if (solution.Quality.Value > qualities[i].Value) {
+ if (qualities[i].Value <= solution.Quality.Value) {
solution.Coordinates = coordinates;
solution.Solution = best.Clone() as IVRPEncoding;
solution.Quality.Value = qualities[i].Value;
- solution.Distance.Value = (results["Best Distance"].Value as DoubleValue).Value = distances[i].Value;
- solution.Overload.Value = (results["Best Overload"].Value as DoubleValue).Value = overloads[i].Value;
- solution.Tardiness.Value = (results["Best Tardiness"].Value as DoubleValue).Value = tardinesses[i].Value;
- solution.TravelTime.Value = (results["Best TravelTime"].Value as DoubleValue).Value = travelTimes[i].Value;
- solution.VehicleUtilization.Value = (results["Best VehicleUtilization"].Value as DoubleValue).Value = vehiclesUtilizations[i].Value;
+ solution.Distance.Value = distances[i].Value;
+ solution.Overload.Value = overloads[i].Value;
+ solution.Tardiness.Value = tardinesses[i].Value;
+ solution.TravelTime.Value = travelTimes[i].Value;
+ solution.VehicleUtilization.Value = vehiclesUtilizations[i].Value;
solution.DistanceMatrix = DistanceMatrixParameter.ActualValue;
solution.UseDistanceMatrix = UseDistanceMatrixParameter.ActualValue;
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestVRPToursMemorizer.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestVRPToursMemorizer.cs (revision 4301)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestVRPToursMemorizer.cs (revision 4301)
@@ -0,0 +1,115 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see .
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+ [Item("BestVRPToursMemorizer", "An operator that updates the best VRP tour found so far in the scope three.")]
+ [StorableClass]
+ public class BestVRPToursMemorizer : SingleSuccessorOperator {
+ public ScopeTreeLookupParameter OverloadParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["Overload"]; }
+ }
+ public ScopeTreeLookupParameter TardinessParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["Tardiness"]; }
+ }
+ public ScopeTreeLookupParameter DistanceParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["Distance"]; }
+ }
+ public ScopeTreeLookupParameter TravelTimeParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["TravelTime"]; }
+ }
+ public ScopeTreeLookupParameter VehiclesUtilizedParameter {
+ get { return (ScopeTreeLookupParameter)Parameters["VehiclesUtilized"]; }
+ }
+
+ public ValueLookupParameter BestOverloadParameter {
+ get { return (ValueLookupParameter)Parameters["BestOverload"]; }
+ }
+ public ValueLookupParameter BestTardinessParameter {
+ get { return (ValueLookupParameter)Parameters["BestTardiness"]; }
+ }
+ public ValueLookupParameter BestDistanceParameter {
+ get { return (ValueLookupParameter)Parameters["BestDistance"]; }
+ }
+ public ValueLookupParameter BestTravelTimeParameter {
+ get { return (ValueLookupParameter)Parameters["BestTravelTime"]; }
+ }
+ public ValueLookupParameter BestVehiclesUtilizedParameter {
+ get { return (ValueLookupParameter)Parameters["BestVehiclesUtilized"]; }
+ }
+
+ public BestVRPToursMemorizer()
+ : base() {
+ Parameters.Add(new ScopeTreeLookupParameter("Distance", "The distances of the VRP solutions which should be analyzed."));
+ Parameters.Add(new ScopeTreeLookupParameter("Overload", "The overloads of the VRP solutions which should be analyzed."));
+ Parameters.Add(new ScopeTreeLookupParameter("Tardiness", "The tardiness of the VRP solutions which should be analyzed."));
+ Parameters.Add(new ScopeTreeLookupParameter("TravelTime", "The travel times of the VRP solutions which should be analyzed."));
+ Parameters.Add(new ScopeTreeLookupParameter("VehiclesUtilized", "The utilized vehicles of the VRP solutions which should be analyzed."));
+
+ Parameters.Add(new ValueLookupParameter("BestDistance", "The best distance found so far."));
+ Parameters.Add(new ValueLookupParameter("BestOverload", "The best overload found so far."));
+ Parameters.Add(new ValueLookupParameter("BestTardiness", "The best tardiness found so far."));
+ Parameters.Add(new ValueLookupParameter("BestTravelTime", "The best travel time found so far."));
+ Parameters.Add(new ValueLookupParameter("BestVehiclesUtilized", "The best vehicles utilized found so far."));
+
+ }
+
+ public override IOperation Apply() {
+ int i = OverloadParameter.ActualValue.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
+ if (BestOverloadParameter.ActualValue == null)
+ BestOverloadParameter.ActualValue = new DoubleValue(OverloadParameter.ActualValue[i].Value);
+ else if(OverloadParameter.ActualValue[i].Value <= BestOverloadParameter.ActualValue.Value)
+ BestOverloadParameter.ActualValue.Value = OverloadParameter.ActualValue[i].Value;
+
+ i = TardinessParameter.ActualValue.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
+ if (BestTardinessParameter.ActualValue == null)
+ BestTardinessParameter.ActualValue = new DoubleValue(TardinessParameter.ActualValue[i].Value);
+ else if (TardinessParameter.ActualValue[i].Value <= BestTardinessParameter.ActualValue.Value)
+ BestTardinessParameter.ActualValue.Value = TardinessParameter.ActualValue[i].Value;
+
+ i = DistanceParameter.ActualValue.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
+ if (BestDistanceParameter.ActualValue == null)
+ BestDistanceParameter.ActualValue = new DoubleValue(DistanceParameter.ActualValue[i].Value);
+ else if (DistanceParameter.ActualValue[i].Value <= BestDistanceParameter.ActualValue.Value)
+ BestDistanceParameter.ActualValue.Value = DistanceParameter.ActualValue[i].Value;
+
+ i = TravelTimeParameter.ActualValue.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
+ if (BestTravelTimeParameter.ActualValue == null)
+ BestTravelTimeParameter.ActualValue = new DoubleValue(TravelTimeParameter.ActualValue[i].Value);
+ else if (TravelTimeParameter.ActualValue[i].Value <= BestTravelTimeParameter.ActualValue.Value)
+ BestTravelTimeParameter.ActualValue.Value = TravelTimeParameter.ActualValue[i].Value;
+
+ i = VehiclesUtilizedParameter.ActualValue.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
+ if (BestVehiclesUtilizedParameter.ActualValue == null)
+ BestVehiclesUtilizedParameter.ActualValue = new DoubleValue(VehiclesUtilizedParameter.ActualValue[i].Value);
+ else if (VehiclesUtilizedParameter.ActualValue[i].Value <= BestVehiclesUtilizedParameter.ActualValue.Value)
+ BestVehiclesUtilizedParameter.ActualValue.Value = VehiclesUtilizedParameter.ActualValue[i].Value;
+
+ return base.Apply();
+ }
+ }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLab.Problems.VehicleRouting-3.3.csproj
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLab.Problems.VehicleRouting-3.3.csproj (revision 4300)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLab.Problems.VehicleRouting-3.3.csproj (revision 4301)
@@ -106,4 +106,7 @@
+
+
+
@@ -216,4 +219,8 @@
+
+ {887425B4-4348-49ED-A457-B7D2C26DDBF9}
+ HeuristicLab.Analysis-3.3
+
{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLabProblemsVehicleRoutingPlugin.cs.frame
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLabProblemsVehicleRoutingPlugin.cs.frame (revision 4300)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLabProblemsVehicleRoutingPlugin.cs.frame (revision 4301)
@@ -28,4 +28,5 @@
[Plugin("HeuristicLab.Problems.VehicleRouting", "3.3.0.$WCREV$")]
[PluginFile("HeuristicLab.Problems.VehicleRouting-3.3.dll", PluginFileType.Assembly)]
+ [PluginDependency("HeuristicLab.Analysis", "3.3")]
[PluginDependency("HeuristicLab.Collections", "3.3")]
[PluginDependency("HeuristicLab.Common", "3.3")]
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs (revision 4300)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs (revision 4301)
@@ -178,4 +178,7 @@
get { return operators.OfType().FirstOrDefault(); }
}
+ private BestAverageWorstVRPToursAnalyzer BestAverageWorstVRPToursAnalyzer {
+ get { return operators.OfType().FirstOrDefault(); }
+ }
#endregion
@@ -315,4 +318,5 @@
operators = new List();
operators.Add(new BestVRPSolutionAnalyzer());
+ operators.Add(new BestAverageWorstVRPToursAnalyzer());
ParameterizeAnalyzer();
operators.AddRange(ApplicationManager.Manager.GetInstances().Cast());
@@ -367,6 +371,15 @@
BestVRPSolutionAnalyzer.OverloadParameter.ActualName = Evaluator.OverloadParameter.ActualName;
BestVRPSolutionAnalyzer.TardinessParameter.ActualName = Evaluator.TardinessParameter.ActualName;
+ BestVRPSolutionAnalyzer.TravelTimeParameter.ActualName = Evaluator.TravelTimeParameter.ActualName;
+ BestVRPSolutionAnalyzer.VehiclesUtilizedParameter.ActualName = Evaluator.VehcilesUtilizedParameter.ActualName;
BestVRPSolutionAnalyzer.VRPToursParameter.ActualName = SolutionCreator.VRPToursParameter.ActualName;
BestVRPSolutionAnalyzer.ResultsParameter.ActualName = "Results";
+
+ BestAverageWorstVRPToursAnalyzer.DistanceParameter.ActualName = Evaluator.DistanceParameter.ActualName;
+ BestAverageWorstVRPToursAnalyzer.OverloadParameter.ActualName = Evaluator.OverloadParameter.ActualName;
+ BestAverageWorstVRPToursAnalyzer.TardinessParameter.ActualName = Evaluator.TardinessParameter.ActualName;
+ BestAverageWorstVRPToursAnalyzer.TravelTimeParameter.ActualName = Evaluator.TravelTimeParameter.ActualName;
+ BestAverageWorstVRPToursAnalyzer.VehiclesUtilizedParameter.ActualName = Evaluator.VehcilesUtilizedParameter.ActualName;
+ BestAverageWorstVRPToursAnalyzer.ResultsParameter.ActualName = "Results";
}
private void ParameterizeOperators() {