Index: branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/BasicTourAnalyzer.cs
===================================================================
--- branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/BasicTourAnalyzer.cs	(revision 17715)
+++ branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/BasicTourAnalyzer.cs	(revision 17715)
@@ -0,0 +1,119 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HEAL.Attic;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  /// <summary>
+  /// An operator which analyzes the best, average and worst quality of solutions in the scope tree.
+  /// </summary>
+  [Item("Basic Tour Analyzer", "An operator which analyzes the best, average and worst properties of the VRP tours in the scope tree.")]
+  [StorableType("5DF1280C-5FEB-451E-8132-168E515CF47D")]
+  public sealed class BasicVRPTourAnalyzer : InstrumentedOperator, IAnalyzer, IGeneralVRPOperator {
+    [Storable] public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter { get; private set; }
+    [Storable] public IScopeTreeLookupParameter<VRPEvaluation> EvaluationResultParameter { get; private set; }
+
+    [Storable] public IResultParameter<DataTable> DistancesResult { get; private set; }
+    [Storable] public IResultParameter<DataTable> VehiclesUtilizedResult { get; private set; }
+
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+
+    [StorableConstructor]
+    private BasicVRPTourAnalyzer(StorableConstructorFlag _) : base(_) { }
+    private BasicVRPTourAnalyzer(BasicVRPTourAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+      ProblemInstanceParameter = cloner.Clone(original.ProblemInstanceParameter);
+      EvaluationResultParameter = cloner.Clone(original.EvaluationResultParameter);
+      DistancesResult = cloner.Clone(original.DistancesResult);
+      VehiclesUtilizedResult = cloner.Clone(original.VehiclesUtilizedResult);
+    }
+    public BasicVRPTourAnalyzer()
+      : base() {
+      Parameters.Add(ProblemInstanceParameter = new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The problem instance."));
+      Parameters.Add(EvaluationResultParameter = new ScopeTreeLookupParameter<VRPEvaluation>("EvaluationResult", "The evaluations of the VRP solutions which should be analyzed."));
+      DataTable defaultDistanceTable = new DataTable("Distances"), defaultVehiclesUtilizedTable = new DataTable("Vehicles Utilized");
+      Parameters.Add(DistancesResult = new ResultParameter<DataTable>("Distances", "The solution distance progress in each iteration.", defaultDistanceTable));
+      Parameters.Add(VehiclesUtilizedResult = new ResultParameter<DataTable>("Vehicles Utilized", "The solution vehicle utilization progress in each iteration.", defaultVehiclesUtilizedTable));
+
+      defaultDistanceTable.Rows.Add(new DataRow("Best (monotonic)"));
+      defaultDistanceTable.Rows.Add(new DataRow("Best"));
+      defaultDistanceTable.Rows.Add(new DataRow("Average"));
+      defaultDistanceTable.Rows.Add(new DataRow("Worst"));
+
+      defaultVehiclesUtilizedTable.Rows.Add(new DataRow("Best (monotonic)"));
+      defaultVehiclesUtilizedTable.Rows.Add(new DataRow("Best"));
+      defaultVehiclesUtilizedTable.Rows.Add(new DataRow("Average"));
+      defaultVehiclesUtilizedTable.Rows.Add(new DataRow("Worst"));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BasicVRPTourAnalyzer(this, cloner);
+    }
+
+    public override IOperation InstrumentedApply() {
+      var evaluations = EvaluationResultParameter.ActualValue;
+      var distances = evaluations.Select(x => x.Distance);
+      var vehicles = evaluations.Select(x => (double)x.VehicleUtilization);
+
+      Analyze(distances, DistancesResult.ActualValue);
+      Analyze(vehicles, VehiclesUtilizedResult.ActualValue);
+
+      return base.InstrumentedApply();
+    }
+
+    internal static void Analyze(IEnumerable<double> sequence, DataTable table) {
+      var bestSoFar = table.Rows["Best (monotonic)"];
+      var best = table.Rows["Best"];
+      var average = table.Rows["Average"];
+      var worst = table.Rows["Worst"];
+
+      double min = double.MaxValue, max = double.MinValue, sum = 0.0;
+      double minmin = bestSoFar.Values.Count > 0 ? bestSoFar.Values.Last() : double.MaxValue;
+      int count = 0;
+
+      foreach (var s in sequence) {
+        if (min > s) min = s;
+        if (minmin > s) minmin = s;
+        if (max < s) max = s;
+        sum += s;
+        count++;
+      }
+
+      bestSoFar.Values.Add(minmin);
+      best.Values.Add(min);
+      average.Values.Add(sum / count);
+      worst.Values.Add(max);
+    }
+  }
+}
Index: branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/BestAverageWorstVRPToursAnalyzer.cs
===================================================================
--- branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/BestAverageWorstVRPToursAnalyzer.cs	(revision 17710)
+++ 	(revision )
@@ -1,208 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 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 <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using HeuristicLab.Analysis;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Optimization.Operators;
-using HeuristicLab.Parameters;
-using HEAL.Attic;
-using HeuristicLab.Problems.VehicleRouting.Interfaces;
-using HeuristicLab.Problems.VehicleRouting.Variants;
-
-namespace HeuristicLab.Problems.VehicleRouting {
-  /// <summary>
-  /// An operator which analyzes the best, average and worst quality of solutions in the scope tree.
-  /// </summary>
-  [Item("BestAverageWorstVRPToursAnalyzer", "An operator which analyzes the best, average and worst properties of the VRP tours in the scope tree.")]
-  [StorableType("5DF1280C-5FEB-451E-8132-168E515CF47D")]
-  public sealed class BestAverageWorstVRPToursAnalyzer : AlgorithmOperator, IAnalyzer, IGeneralVRPOperator {
-    #region Parameter properties
-    public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter {
-      get { return (ILookupParameter<IVRPProblemInstance>)Parameters["ProblemInstance"]; }
-    }
-    public ScopeTreeLookupParameter<DoubleValue> DistanceParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Distance"]; }
-    }
-    public ValueLookupParameter<DoubleValue> BestDistanceParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["BestDistance"]; }
-    }
-    public ValueLookupParameter<DoubleValue> CurrentBestDistanceParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["CurrentBestDistance"]; }
-    }
-    public ValueLookupParameter<DoubleValue> CurrentAverageDistanceParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["CurrentAverageDistance"]; }
-    }
-    public ValueLookupParameter<DoubleValue> CurrentWorstDistanceParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["CurrentWorstDistance"]; }
-    }
-    public ValueLookupParameter<DataTable> DistancesParameter {
-      get { return (ValueLookupParameter<DataTable>)Parameters["Distances"]; }
-    }
-
-    public ScopeTreeLookupParameter<DoubleValue> VehiclesUtilizedParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["VehiclesUtilized"]; }
-    }
-    public ValueLookupParameter<DoubleValue> BestVehiclesUtilizedParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["BestVehiclesUtilized"]; }
-    }
-    public ValueLookupParameter<DoubleValue> CurrentBestVehiclesUtilizedParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["CurrentBestVehiclesUtilized"]; }
-    }
-    public ValueLookupParameter<DoubleValue> CurrentAverageVehiclesUtilizedParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["CurrentAverageVehiclesUtilized"]; }
-    }
-    public ValueLookupParameter<DoubleValue> CurrentWorstVehiclesUtilizedParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["CurrentWorstVehiclesUtilized"]; }
-    }
-    public ValueLookupParameter<DataTable> VehiclesUtilizedValuesParameter {
-      get { return (ValueLookupParameter<DataTable>)Parameters["VehiclesUtilizedValues"]; }
-    }
-
-    public ValueLookupParameter<VariableCollection> ResultsParameter {
-      get { return (ValueLookupParameter<VariableCollection>)Parameters["Results"]; }
-    }
-    #endregion
-
-    #region Properties
-    public bool EnabledByDefault {
-      get { return true; }
-    }
-    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 LookupParameter<IVRPProblemInstance>("ProblemInstance", "The problem instance."));
-
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Distance", "The distance of the VRP solutions which should be analyzed."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestDistance", "The best distance value."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentBestDistance", "The current best distance value."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentAverageDistance", "The current average distance value of all solutions."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentWorstDistance", "The current worst distance value of all solutions."));
-      Parameters.Add(new ValueLookupParameter<DataTable>("Distances", "The data table to store the current best, current average, current worst, best and best known distance value."));
-
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("VehiclesUtilized", "The vehicles utilized of the VRP solutions which should be analyzed."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestVehiclesUtilized", "The best  vehicles utilized value."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentBestVehiclesUtilized", "The current best  vehicles utilized value."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentAverageVehiclesUtilized", "The current average  vehicles utilized value of all solutions."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentWorstVehiclesUtilized", "The current worst  vehicles utilized value of all solutions."));
-      Parameters.Add(new ValueLookupParameter<DataTable>("VehiclesUtilizedValues", "The data table to store the current best, current average, current worst, best and best known vehicles utilized value."));
-
-      Parameters.Add(new ValueLookupParameter<VariableCollection>("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();
-
-      //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<DoubleValue>("BestDistance", null, BestDistanceParameter.Name));
-      distanceDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentBestDistance", null, CurrentBestDistanceParameter.Name));
-      distanceDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentAverageDistance", null, CurrentAverageDistanceParameter.Name));
-      distanceDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentWorstDistance", null, CurrentWorstDistanceParameter.Name));
-      distanceDataTablesCollector.DataTableParameter.ActualName = DistancesParameter.Name;
-
-      resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(DistancesParameter.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<DoubleValue>("BestVehiclesUtilized", null, BestVehiclesUtilizedParameter.Name));
-      vehiclesUtilizedDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentBestVehiclesUtilized", null, CurrentBestVehiclesUtilizedParameter.Name));
-      vehiclesUtilizedDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentAverageVehiclesUtilized", null, CurrentAverageVehiclesUtilizedParameter.Name));
-      vehiclesUtilizedDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentWorstVehiclesUtilized", null, CurrentWorstVehiclesUtilizedParameter.Name));
-      vehiclesUtilizedDataTablesCollector.DataTableParameter.ActualName = VehiclesUtilizedValuesParameter.Name;
-
-      resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(VehiclesUtilizedValuesParameter.Name));
-      #endregion
-
-      #region Create operator graph
-      OperatorGraph.InitialOperator = bestMemorizer;
-      bestMemorizer.Successor = calculator;
-      calculator.Successor = distanceDataTablesCollector;
-      distanceDataTablesCollector.Successor = vehiclesUtilizedDataTablesCollector;
-      vehiclesUtilizedDataTablesCollector.Successor = resultsCollector;
-      resultsCollector.Successor = null;
-      #endregion
-
-      Initialize();
-    }
-    [StorableConstructor]
-    private BestAverageWorstVRPToursAnalyzer(StorableConstructorFlag _) : base(_) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new BestAverageWorstVRPToursAnalyzer(this, cloner);
-    }
-
-    private BestAverageWorstVRPToursAnalyzer(BestAverageWorstVRPToursAnalyzer original, Cloner cloner)
-      : base(original, cloner) {
-      this.Initialize();
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void Initialize() {
-      DistanceParameter.DepthChanged += new EventHandler(DistanceParameter_DepthChanged);
-      VehiclesUtilizedParameter.DepthChanged += new EventHandler(VehiclesUtilizedParameter_DepthChanged);
-    }
-
-    void DistanceParameter_DepthChanged(object sender, EventArgs e) {
-      BestAverageWorstCalculator.DistanceParameter.Depth = DistanceParameter.Depth;
-      BestMemorizer.DistanceParameter.Depth = DistanceParameter.Depth;
-    }
-
-    void VehiclesUtilizedParameter_DepthChanged(object sender, EventArgs e) {
-      BestAverageWorstCalculator.VehiclesUtilizedParameter.Depth = VehiclesUtilizedParameter.Depth;
-      BestMemorizer.VehiclesUtilizedParameter.Depth = DistanceParameter.Depth;
-    }
-  }
-}
Index: branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/BestAverageWorstVRPToursCalculator.cs
===================================================================
--- branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/BestAverageWorstVRPToursCalculator.cs	(revision 17710)
+++ 	(revision )
@@ -1,135 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 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 <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Operators;
-using HeuristicLab.Parameters;
-using HEAL.Attic;
-
-namespace HeuristicLab.Problems.VehicleRouting {
-  [Item("BestAverageWorstVRPToursCalculator", "An operator which calculates the current best, average and worst properties of VRP tours in the scope tree.")]
-  [StorableType("22DF27FC-17D0-4220-9B5D-C326DF47175C")]
-  public sealed class BestAverageWorstVRPToursCalculator : SingleSuccessorOperator {
-    public ScopeTreeLookupParameter<DoubleValue> DistanceParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Distance"]; }
-    }
-    public ValueLookupParameter<DoubleValue> BestDistanceParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["BestDistance"]; }
-    }
-    public ValueLookupParameter<DoubleValue> AverageDistanceParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["AverageDistance"]; }
-    }
-    public ValueLookupParameter<DoubleValue> WorstDistanceParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["WorstDistance"]; }
-    }
-
-    public ScopeTreeLookupParameter<DoubleValue> VehiclesUtilizedParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["VehiclesUtilized"]; }
-    }
-    public ValueLookupParameter<DoubleValue> BestVehiclesUtilizedParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["BestVehiclesUtilized"]; }
-    }
-    public ValueLookupParameter<DoubleValue> AverageVehiclesUtilizedParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["AverageVehiclesUtilized"]; }
-    }
-    public ValueLookupParameter<DoubleValue> WorstVehiclesUtilizedParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["WorstVehiclesUtilized"]; }
-    }
-
-    public BestAverageWorstVRPToursCalculator()
-      : base() {
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Distance", "The distances of the VRP solutions which should be analyzed."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestDistance", "The best distance value."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("AverageDistance", "The average distance value of all solutions."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("WorstDistance", "The worst distance value of all solutions."));
-
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("VehiclesUtilized", "The utilized vehicles of the VRP solutions which should be analyzed."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestVehiclesUtilized", "The best utilized vehicles value."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("AverageVehiclesUtilized", "The average utilized vehicles value of all solutions."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("WorstVehiclesUtilized", "The worst utilized vehicles value of all solutions."));
-    }
-
-    [StorableConstructor]
-    private BestAverageWorstVRPToursCalculator(StorableConstructorFlag _) : base(_) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new BestAverageWorstVRPToursCalculator(this, cloner);
-    }
-
-    private BestAverageWorstVRPToursCalculator(BestAverageWorstVRPToursCalculator original, Cloner cloner)
-      : base(original, cloner) {
-    }
-
-    private void UpdateDistances() {
-      ItemArray<DoubleValue> 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 UpdateVehiclesUtilized() {
-      ItemArray<DoubleValue> 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() {
-      UpdateDistances();
-      UpdateVehiclesUtilized();
-
-      return base.Apply();
-    }
-  }
-}
Index: branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/BestVRPToursMemorizer.cs
===================================================================
--- branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/BestVRPToursMemorizer.cs	(revision 17710)
+++ 	(revision )
@@ -1,85 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 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 <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Operators;
-using HeuristicLab.Parameters;
-using HEAL.Attic;
-
-namespace HeuristicLab.Problems.VehicleRouting {
-  [Item("BestVRPToursMemorizer", "An operator that updates the best VRP tour found so far in the scope three.")]
-  [StorableType("3E5AF7DC-B85A-453B-8502-DC4FF45EE637")]
-  public class BestVRPToursMemorizer : SingleSuccessorOperator {
-    public ScopeTreeLookupParameter<DoubleValue> DistanceParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Distance"]; }
-    }
-    public ScopeTreeLookupParameter<DoubleValue> VehiclesUtilizedParameter {
-      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["VehiclesUtilized"]; }
-    }
-
-    public ValueLookupParameter<DoubleValue> BestDistanceParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["BestDistance"]; }
-    }
-    public ValueLookupParameter<DoubleValue> BestVehiclesUtilizedParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["BestVehiclesUtilized"]; }
-    }
-
-    public BestVRPToursMemorizer()
-      : base() {
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Distance", "The distances of the VRP solutions which should be analyzed."));
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("VehiclesUtilized", "The utilized vehicles of the VRP solutions which should be analyzed."));
-
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestDistance", "The best distance found so far."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestVehiclesUtilized", "The best vehicles utilized found so far."));
-
-    }
-
-    [StorableConstructor]
-    protected BestVRPToursMemorizer(StorableConstructorFlag _) : base(_) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new BestVRPToursMemorizer(this, cloner);
-    }
-
-    protected BestVRPToursMemorizer(BestVRPToursMemorizer original, Cloner cloner)
-      : base(original, cloner) {
-    }
-
-    public override IOperation Apply() {
-      int 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 = 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/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/CapacitatedTourAnalyzer.cs
===================================================================
--- branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/CapacitatedTourAnalyzer.cs	(revision 17715)
+++ branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/CapacitatedTourAnalyzer.cs	(revision 17715)
@@ -0,0 +1,84 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HEAL.Attic;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  /// <summary>
+  /// An operator which analyzes the best, average and worst quality of solutions in the scope tree.
+  /// </summary>
+  [Item("Capacitated Tour Analyzer", "An operator which analyzes the best, average and worst properties of the VRP tours in the scope tree.")]
+  [StorableType("5DF1280C-5FEB-451E-8132-168E515CF47D")]
+  public sealed class CapacitatedTourAnalyzer : InstrumentedOperator, IAnalyzer, ICapacitatedOperator {
+    [Storable] public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter { get; private set; }
+    [Storable] public IScopeTreeLookupParameter<CVRPEvaluation> EvaluationResultParameter { get; private set; }
+
+    [Storable] public IResultParameter<DataTable> OverloadResult { get; private set; }
+
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+
+    [StorableConstructor]
+    private CapacitatedTourAnalyzer(StorableConstructorFlag _) : base(_) { }
+    private CapacitatedTourAnalyzer(CapacitatedTourAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+      ProblemInstanceParameter = cloner.Clone(original.ProblemInstanceParameter);
+      EvaluationResultParameter = cloner.Clone(original.EvaluationResultParameter);
+      OverloadResult = cloner.Clone(original.OverloadResult);
+    }
+    public CapacitatedTourAnalyzer()
+      : base() {
+      Parameters.Add(ProblemInstanceParameter = new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The problem instance."));
+      Parameters.Add(EvaluationResultParameter = new ScopeTreeLookupParameter<CVRPEvaluation>("EvaluationResult", "The evaluations of the VRP solutions which should be analyzed."));
+      DataTable defaultOverloadTable = new DataTable("Overload");
+      Parameters.Add(OverloadResult = new ResultParameter<DataTable>("Overload", "The solution overload progress in each iteration.", defaultOverloadTable));
+
+      defaultOverloadTable.Rows.Add(new DataRow("Best (monotonic)"));
+      defaultOverloadTable.Rows.Add(new DataRow("Best"));
+      defaultOverloadTable.Rows.Add(new DataRow("Average"));
+      defaultOverloadTable.Rows.Add(new DataRow("Worst"));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CapacitatedTourAnalyzer(this, cloner);
+    }
+
+    public override IOperation InstrumentedApply() {
+      var evaluations = EvaluationResultParameter.ActualValue;
+      var overloads = evaluations.Select(x => x.Overload);
+
+      BasicVRPTourAnalyzer.Analyze(overloads, OverloadResult.ActualValue);
+
+      return base.InstrumentedApply();
+    }
+  }
+}
Index: branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/PickupAndDeliveryTourAnalyzer.cs
===================================================================
--- branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/PickupAndDeliveryTourAnalyzer.cs	(revision 17715)
+++ branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/PickupAndDeliveryTourAnalyzer.cs	(revision 17715)
@@ -0,0 +1,84 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HEAL.Attic;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  /// <summary>
+  /// An operator which analyzes the best, average and worst quality of solutions in the scope tree.
+  /// </summary>
+  [Item("Pickup & Delivery Tour Analyzer", "An operator which analyzes the best, average and worst properties of the VRP tours in the scope tree.")]
+  [StorableType("5DF1280C-5FEB-451E-8132-168E515CF47D")]
+  public sealed class PickupAndDeliveryTourAnalyzer : InstrumentedOperator, IAnalyzer, ICapacitatedOperator {
+    [Storable] public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter { get; private set; }
+    [Storable] public IScopeTreeLookupParameter<CVRPPDTWEvaluation> EvaluationResultParameter { get; private set; }
+
+    [Storable] public IResultParameter<DataTable> PickupViolationsResult { get; private set; }
+
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+
+    [StorableConstructor]
+    private PickupAndDeliveryTourAnalyzer(StorableConstructorFlag _) : base(_) { }
+    private PickupAndDeliveryTourAnalyzer(PickupAndDeliveryTourAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+      ProblemInstanceParameter = cloner.Clone(original.ProblemInstanceParameter);
+      EvaluationResultParameter = cloner.Clone(original.EvaluationResultParameter);
+      PickupViolationsResult = cloner.Clone(original.PickupViolationsResult);
+    }
+    public PickupAndDeliveryTourAnalyzer()
+      : base() {
+      Parameters.Add(ProblemInstanceParameter = new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The problem instance."));
+      Parameters.Add(EvaluationResultParameter = new ScopeTreeLookupParameter<CVRPPDTWEvaluation>("EvaluationResult", "The evaluations of the VRP solutions which should be analyzed."));
+      DataTable defaultPickupViolationsTable = new DataTable("Pickup Violations");
+      Parameters.Add(PickupViolationsResult = new ResultParameter<DataTable>("Pickup Violations", "The solution pickup violation progress in each iteration.", defaultPickupViolationsTable));
+
+      defaultPickupViolationsTable.Rows.Add(new DataRow("Best (monotonic)"));
+      defaultPickupViolationsTable.Rows.Add(new DataRow("Best"));
+      defaultPickupViolationsTable.Rows.Add(new DataRow("Average"));
+      defaultPickupViolationsTable.Rows.Add(new DataRow("Worst"));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PickupAndDeliveryTourAnalyzer(this, cloner);
+    }
+
+    public override IOperation InstrumentedApply() {
+      var evaluations = EvaluationResultParameter.ActualValue;
+      var pickupViolations = evaluations.Select(x => (double)x.PickupViolations);
+
+      BasicVRPTourAnalyzer.Analyze(pickupViolations, PickupViolationsResult.ActualValue);
+
+      return base.InstrumentedApply();
+    }
+  }
+}
Index: branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/TimeWindowTourAnalyzer.cs
===================================================================
--- branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/TimeWindowTourAnalyzer.cs	(revision 17715)
+++ branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/TimeWindowTourAnalyzer.cs	(revision 17715)
@@ -0,0 +1,94 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HEAL.Attic;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  /// <summary>
+  /// An operator which analyzes the best, average and worst quality of solutions in the scope tree.
+  /// </summary>
+  [Item("Time Window Tour Analyzer", "An operator which analyzes the best, average and worst properties of the VRP tours in the scope tree.")]
+  [StorableType("5DF1280C-5FEB-451E-8132-168E515CF47D")]
+  public sealed class TimeWindowTourAnalyzer : InstrumentedOperator, IAnalyzer, ITimeWindowedOperator {
+    [Storable] public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter { get; private set; }
+    [Storable] public IScopeTreeLookupParameter<CVRPTWEvaluation> EvaluationResultParameter { get; private set; }
+
+    [Storable] public IResultParameter<DataTable> TardinessResult { get; private set; }
+    [Storable] public IResultParameter<DataTable> TravelTimeResult { get; private set; }
+
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+
+    [StorableConstructor]
+    private TimeWindowTourAnalyzer(StorableConstructorFlag _) : base(_) { }
+    private TimeWindowTourAnalyzer(TimeWindowTourAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+      ProblemInstanceParameter = cloner.Clone(original.ProblemInstanceParameter);
+      EvaluationResultParameter = cloner.Clone(original.EvaluationResultParameter);
+      TardinessResult = cloner.Clone(original.TardinessResult);
+      TravelTimeResult = cloner.Clone(original.TravelTimeResult);
+    }
+    public TimeWindowTourAnalyzer()
+      : base() {
+      Parameters.Add(ProblemInstanceParameter = new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The problem instance."));
+      Parameters.Add(EvaluationResultParameter = new ScopeTreeLookupParameter<CVRPTWEvaluation>("EvaluationResult", "The evaluations of the VRP solutions which should be analyzed."));
+      DataTable defaultTardinessTable = new DataTable("Tardiness"), defaultTravelTimeTable = new DataTable("Travel Times");
+      Parameters.Add(TardinessResult = new ResultParameter<DataTable>("Tardiness", "The solution tardiness progress in each iteration.", defaultTardinessTable));
+      Parameters.Add(TravelTimeResult = new ResultParameter<DataTable>("Travel Times", "The solution travel time progress in each iteration.", defaultTravelTimeTable));
+
+      defaultTardinessTable.Rows.Add(new DataRow("Best (monotonic)"));
+      defaultTardinessTable.Rows.Add(new DataRow("Best"));
+      defaultTardinessTable.Rows.Add(new DataRow("Average"));
+      defaultTardinessTable.Rows.Add(new DataRow("Worst"));
+
+      defaultTravelTimeTable.Rows.Add(new DataRow("Best (monotonic)"));
+      defaultTravelTimeTable.Rows.Add(new DataRow("Best"));
+      defaultTravelTimeTable.Rows.Add(new DataRow("Average"));
+      defaultTravelTimeTable.Rows.Add(new DataRow("Worst"));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new TimeWindowTourAnalyzer(this, cloner);
+    }
+
+    public override IOperation InstrumentedApply() {
+      var evaluations = EvaluationResultParameter.ActualValue;
+      var tardiness = evaluations.Select(x => x.Tardiness);
+      var travelTimes = evaluations.Select(x => (double)x.TravelTime);
+
+      BasicVRPTourAnalyzer.Analyze(tardiness, TardinessResult.ActualValue);
+      BasicVRPTourAnalyzer.Analyze(travelTimes, TravelTimeResult.ActualValue);
+
+      return base.InstrumentedApply();
+    }
+  }
+}
Index: branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/ConstraintRelaxation/CapacityRelaxationVRPAnalyzer.cs
===================================================================
--- branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/ConstraintRelaxation/CapacityRelaxationVRPAnalyzer.cs	(revision 17715)
+++ branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/ConstraintRelaxation/CapacityRelaxationVRPAnalyzer.cs	(revision 17715)
@@ -0,0 +1,125 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HEAL.Attic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  /// <summary>
+  /// An operator for adaptive constraint relaxation.
+  /// </summary>
+  [Item("CapacityRelaxationVRPAnalyzer", "An operator for adaptively relaxing the capacity constraints.")]
+  [StorableType("02E519CA-7B71-4BBE-89A5-E630D1FEFC58")]
+  public class CapacityRelaxationVRPAnalyzer : SingleSuccessorOperator, IAnalyzer, ICapacitatedOperator, ISingleObjectiveOperator {
+    [Storable] public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter { get; private set; }
+    [Storable] public IScopeTreeLookupParameter<IVRPEncodedSolution> VRPToursParameter { get; private set; }
+    [Storable] public IScopeTreeLookupParameter<CVRPEvaluation> EvaluationResultParameter { get; private set; }
+
+    [Storable] public IValueParameter<DoubleValue> SigmaParameter { get; private set; }
+    [Storable] public IValueParameter<DoubleValue> PhiParameter { get; private set; }
+    [Storable] public IValueParameter<DoubleValue> MinPenaltyFactorParameter { get; private set; }
+    [Storable] public IValueParameter<DoubleValue> MaxPenaltyFactorParameter { get; private set; }
+
+    [Storable] public IResultParameter<DoubleValue> CurrentOverloadPenaltyResult { get; private set; }
+
+    public bool EnabledByDefault {
+      get { return false; }
+    }
+
+    [StorableConstructor]
+    protected CapacityRelaxationVRPAnalyzer(StorableConstructorFlag _) : base(_) { }
+    protected CapacityRelaxationVRPAnalyzer(CapacityRelaxationVRPAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+      ProblemInstanceParameter = cloner.Clone(original.ProblemInstanceParameter);
+      VRPToursParameter = cloner.Clone(original.VRPToursParameter);
+      EvaluationResultParameter = cloner.Clone(original.EvaluationResultParameter);
+      SigmaParameter = cloner.Clone(original.SigmaParameter);
+      PhiParameter = cloner.Clone(original.PhiParameter);
+      MinPenaltyFactorParameter = cloner.Clone(original.MinPenaltyFactorParameter);
+      MaxPenaltyFactorParameter = cloner.Clone(original.MaxPenaltyFactorParameter);
+      CurrentOverloadPenaltyResult = cloner.Clone(original.CurrentOverloadPenaltyResult);
+    }
+    public CapacityRelaxationVRPAnalyzer()
+      : base() {
+      Parameters.Add(ProblemInstanceParameter = new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The problem instance."));
+      Parameters.Add(VRPToursParameter = new ScopeTreeLookupParameter<IVRPEncodedSolution>("VRPTours", "The VRP tours which should be evaluated."));
+      Parameters.Add(EvaluationResultParameter = new ScopeTreeLookupParameter<CVRPEvaluation>("EvaluationResult", "The evaluations of the VRP solutions which should be analyzed."));
+
+      Parameters.Add(SigmaParameter = new ValueParameter<DoubleValue>("Sigma", "The sigma applied to the penalty factor.", new DoubleValue(0.5)));
+      Parameters.Add(PhiParameter = new ValueParameter<DoubleValue>("Phi", "The phi applied to the penalty factor.", new DoubleValue(0.5)));
+      Parameters.Add(MinPenaltyFactorParameter = new ValueParameter<DoubleValue>("MinPenaltyFactor", "The minimum penalty factor.", new DoubleValue(0.01)));
+      Parameters.Add(MaxPenaltyFactorParameter = new ValueParameter<DoubleValue>("MaxPenaltyFactor", "The maximum penalty factor.", new DoubleValue(100000)));
+      Parameters.Add(CurrentOverloadPenaltyResult = new ResultParameter<DoubleValue>("Current Overload Penalty", "The current penalty applied to exceeding the capacity constraint.", new DoubleValue(double.NaN)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CapacityRelaxationVRPAnalyzer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var cvrp = (ICapacitatedProblemInstance)ProblemInstanceParameter.ActualValue;
+  
+      ItemArray<CVRPEvaluation> evaluations = EvaluationResultParameter.ActualValue;
+
+      double sigma = SigmaParameter.Value.Value;
+      double phi = PhiParameter.Value.Value;
+      double minPenalty = MinPenaltyFactorParameter.Value.Value;
+      double maxPenalty = MaxPenaltyFactorParameter.Value.Value;
+
+      for (int j = 0; j < evaluations.Length; j++) {
+        evaluations[j].Quality -= evaluations[j].Overload * cvrp.OverloadPenalty.Value;
+      }
+
+      int validCount = 0;
+      for (int j = 0; j < evaluations.Length; j++) {
+        if (evaluations[j].Overload == 0)
+          validCount++;
+      }
+
+      double factor = 1.0 - ((double)validCount / (double)evaluations.Length);
+
+      double min = cvrp.OverloadPenalty.Value / (1 + sigma);
+      double max = cvrp.OverloadPenalty.Value * (1 + phi);
+
+      cvrp.CurrentOverloadPenalty = new DoubleValue(min + (max - min) * factor);
+      if (cvrp.CurrentOverloadPenalty.Value < minPenalty)
+        cvrp.CurrentOverloadPenalty.Value = minPenalty;
+      if (cvrp.CurrentOverloadPenalty.Value > maxPenalty)
+        cvrp.CurrentOverloadPenalty.Value = maxPenalty;
+
+      for (int j = 0; j < evaluations.Length; j++) {
+        evaluations[j].Quality += evaluations[j].Overload * cvrp.CurrentOverloadPenalty.Value;
+      }
+
+      CurrentOverloadPenaltyResult.ActualValue = new DoubleValue(cvrp.CurrentOverloadPenalty.Value);
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/ConstraintRelaxation/PickupViolationsRelaxationVRPAnalyzer.cs
===================================================================
--- branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/ConstraintRelaxation/PickupViolationsRelaxationVRPAnalyzer.cs	(revision 17715)
+++ branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/ConstraintRelaxation/PickupViolationsRelaxationVRPAnalyzer.cs	(revision 17715)
@@ -0,0 +1,126 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HEAL.Attic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  /// <summary>
+  /// An operator for adaptive constraint relaxation.
+  /// </summary>
+  [Item("PickupViolationsRelaxationVRPAnalyzer", "An operator for adaptively relaxing the pickup constraints.")]
+  [StorableType("86D541AB-5E65-432B-A8C4-F012A6B46275")]
+  public class PickupViolationsRelaxationVRPAnalyzer : SingleSuccessorOperator, IAnalyzer, IPickupAndDeliveryOperator, ISingleObjectiveOperator {
+    [Storable] public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter { get; private set; }
+    [Storable] public IScopeTreeLookupParameter<IVRPEncodedSolution> VRPToursParameter { get; private set; }
+    [Storable] public IScopeTreeLookupParameter<CVRPPDTWEvaluation> EvaluationResultParameter { get; private set; }
+
+    [Storable] public IValueParameter<DoubleValue> SigmaParameter { get; private set; }
+    [Storable] public IValueParameter<DoubleValue> PhiParameter { get; private set; }
+    [Storable] public IValueParameter<DoubleValue> MinPenaltyFactorParameter { get; private set; }
+    [Storable] public IValueParameter<DoubleValue> MaxPenaltyFactorParameter { get; private set; }
+
+    [Storable] public IResultParameter<DoubleValue> CurrentPickupViolationPenaltyResult { get; private set; }
+
+
+    public bool EnabledByDefault {
+      get { return false; }
+    }
+
+    [StorableConstructor]
+    protected PickupViolationsRelaxationVRPAnalyzer(StorableConstructorFlag _) : base(_) { }
+    protected PickupViolationsRelaxationVRPAnalyzer(PickupViolationsRelaxationVRPAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+      ProblemInstanceParameter = cloner.Clone(original.ProblemInstanceParameter);
+      VRPToursParameter = cloner.Clone(original.VRPToursParameter);
+      EvaluationResultParameter = cloner.Clone(original.EvaluationResultParameter);
+      SigmaParameter = cloner.Clone(original.SigmaParameter);
+      PhiParameter = cloner.Clone(original.PhiParameter);
+      MinPenaltyFactorParameter = cloner.Clone(original.MinPenaltyFactorParameter);
+      MaxPenaltyFactorParameter = cloner.Clone(original.MaxPenaltyFactorParameter);
+      CurrentPickupViolationPenaltyResult = cloner.Clone(original.CurrentPickupViolationPenaltyResult);
+    }
+    public PickupViolationsRelaxationVRPAnalyzer()
+      : base() {
+      Parameters.Add(ProblemInstanceParameter = new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The problem instance."));
+      Parameters.Add(VRPToursParameter = new ScopeTreeLookupParameter<IVRPEncodedSolution>("VRPTours", "The VRP tours which should be evaluated."));
+      Parameters.Add(EvaluationResultParameter = new ScopeTreeLookupParameter<CVRPPDTWEvaluation>("EvaluationResult", "The evaluations of the VRP solutions which should be analyzed."));
+
+      Parameters.Add(SigmaParameter = new ValueParameter<DoubleValue>("Sigma", "The sigma applied to the penalty factor.", new DoubleValue(0.5)));
+      Parameters.Add(PhiParameter = new ValueParameter<DoubleValue>("Phi", "The phi applied to the penalty factor.", new DoubleValue(0.5)));
+      Parameters.Add(MinPenaltyFactorParameter = new ValueParameter<DoubleValue>("MinPenaltyFactor", "The minimum penalty factor.", new DoubleValue(0.01)));
+      Parameters.Add(MaxPenaltyFactorParameter = new ValueParameter<DoubleValue>("MaxPenaltyFactor", "The maximum penalty factor.", new DoubleValue(100000)));
+      Parameters.Add(CurrentPickupViolationPenaltyResult = new ResultParameter<DoubleValue>("Current Pickup Violation Penalty", "The current penalty applied to violating pickup-dropoff precedence constraint.", new DoubleValue(double.NaN)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PickupViolationsRelaxationVRPAnalyzer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var pdp = (IPickupAndDeliveryProblemInstance)ProblemInstanceParameter.ActualValue;
+
+      ItemArray<CVRPPDTWEvaluation> evaluations = EvaluationResultParameter.ActualValue;
+
+      double sigma = SigmaParameter.Value.Value;
+      double phi = PhiParameter.Value.Value;
+      double minPenalty = MinPenaltyFactorParameter.Value.Value;
+      double maxPenalty = MaxPenaltyFactorParameter.Value.Value;
+
+      for (int j = 0; j < evaluations.Length; j++) {
+        evaluations[j].Quality -= evaluations[j].PickupViolations * pdp.PickupViolationPenalty.Value;
+      }
+
+      int validCount = 0;
+      for (int j = 0; j < evaluations.Length; j++) {
+        if (evaluations[j].PickupViolations == 0)
+          validCount++;
+      }
+
+      double factor = 1.0 - ((double)validCount / (double)evaluations.Length);
+
+      double min = pdp.PickupViolationPenalty.Value / (1 + sigma);
+      double max = pdp.PickupViolationPenalty.Value * (1 + phi);
+
+      pdp.CurrentPickupViolationPenalty = new DoubleValue(min + (max - min) * factor);
+      if (pdp.CurrentPickupViolationPenalty.Value < minPenalty)
+        pdp.CurrentPickupViolationPenalty.Value = minPenalty;
+      if (pdp.CurrentPickupViolationPenalty.Value > maxPenalty)
+        pdp.CurrentPickupViolationPenalty.Value = maxPenalty;
+
+      for (int j = 0; j < evaluations.Length; j++) {
+        evaluations[j].Quality += evaluations[j].PickupViolations * pdp.CurrentPickupViolationPenalty.Value;
+      }
+
+      CurrentPickupViolationPenaltyResult.ActualValue = new DoubleValue(pdp.CurrentPickupViolationPenalty.Value);
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/ConstraintRelaxation/TimeWindowRelaxationVRPAnalyzer.cs
===================================================================
--- branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/ConstraintRelaxation/TimeWindowRelaxationVRPAnalyzer.cs	(revision 17715)
+++ branches/2521_ProblemRefactoring/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/ConstraintRelaxation/TimeWindowRelaxationVRPAnalyzer.cs	(revision 17715)
@@ -0,0 +1,125 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HEAL.Attic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  /// <summary>
+  /// An operator for adaptive constraint relaxation.
+  /// </summary>
+  [Item("TimeWindowRelaxationVRPAnalyzer", "An operator for adaptively relaxing the time window constraints.")]
+  [StorableType("2CF57A00-547B-46E8-8B55-D626EB2D61DD")]
+  public class TimeWindowRelaxationVRPAnalyzer : SingleSuccessorOperator, IAnalyzer, ITimeWindowedOperator, ISingleObjectiveOperator {
+    [Storable] public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter { get; private set; }
+    [Storable] public IScopeTreeLookupParameter<IVRPEncodedSolution> VRPToursParameter { get; private set; }
+    [Storable] public IScopeTreeLookupParameter<CVRPTWEvaluation> EvaluationResultParameter { get; private set; }
+
+    [Storable] public IValueParameter<DoubleValue> SigmaParameter { get; private set; }
+    [Storable] public IValueParameter<DoubleValue> PhiParameter { get; private set; }
+    [Storable] public IValueParameter<DoubleValue> MinPenaltyFactorParameter { get; private set; }
+    [Storable] public IValueParameter<DoubleValue> MaxPenaltyFactorParameter { get; private set; }
+
+    [Storable] public IResultParameter<DoubleValue> CurrentTardinessPenaltyResult { get; private set; }
+
+    public bool EnabledByDefault {
+      get { return false; }
+    }
+
+    [StorableConstructor]
+    protected TimeWindowRelaxationVRPAnalyzer(StorableConstructorFlag _) : base(_) { }
+    protected TimeWindowRelaxationVRPAnalyzer(TimeWindowRelaxationVRPAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+      ProblemInstanceParameter = cloner.Clone(original.ProblemInstanceParameter);
+      VRPToursParameter = cloner.Clone(original.VRPToursParameter);
+      EvaluationResultParameter = cloner.Clone(original.EvaluationResultParameter);
+      SigmaParameter = cloner.Clone(original.SigmaParameter);
+      PhiParameter = cloner.Clone(original.PhiParameter);
+      MinPenaltyFactorParameter = cloner.Clone(original.MinPenaltyFactorParameter);
+      MaxPenaltyFactorParameter = cloner.Clone(original.MaxPenaltyFactorParameter);
+      CurrentTardinessPenaltyResult = cloner.Clone(original.CurrentTardinessPenaltyResult);
+    }
+    public TimeWindowRelaxationVRPAnalyzer()
+      : base() {
+      Parameters.Add(ProblemInstanceParameter = new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The problem instance."));
+      Parameters.Add(VRPToursParameter = new ScopeTreeLookupParameter<IVRPEncodedSolution>("VRPTours", "The VRP tours which should be evaluated."));
+      Parameters.Add(EvaluationResultParameter = new ScopeTreeLookupParameter<CVRPTWEvaluation>("EvaluationResult", "The evaluations of the VRP solutions which should be analyzed."));
+
+      Parameters.Add(SigmaParameter = new ValueParameter<DoubleValue>("Sigma", "The sigma applied to the penalty factor.", new DoubleValue(0.5)));
+      Parameters.Add(PhiParameter = new ValueParameter<DoubleValue>("Phi", "The phi applied to the penalty factor.", new DoubleValue(0.5)));
+      Parameters.Add(MinPenaltyFactorParameter = new ValueParameter<DoubleValue>("MinPenaltyFactor", "The minimum penalty factor.", new DoubleValue(0.01)));
+      Parameters.Add(MaxPenaltyFactorParameter = new ValueParameter<DoubleValue>("MaxPenaltyFactor", "The maximum penalty factor.", new DoubleValue(100000)));
+      Parameters.Add(CurrentTardinessPenaltyResult = new ResultParameter<DoubleValue>("Current Tardiness Penalty", "The current penalty applied to failing the time window constraint.", new DoubleValue(double.NaN)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new TimeWindowRelaxationVRPAnalyzer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var vrptw = (ITimeWindowedProblemInstance)ProblemInstanceParameter.ActualValue;
+
+      ItemArray<CVRPTWEvaluation> evaluations = EvaluationResultParameter.ActualValue;
+
+      double sigma = SigmaParameter.Value.Value;
+      double phi = PhiParameter.Value.Value;
+      double minPenalty = MinPenaltyFactorParameter.Value.Value;
+      double maxPenalty = MaxPenaltyFactorParameter.Value.Value;
+
+      for (int j = 0; j < evaluations.Length; j++) {
+        evaluations[j].Quality -= evaluations[j].Tardiness * vrptw.TardinessPenalty.Value;
+      }
+
+      int validCount = 0;
+      for (int j = 0; j < evaluations.Length; j++) {
+        if (evaluations[j].Tardiness == 0)
+          validCount++;
+      }
+
+      double factor = 1.0 - ((double)validCount / (double)evaluations.Length);
+
+      double min = vrptw.TardinessPenalty.Value / (1 + sigma);
+      double max = vrptw.TardinessPenalty.Value * (1 + phi);
+
+      vrptw.CurrentTardinessPenalty = new DoubleValue(min + (max - min) * factor);
+      if (vrptw.CurrentTardinessPenalty.Value < minPenalty)
+        vrptw.CurrentTardinessPenalty.Value = minPenalty;
+      if (vrptw.CurrentTardinessPenalty.Value > maxPenalty)
+        vrptw.CurrentTardinessPenalty.Value = maxPenalty;
+
+      for (int j = 0; j < evaluations.Length; j++) {
+        evaluations[j].Quality += evaluations[j].Tardiness * vrptw.CurrentTardinessPenalty.Value;
+      }
+
+      CurrentTardinessPenaltyResult.ActualValue = new DoubleValue(vrptw.CurrentTardinessPenalty.Value);
+
+      return base.Apply();
+    }
+  }
+}
