Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/CVRPPDTWView.Designer.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/CVRPPDTWView.Designer.cs	(revision 6710)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/CVRPPDTWView.Designer.cs	(revision 6710)
@@ -0,0 +1,31 @@
+﻿namespace HeuristicLab.Problems.VehicleRouting.Views {
+  partial class CVRPPDTWView {
+    /// <summary>
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary>
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Windows Form Designer generated code
+
+    /// <summary>
+    /// Required method for Designer support - do not modify
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.components = new System.ComponentModel.Container();
+    }
+
+    #endregion
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/CVRPPDTWView.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/CVRPPDTWView.cs	(revision 6710)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/CVRPPDTWView.cs	(revision 6710)
@@ -0,0 +1,144 @@
+﻿using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+using HeuristicLab.MainForm;
+using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Views {
+  [View("CVRPPDTWProblemInstance View")]
+  [Content(typeof(CVRPPDTWProblemInstance), true)]
+  public partial class CVRPPDTWView : VRPProblemInstanceView {
+    public new CVRPPDTWProblemInstance Content {
+      get { return (CVRPPDTWProblemInstance)base.Content; }
+      set { base.Content = value; }
+    }
+
+    public CVRPPDTWView() {
+      InitializeComponent();
+    }
+
+    protected override void DrawVisualization(Bitmap bitmap) {
+      DoubleMatrix coordinates = Content.Coordinates;
+      DoubleMatrix distanceMatrix = Content.DistanceMatrix;
+      BoolValue useDistanceMatrix = Content.UseDistanceMatrix;
+      DoubleArray dueTime = Content.DueTime;
+      DoubleArray serviceTime = Content.ServiceTime;
+      DoubleArray readyTime = Content.ReadyTime;
+      DoubleArray demand = Content.Demand;
+      IntArray pickupDeliveryLocation = Content.PickupDeliveryLocation;
+
+      Pen[] pens = {new Pen(Color.FromArgb(92,20,237)), new Pen(Color.FromArgb(237,183,20)), new Pen(Color.FromArgb(237,20,219)), new Pen(Color.FromArgb(20,237,76)),
+                    new Pen(Color.FromArgb(237,61,20)), new Pen(Color.FromArgb(115,78,26)), new Pen(Color.FromArgb(20,237,229)), new Pen(Color.FromArgb(39,101,19)),
+                    new Pen(Color.FromArgb(230,170,229)), new Pen(Color.FromArgb(142,136,89)), new Pen(Color.FromArgb(157,217,166)), new Pen(Color.FromArgb(31,19,101)),
+                    new Pen(Color.FromArgb(173,237,20)), new Pen(Color.FromArgb(230,231,161)), new Pen(Color.FromArgb(142,89,89)), new Pen(Color.FromArgb(93,89,142)),
+                    new Pen(Color.FromArgb(146,203,217)), new Pen(Color.FromArgb(101,19,75)), new Pen(Color.FromArgb(198,20,237)), new Pen(Color.FromArgb(185,185,185)),
+                    new Pen(Color.FromArgb(179,32,32)), new Pen(Color.FromArgb(18,119,115)), new Pen(Color.FromArgb(104,158,239)), new Pen(Color.Black)};
+
+      if ((coordinates != null) && (coordinates.Rows > 0) && (coordinates.Columns == 2)) {
+        double xMin = double.MaxValue, yMin = double.MaxValue, xMax = double.MinValue, yMax = double.MinValue;
+        for (int i = 0; i < coordinates.Rows; i++) {
+          if (xMin > coordinates[i, 0]) xMin = coordinates[i, 0];
+          if (yMin > coordinates[i, 1]) yMin = coordinates[i, 1];
+          if (xMax < coordinates[i, 0]) xMax = coordinates[i, 0];
+          if (yMax < coordinates[i, 1]) yMax = coordinates[i, 1];
+        }
+
+        int border = 20;
+        double xStep = xMax != xMin ? (bitmap.Width - 2 * border) / (xMax - xMin) : 1;
+        double yStep = yMax != yMin ? (bitmap.Height - 2 * border) / (yMax - yMin) : 1;
+
+        using (Graphics graphics = Graphics.FromImage(bitmap)) {
+          if (Solution != null) {
+            int currentTour = 0;
+            foreach (Tour tour in Solution.GetTours()) {
+              double t = 0.0;
+              Point[] tourPoints = new Point[tour.Stops.Count + 2];
+              Brush[] customerBrushes = new Brush[tour.Stops.Count];
+              Pen[] customerPens = new Pen[tour.Stops.Count];
+              bool[] validPickupDelivery = new bool[tour.Stops.Count];
+              int lastCustomer = 0;
+
+              Dictionary<int, bool> stops = new Dictionary<int, bool>();
+              for (int i = -1; i <= tour.Stops.Count; i++) {
+                int location = 0;
+
+                if (i == -1 || i == tour.Stops.Count)
+                  location = 0; //depot
+                else
+                  location = tour.Stops[i];
+
+                Point locationPoint = new Point(border + ((int)((coordinates[location, 0] - xMin) * xStep)),
+                                bitmap.Height - (border + ((int)((coordinates[location, 1] - yMin) * yStep))));
+                tourPoints[i + 1] = locationPoint;
+
+                if (i != -1 && i != tour.Stops.Count) {
+                  Brush customerBrush = Brushes.Black;
+                  Pen customerPen = Pens.Black;
+
+                  t += Content.GetDistance(
+                    lastCustomer, location);
+
+                  if (t < readyTime[location]) {
+                    t = readyTime[location];
+                    customerBrush = Brushes.Orange;
+                    customerPen = Pens.Orange;
+                    
+                  } else if (t > dueTime[location]) {
+                    customerBrush = Brushes.Red;
+                    customerPen = Pens.Red;
+                  }
+
+                  t += serviceTime[location];
+
+                  validPickupDelivery[i] =
+                    ((demand[location] >= 0) ||
+                     (stops.ContainsKey(pickupDeliveryLocation[location])));
+
+                  customerBrushes[i] = customerBrush;
+                  customerPens[i] = customerPen;
+
+                  stops.Add(location, true);
+                }
+                lastCustomer = location;
+              }
+
+              graphics.DrawPolygon(pens[((currentTour >= pens.Length) ? (pens.Length - 1) : (currentTour))], tourPoints);
+
+              for (int i = 0; i < tour.Stops.Count; i++) {
+                if(validPickupDelivery[i])
+                  graphics.FillRectangle(customerBrushes[i], tourPoints[i + 1].X - 3, tourPoints[i + 1].Y - 3, 6, 6);
+                else
+                  graphics.DrawRectangle(customerPens[i], tourPoints[i + 1].X - 3, tourPoints[i + 1].Y - 3, 6, 6);
+              }
+
+              graphics.FillEllipse(Brushes.Blue, tourPoints[0].X - 5, tourPoints[0].Y - 5, 10, 10);
+
+              currentTour++;
+            }
+          } else {
+            Point locationPoint;
+            //just draw customers
+            for (int i = 1; i < coordinates.Rows; i++) {
+              locationPoint = new Point(border + ((int)((coordinates[i, 0] - xMin) * xStep)),
+                              bitmap.Height - (border + ((int)((coordinates[i, 1] - yMin) * yStep))));
+
+              graphics.FillRectangle(Brushes.Black, locationPoint.X - 3, locationPoint.Y - 3, 6, 6);
+            }
+
+            locationPoint = new Point(border + ((int)((coordinates[0, 0] - xMin) * xStep)),
+                              bitmap.Height - (border + ((int)((coordinates[0, 1] - yMin) * yStep))));
+            graphics.FillEllipse(Brushes.Blue, locationPoint.X - 5, locationPoint.Y - 5, 10, 10);
+          }
+        }
+      }
+
+      for (int i = 0; i < pens.Length; i++)
+        pens[i].Dispose();
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/HeuristicLab.Problems.VehicleRouting.Views-3.4.csproj
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/HeuristicLab.Problems.VehicleRouting.Views-3.4.csproj	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/HeuristicLab.Problems.VehicleRouting.Views-3.4.csproj	(revision 6710)
@@ -112,4 +112,10 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="CVRPPDTWView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="CVRPPDTWView.Designer.cs">
+      <DependentUpon>CVRPPDTWView.cs</DependentUpon>
+    </Compile>
     <Compile Include="CVRPTWView.cs">
       <SubType>UserControl</SubType>
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/VRPImportDialog.Designer.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/VRPImportDialog.Designer.cs	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/VRPImportDialog.Designer.cs	(revision 6710)
@@ -85,5 +85,5 @@
       this.openVRPFileDialog.DefaultExt = "vrp";
       this.openVRPFileDialog.FileName = "vrp";
-      this.openVRPFileDialog.Filter = "TSPLib Format|*.vrp|Solomon Format|*.txt|ORLib Format|*.txt";
+      this.openVRPFileDialog.Filter = "TSPLib Format|*.vrp|Solomon Format|*.txt|ORLib Format|*.txt|LiLim Format|*.txt";
       this.openVRPFileDialog.Title = "Open TSP File";
       // 
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/VRPImportDialog.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/VRPImportDialog.cs	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/VRPImportDialog.cs	(revision 6710)
@@ -27,5 +27,5 @@
 
 namespace HeuristicLab.Problems.VehicleRouting.Views {
-  public enum VRPFormat { Empty, TSPLib, Solomon, ORLib }
+  public enum VRPFormat { Empty, TSPLib, Solomon, ORLib, LiLim }
 
   public sealed partial class VRPImportDialog : Form {
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/VehicleRoutingProblemView.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/VehicleRoutingProblemView.cs	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.4/VehicleRoutingProblemView.cs	(revision 6710)
@@ -82,4 +82,8 @@
               Content.ImportFromORLib(vrpImportDialog.VRPFileName);
               break;
+
+            case VRPFormat.LiLim:
+              Content.ImportFromLiLim(vrpImportDialog.VRPFileName);
+              break;
           }
 
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/PickupAndDelivery/BestAverageWorstPickupAndDeliveryVRPToursAnalyzer.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/PickupAndDelivery/BestAverageWorstPickupAndDeliveryVRPToursAnalyzer.cs	(revision 6710)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/PickupAndDelivery/BestAverageWorstPickupAndDeliveryVRPToursAnalyzer.cs	(revision 6710)
@@ -0,0 +1,152 @@
+#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 <http://www.gnu.org/licenses/>.
+ */
+#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;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  /// <summary>
+  /// An operator which analyzes the best, average and worst quality of solutions in the scope tree.
+  /// </summary>
+  [Item("BestAverageWorstPickupAndDeliveryVRPToursAnalyzer", "An operator which analyzes the best, average and worst properties of the VRP tours in the scope tree.")]
+  [StorableClass]
+  public sealed class BestAverageWorstPickupAndDeliveryVRPToursAnalyzer : AlgorithmOperator, IAnalyzer, IPickupAndDeliveryOperator {
+    #region Parameter properties
+    public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter {
+      get { return (ILookupParameter<IVRPProblemInstance>)Parameters["ProblemInstance"]; }
+    }
+    public ScopeTreeLookupParameter<IntValue> PickupViolationsParameter {
+      get { return (ScopeTreeLookupParameter<IntValue>)Parameters["PickupViolations"]; }
+    }
+    public ValueLookupParameter<IntValue> BestPickupViolationsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["BestPickupViolations"]; }
+    }
+    public ValueLookupParameter<IntValue> CurrentBestPickupViolationsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["CurrentBestPickupViolations"]; }
+    }
+    public ValueLookupParameter<DoubleValue> CurrentAveragePickupViolationsParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["CurrentAveragePickupViolations"]; }
+    }
+    public ValueLookupParameter<IntValue> CurrentWorstPickupViolationsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["CurrentWorstPickupViolations"]; }
+    }
+    public ValueLookupParameter<DataTable> PickupViolationsValuesParameter {
+      get { return (ValueLookupParameter<DataTable>)Parameters["PickupViolationsValues"]; }
+    }
+
+    public ValueLookupParameter<VariableCollection> ResultsParameter {
+      get { return (ValueLookupParameter<VariableCollection>)Parameters["Results"]; }
+    }
+    #endregion
+
+    #region Properties
+    private BestPickupAndDeliveryVRPToursMemorizer BestMemorizer {
+      get { return (BestPickupAndDeliveryVRPToursMemorizer)OperatorGraph.InitialOperator; }
+    }
+    private BestAverageWorstPickupAndDeliveryVRPToursCalculator BestAverageWorstCalculator {
+      get { return (BestAverageWorstPickupAndDeliveryVRPToursCalculator)BestMemorizer.Successor; }
+    }
+    #endregion
+
+    public BestAverageWorstPickupAndDeliveryVRPToursAnalyzer()
+      : base() {
+      #region Create parameters 
+      Parameters.Add(new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The problem instance."));
+
+      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("PickupViolations", "The pickup violations of the VRP solutions which should be analyzed."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("BestPickupViolations", "The best pickup violations value."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("CurrentBestPickupViolations", "The current best pickup violations value."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentAveragePickupViolations", "The current average pickup violations value of all solutions."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("CurrentWorstPickupViolations", "The current worst pickup violations value of all solutions."));
+      Parameters.Add(new ValueLookupParameter<DataTable>("PickupViolationsValues", "The data table to store the current best, current average, current worst, best and best known pickup violations value."));
+ 
+      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The results collection where the analysis values should be stored."));
+      #endregion
+
+      #region Create operators
+      BestPickupAndDeliveryVRPToursMemorizer bestMemorizer = new BestPickupAndDeliveryVRPToursMemorizer();
+      BestAverageWorstPickupAndDeliveryVRPToursCalculator calculator = new BestAverageWorstPickupAndDeliveryVRPToursCalculator();
+      ResultsCollector resultsCollector = new ResultsCollector();
+
+      //pickup violations
+      bestMemorizer.BestPickupViolationsParameter.ActualName = BestPickupViolationsParameter.Name;
+      bestMemorizer.PickupViolationsParameter.ActualName = PickupViolationsParameter.Name;
+      bestMemorizer.PickupViolationsParameter.Depth = PickupViolationsParameter.Depth;
+
+      calculator.PickupViolationsParameter.ActualName = PickupViolationsParameter.Name;
+      calculator.PickupViolationsParameter.Depth = PickupViolationsParameter.Depth;
+      calculator.BestPickupViolationsParameter.ActualName = CurrentBestPickupViolationsParameter.Name;
+      calculator.AveragePickupViolationsParameter.ActualName = CurrentAveragePickupViolationsParameter.Name;
+      calculator.WorstPickupViolationsParameter.ActualName = CurrentWorstPickupViolationsParameter.Name;
+
+      DataTableValuesCollector pickupViolationsDataTablesCollector = new DataTableValuesCollector();
+      pickupViolationsDataTablesCollector.CollectedValues.Add(new LookupParameter<IntValue>("BestPickupViolations", null, BestPickupViolationsParameter.Name));
+      pickupViolationsDataTablesCollector.CollectedValues.Add(new LookupParameter<IntValue>("CurrentBestPickupViolations", null, CurrentBestPickupViolationsParameter.Name));
+      pickupViolationsDataTablesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentAveragePickupViolations", null, CurrentAveragePickupViolationsParameter.Name));
+      pickupViolationsDataTablesCollector.CollectedValues.Add(new LookupParameter<IntValue>("CurrentWorstPickupViolations", null, CurrentWorstPickupViolationsParameter.Name));
+      pickupViolationsDataTablesCollector.DataTableParameter.ActualName = PickupViolationsValuesParameter.Name;
+
+      resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(PickupViolationsValuesParameter.Name));
+      #endregion
+
+      #region Create operator graph
+      OperatorGraph.InitialOperator = bestMemorizer;
+      bestMemorizer.Successor = calculator;
+      calculator.Successor = pickupViolationsDataTablesCollector;
+      pickupViolationsDataTablesCollector.Successor = resultsCollector;
+      resultsCollector.Successor = null;
+      #endregion
+
+      Initialize();
+    }
+    [StorableConstructor]
+    private BestAverageWorstPickupAndDeliveryVRPToursAnalyzer(bool deserializing) : base() { }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      PickupViolationsParameter.DepthChanged += new EventHandler(PickupViolationsParameter_DepthChanged);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BestAverageWorstPickupAndDeliveryVRPToursAnalyzer(this, cloner);
+    }
+
+    private BestAverageWorstPickupAndDeliveryVRPToursAnalyzer(BestAverageWorstPickupAndDeliveryVRPToursAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+        this.Initialize();
+    }
+
+    void PickupViolationsParameter_DepthChanged(object sender, EventArgs e) {
+      BestAverageWorstCalculator.PickupViolationsParameter.Depth = PickupViolationsParameter.Depth;
+      BestMemorizer.PickupViolationsParameter.Depth = PickupViolationsParameter.Depth;
+    } 
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/PickupAndDelivery/BestAverageWorstPickupAndDeliveryVRPToursCalculator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/PickupAndDelivery/BestAverageWorstPickupAndDeliveryVRPToursCalculator.cs	(revision 6710)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/PickupAndDelivery/BestAverageWorstPickupAndDeliveryVRPToursCalculator.cs	(revision 6710)
@@ -0,0 +1,93 @@
+#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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  [Item("BestAverageWorstPickupAndDeliveryVRPToursCalculator", "An operator which calculates the current best, average and worst properties of VRP tours in the scope tree.")]
+  [StorableClass]
+  public sealed class BestAverageWorstPickupAndDeliveryVRPToursCalculator : SingleSuccessorOperator {
+    public ScopeTreeLookupParameter<IntValue> PickupViolationsParameter {
+      get { return (ScopeTreeLookupParameter<IntValue>)Parameters["PickupViolations"]; }
+    }
+    public ValueLookupParameter<IntValue> BestPickupViolationsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["BestPickupViolations"]; }
+    }
+    public ValueLookupParameter<DoubleValue> AveragePickupViolationsParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["AveragePickupViolations"]; }
+    }
+    public ValueLookupParameter<IntValue> WorstPickupViolationsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["WorstPickupViolations"]; }
+    }
+
+    public BestAverageWorstPickupAndDeliveryVRPToursCalculator()
+      : base() {
+        Parameters.Add(new ScopeTreeLookupParameter<IntValue>("PickupViolations", "The pickup violations of the VRP solutions which should be analyzed."));
+        Parameters.Add(new ValueLookupParameter<IntValue>("BestPickupViolations", "The best pickup violations value."));
+        Parameters.Add(new ValueLookupParameter<DoubleValue>("AveragePickupViolations", "The average pickup violations value of all solutions."));
+        Parameters.Add(new ValueLookupParameter<IntValue>("WorstPickupViolations", "The worst pickup violations value of all solutions."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BestAverageWorstPickupAndDeliveryVRPToursCalculator(this, cloner);
+    }
+
+    private BestAverageWorstPickupAndDeliveryVRPToursCalculator(BestAverageWorstPickupAndDeliveryVRPToursCalculator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    [StorableConstructor]
+    private BestAverageWorstPickupAndDeliveryVRPToursCalculator(bool deserializing) : base(deserializing) { }
+
+    private void UpdatePickupViolations() {
+      ItemArray<IntValue> pickupViolations = PickupViolationsParameter.ActualValue;
+      if (pickupViolations.Length > 0) {
+        int min = int.MaxValue, max = int.MinValue, sum = 0;
+        for (int i = 0; i < pickupViolations.Length; i++) {
+          if (pickupViolations[i].Value < min) min = pickupViolations[i].Value;
+          if (pickupViolations[i].Value > max) max = pickupViolations[i].Value;
+          sum += pickupViolations[i].Value;
+        }
+
+        IntValue best = BestPickupViolationsParameter.ActualValue;
+        if (best == null) BestPickupViolationsParameter.ActualValue = new IntValue(min);
+        else best.Value = min;
+        DoubleValue average = AveragePickupViolationsParameter.ActualValue;
+        if (average == null) AveragePickupViolationsParameter.ActualValue = new DoubleValue(sum / pickupViolations.Length);
+        else average.Value = sum / pickupViolations.Length;
+        IntValue worst = WorstPickupViolationsParameter.ActualValue;
+        if (worst == null) WorstPickupViolationsParameter.ActualValue = new IntValue(max);
+        else worst.Value = max;
+      }
+    }
+  
+    public override IOperation Apply() {
+      UpdatePickupViolations();
+     
+      return base.Apply();
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/PickupAndDelivery/BestPickupAndDeliveryVRPToursMemorizer.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/PickupAndDelivery/BestPickupAndDeliveryVRPToursMemorizer.cs	(revision 6710)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestAverageWorstTours/PickupAndDelivery/BestPickupAndDeliveryVRPToursMemorizer.cs	(revision 6710)
@@ -0,0 +1,70 @@
+﻿#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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  [Item("BestPickupAndDeliveryVRPToursMemorizer", "An operator that updates the best VRP tour found so far in the scope three.")]
+  [StorableClass]
+  public class BestPickupAndDeliveryVRPToursMemorizer : SingleSuccessorOperator {
+    public ScopeTreeLookupParameter<IntValue> PickupViolationsParameter {
+      get { return (ScopeTreeLookupParameter<IntValue>)Parameters["PickupViolations"]; }
+    }
+
+    public ValueLookupParameter<IntValue> BestPickupViolationsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["BestPickupViolations"]; }
+    }
+
+    public BestPickupAndDeliveryVRPToursMemorizer()
+      : base() {
+        Parameters.Add(new ScopeTreeLookupParameter<IntValue>("PickupViolations", "The pickup violations of the VRP solutions which should be analyzed."));
+
+        Parameters.Add(new ValueLookupParameter<IntValue>("BestPickupViolations", "The best pickup violations found so far."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BestPickupAndDeliveryVRPToursMemorizer(this, cloner);
+    }
+
+    protected BestPickupAndDeliveryVRPToursMemorizer(BestPickupAndDeliveryVRPToursMemorizer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    [StorableConstructor]
+    protected BestPickupAndDeliveryVRPToursMemorizer(bool deserializing) : base(deserializing) { }
+
+    public override IOperation Apply() {
+      int i = PickupViolationsParameter.ActualValue.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
+      if (BestPickupViolationsParameter.ActualValue == null)
+        BestPickupViolationsParameter.ActualValue = new IntValue(PickupViolationsParameter.ActualValue[i].Value);
+      else if (PickupViolationsParameter.ActualValue[i].Value <= BestPickupViolationsParameter.ActualValue.Value)
+        BestPickupViolationsParameter.ActualValue.Value = PickupViolationsParameter.ActualValue[i].Value;
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestSolution/Capacitated/BestCapacitatedVRPSolutionAnalyzer.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestSolution/Capacitated/BestCapacitatedVRPSolutionAnalyzer.cs	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestSolution/Capacitated/BestCapacitatedVRPSolutionAnalyzer.cs	(revision 6710)
@@ -70,5 +70,5 @@
         Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Overload", "The overloads of the VRP solutions which should be analyzed."));
 
-        Parameters.Add(new LookupParameter<VRPSolution>("BestSolution", "The best TSP solution."));
+        Parameters.Add(new LookupParameter<VRPSolution>("BestSolution", "The best VRP solution."));
         Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the best VRP solution should be stored."));
     }
@@ -91,11 +91,12 @@
       int i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
 
-      IVRPEncoding best = solutions[i] as IVRPEncoding;
       VRPSolution solution = BestSolutionParameter.ActualValue;
-      if (!results.ContainsKey("Best VRP Solution Overload")) {
-        results.Add(new Result("Best VRP Solution Overload", new DoubleValue(overloads[i].Value)));
-      } else {
-        if (qualities[i].Value <= solution.Quality.Value) {
-          (results["Best VRP Solution Overload"].Value as DoubleValue).Value = overloads[i].Value;
+      if (solution != null) {
+        if (!results.ContainsKey("Best VRP Solution Overload")) {
+          results.Add(new Result("Best VRP Solution Overload", new DoubleValue(overloads[i].Value)));
+        } else {
+          if (qualities[i].Value <= solution.Quality.Value) {
+            (results["Best VRP Solution Overload"].Value as DoubleValue).Value = overloads[i].Value;
+          }
         }
       }
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestSolution/PickupAndDelivery/BestPickupAndDeliveryVRPSolutionAnalyzer.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestSolution/PickupAndDelivery/BestPickupAndDeliveryVRPSolutionAnalyzer.cs	(revision 6710)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestSolution/PickupAndDelivery/BestPickupAndDeliveryVRPSolutionAnalyzer.cs	(revision 6710)
@@ -0,0 +1,108 @@
+#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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  /// <summary>
+  /// An operator for analyzing the best solution of Vehicle Routing Problems.
+  /// </summary>
+  [Item("BestPickupAndDeliveryVRPSolutionAnalyzer", "An operator for analyzing the best solution of Pickup and Delivery Routing Problems.")]
+  [StorableClass]
+  public sealed class BestPickupAndDeliveryVRPSolutionAnalyzer : SingleSuccessorOperator, IAnalyzer, IPickupAndDeliveryOperator {
+    public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter {
+      get { return (ILookupParameter<IVRPProblemInstance>)Parameters["ProblemInstance"]; }
+    }
+    public ScopeTreeLookupParameter<IVRPEncoding> VRPToursParameter {
+      get { return (ScopeTreeLookupParameter<IVRPEncoding>)Parameters["VRPTours"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    public ScopeTreeLookupParameter<IntValue> PickupViolationsParameter {
+      get { return (ScopeTreeLookupParameter<IntValue>)Parameters["PickupViolations"]; }
+    }
+
+    public LookupParameter<VRPSolution> BestSolutionParameter {
+      get { return (LookupParameter<VRPSolution>)Parameters["BestSolution"]; }
+    }
+    public ValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+
+    [StorableConstructor]
+    private BestPickupAndDeliveryVRPSolutionAnalyzer(bool deserializing) : base(deserializing) { }
+
+    public BestPickupAndDeliveryVRPSolutionAnalyzer()
+      : base() {
+        Parameters.Add(new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The problem instance."));
+        Parameters.Add(new ScopeTreeLookupParameter<IVRPEncoding>("VRPTours", "The VRP tours which should be evaluated."));
+        Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The qualities of the VRP solutions which should be analyzed."));
+
+        Parameters.Add(new ScopeTreeLookupParameter<IntValue>("PickupViolations", "The pickup violation of the VRP solutions which should be analyzed."));
+
+        Parameters.Add(new LookupParameter<VRPSolution>("BestSolution", "The best VRP solution."));
+        Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the best VRP solution should be stored."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BestPickupAndDeliveryVRPSolutionAnalyzer(this, cloner);
+    }
+
+    private BestPickupAndDeliveryVRPSolutionAnalyzer(BestPickupAndDeliveryVRPSolutionAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public override IOperation Apply() {
+      ItemArray<IVRPEncoding> solutions = VRPToursParameter.ActualValue;
+      ResultCollection results = ResultsParameter.ActualValue;
+
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
+      ItemArray<IntValue> pickupViolations = PickupViolationsParameter.ActualValue;
+
+      int i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
+
+      IVRPEncoding best = solutions[i] as IVRPEncoding;
+      VRPSolution solution = BestSolutionParameter.ActualValue;
+      if (solution != null) {
+        if (!results.ContainsKey("Best VRP Solution PickupViolations")) {
+          results.Add(new Result("Best VRP Solution PickupViolations", new DoubleValue(pickupViolations[i].Value)));
+        } else {
+          if (qualities[i].Value <= solution.Quality.Value) {
+            (results["Best VRP Solution PickupViolations"].Value as DoubleValue).Value = pickupViolations[i].Value;
+          }
+        }
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestSolution/TimeWindowed/BestTimeWindowedVRPSolutionAnalyzer.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestSolution/TimeWindowed/BestTimeWindowedVRPSolutionAnalyzer.cs	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Analyzer/BestSolution/TimeWindowed/BestTimeWindowedVRPSolutionAnalyzer.cs	(revision 6710)
@@ -73,6 +73,6 @@
         Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Tardiness", "The tardiness of the VRP solutions which should be analyzed."));
         Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("TravelTime", "The travel times of the VRP solutions which should be analyzed."));
- 
-        Parameters.Add(new LookupParameter<VRPSolution>("BestSolution", "The best TSP solution."));
+
+        Parameters.Add(new LookupParameter<VRPSolution>("BestSolution", "The best VRP solution."));
         Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the best VRP solution should be stored."));
     }
@@ -96,13 +96,14 @@
       int i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
 
-      IVRPEncoding best = solutions[i] as IVRPEncoding;
       VRPSolution solution = BestSolutionParameter.ActualValue;
-      if (!results.ContainsKey("Best VRP Solution Tardiness")) {
-        results.Add(new Result("Best VRP Solution Tardiness", new DoubleValue(tardinesses[i].Value)));
-        results.Add(new Result("Best VRP Solution TravelTime", new DoubleValue(travelTimes[i].Value)));
-      } else {
-        if (qualities[i].Value <= solution.Quality.Value) {
-          (results["Best VRP Solution Tardiness"].Value as DoubleValue).Value = tardinesses[i].Value;
-          (results["Best VRP Solution TravelTime"].Value as DoubleValue).Value = travelTimes[i].Value;
+      if (solution != null) {
+        if (!results.ContainsKey("Best VRP Solution Tardiness")) {
+          results.Add(new Result("Best VRP Solution Tardiness", new DoubleValue(tardinesses[i].Value)));
+          results.Add(new Result("Best VRP Solution TravelTime", new DoubleValue(travelTimes[i].Value)));
+        } else {
+          if (qualities[i].Value <= solution.Quality.Value) {
+            (results["Best VRP Solution Tardiness"].Value as DoubleValue).Value = tardinesses[i].Value;
+            (results["Best VRP Solution TravelTime"].Value as DoubleValue).Value = travelTimes[i].Value;
+          }
         }
       }
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/AlbaEncoding.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/AlbaEncoding.cs	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Alba/AlbaEncoding.cs	(revision 6710)
@@ -33,5 +33,5 @@
   [Item("AlbaEncoding", "Represents an Alba encoding of VRP solutions. It is implemented as described in Alba, E. and Dorronsoro, B. (2004). Solving the Vehicle Routing Problem by Using Cellular Genetic Algorithms.")]
   [StorableClass]
-  public class AlbaEncoding : PermutationEncoding, ISingleDepotEncoding, ITimeWindowedEncoding, IHeterogenousCapacitatedEncoding  {   
+  public class AlbaEncoding : PermutationEncoding, IHeterogenousCapacitatedEncoding  {   
     #region IVRPEncoding Members
     public override List<Tour> GetTours() {
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Crossovers/PotvinInsertionBasedCrossover.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Crossovers/PotvinInsertionBasedCrossover.cs	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Crossovers/PotvinInsertionBasedCrossover.cs	(revision 6710)
@@ -27,4 +27,5 @@
 using System;
 using HeuristicLab.Parameters;
+using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
@@ -151,16 +152,21 @@
       int city, bool allowInfeasible, out int place) {
       place = -1;
+
+      if (tour.Stops.Contains(city))
+        return false;
+
       bool bestFeasible = false;
       double minDetour = 0;
 
+      VRPEvaluation eval = ProblemInstance.Evaluate(tour);
+      double length = eval.Quality;
       for (int i = 0; i <= tour.Stops.Count; i++) {
-        double length = tour.GetTourLength(ProblemInstance);
-
         tour.Stops.Insert(i, city);
 
-        bool feasible = ProblemInstance.Feasible(tour);
+        eval = ProblemInstance.Evaluate(tour);
+        bool feasible = ProblemInstance.Feasible(eval);
 
         if (feasible || allowInfeasible && !bestFeasible) {
-          double newLength = tour.GetTourLength(ProblemInstance);
+          double newLength = eval.Quality;
           double detour = newLength - length;
 
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/PotvinEncoding.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/PotvinEncoding.cs	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/PotvinEncoding.cs	(revision 6710)
@@ -35,5 +35,5 @@
   [Item("PotvinEncoding", "Represents a potvin encoding of VRP solutions. It is implemented as described in Potvin, J.-Y. and Bengio, S. (1996). The Vehicle Routing Problem with Time Windows - Part II: Genetic Search. INFORMS Journal of Computing, 8:165–172.")]
   [StorableClass]
-  public class PotvinEncoding : TourEncoding, ISingleDepotEncoding, ITimeWindowedEncoding, IHomogenousCapacitatedEncoding {   
+  public class PotvinEncoding : TourEncoding {   
     [Storable]
     public List<int> Unrouted { get; set; }
@@ -115,13 +115,15 @@
       for (int tour = 0; tour < Tours.Count; tour++) {
         if (tour != routeToAvoid) {
+          VRPEvaluation eval = ProblemInstance.Evaluate(Tours[tour]);
+          double length = eval.Quality;
+
           for (int i = 0; i <= Tours[tour].Stops.Count; i++) {
-            double length = GetTourLength(Tours[tour]);
-
             Tours[tour].Stops.Insert(i, city);
 
-            bool feasible = ProblemInstance.Feasible(Tours[tour]);
+            eval = ProblemInstance.Evaluate(Tours[tour]);
+            bool feasible = ProblemInstance.Feasible(eval);
 
             if (feasible || allowInfeasible && !bestFeasible) {
-              double newLength = GetTourLength(Tours[tour]);
+              double newLength = eval.Quality;
               double detour = newLength - length;
 
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/PrinsEncoding.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/PrinsEncoding.cs	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/PrinsEncoding.cs	(revision 6710)
@@ -66,5 +66,5 @@
           feasible = ProblemInstance.Feasible(eval);
 
-          if (feasible) {
+          if (feasible || j == i) {
             if (V[i - 1] + cost < V[j]) {
               V[j] = V[i - 1] + cost;
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/HeuristicLab.Problems.VehicleRouting-3.4.csproj
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/HeuristicLab.Problems.VehicleRouting-3.4.csproj	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/HeuristicLab.Problems.VehicleRouting-3.4.csproj	(revision 6710)
@@ -113,4 +113,7 @@
     <Compile Include="Analyzer\BestAverageWorstTours\Capacitated\BestAverageWorstCapacitatedVRPToursCalculator.cs" />
     <Compile Include="Analyzer\BestAverageWorstTours\Capacitated\BestCapacitatedVRPToursMemorizer.cs" />
+    <Compile Include="Analyzer\BestAverageWorstTours\PickupAndDelivery\BestAverageWorstPickupAndDeliveryVRPToursAnalyzer.cs" />
+    <Compile Include="Analyzer\BestAverageWorstTours\PickupAndDelivery\BestAverageWorstPickupAndDeliveryVRPToursCalculator.cs" />
+    <Compile Include="Analyzer\BestAverageWorstTours\PickupAndDelivery\BestPickupAndDeliveryVRPToursMemorizer.cs" />
     <Compile Include="Analyzer\BestAverageWorstTours\TimeWindowed\BestAverageWorstTimeWindowedVRPToursAnalyzer.cs" />
     <Compile Include="Analyzer\BestAverageWorstTours\TimeWindowed\BestAverageWorstTimeWindowedVRPToursCalculator.cs" />
@@ -118,4 +121,5 @@
     <Compile Include="Analyzer\BestSolution\BestVRPSolutionAnalyzer.cs" />
     <Compile Include="Analyzer\BestSolution\Capacitated\BestCapacitatedVRPSolutionAnalyzer.cs" />
+    <Compile Include="Analyzer\BestSolution\PickupAndDelivery\BestPickupAndDeliveryVRPSolutionAnalyzer.cs" />
     <Compile Include="Analyzer\BestSolution\TimeWindowed\BestTimeWindowedVRPSolutionAnalyzer.cs" />
     <Compile Include="Analyzer\VRPSolution.cs" />
@@ -249,9 +253,12 @@
     <Compile Include="Interfaces\IVRPEncoding.cs" />
     <Compile Include="Interfaces\IVRPProblemInstance.cs" />
+    <Compile Include="Parsers\LiLimParser.cs" />
+    <Compile Include="ProblemInstances\SingleDepotVRP\CVRP\CVRPTW\CVRPPDTW\CVRPPDTWProblemInstance.cs" />
+    <Compile Include="ProblemInstances\SingleDepotVRP\CVRP\CVRPTW\CVRPPDTW\CVRPPDTWEvaluation.cs" />
+    <Compile Include="ProblemInstances\SingleDepotVRP\CVRP\CVRPTW\CVRPPDTW\CVRPPDTWEvaluator.cs" />
     <Compile Include="SolutionParser.cs" />
     <Compile Include="Variants\Capacitated\Heterogenous\IHeterogenousCapacitatedProblemInstance.cs" />
     <Compile Include="Variants\Capacitated\Heterogenous\IHeterogenousCapacitatedOperator.cs" />
     <Compile Include="Variants\Capacitated\Heterogenous\IHeterogenousCapacitatedEncoding.cs" />
-    <Compile Include="Variants\Capacitated\Homogenous\IHomogenousCapacitatedEncoding.cs" />
     <Compile Include="Variants\Capacitated\Homogenous\IHomogenousCapacitatedOperator.cs" />
     <Compile Include="Variants\Capacitated\Homogenous\IHomogenousCapacitatedProblemInstance.cs" />
@@ -259,10 +266,10 @@
     <Compile Include="Variants\Capacitated\ICapacitatedOperator.cs" />
     <Compile Include="Variants\General\IGeneralVRPOperator.cs" />
+    <Compile Include="Variants\PickupAndDelivery\IPickupAndDeliveryOperator.cs" />
+    <Compile Include="Variants\PickupAndDelivery\IPickupAndDeliveryProblemInstance.cs" />
     <Compile Include="Variants\SingleDepot\ISingleDepotOperator.cs" />
-    <Compile Include="Variants\SingleDepot\ISingleDepotEncoding.cs" />
     <Compile Include="Variants\SingleDepot\ISingleDepotProblemInstance.cs" />
     <Compile Include="Variants\TimeWindowed\ITimeWindowedProblemInstance.cs" />
     <Compile Include="Variants\TimeWindowed\ITimeWindowedOperator.cs" />
-    <Compile Include="Variants\TimeWindowed\ITimeWindowedEncoding.cs" />
     <Compile Include="Parsers\ORLIBParser.cs" />
     <Compile Include="ProblemInstances\SingleDepotVRP\CVRP\CVRPTW\CVRPTWProblemInstance.cs" />
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Parsers/LiLimParser.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Parsers/LiLimParser.cs	(revision 6710)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Parsers/LiLimParser.cs	(revision 6710)
@@ -0,0 +1,163 @@
+﻿#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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.RegularExpressions;
+
+namespace HeuristicLab.Problems.VehicleRouting.Parsers {
+  class LiLimParser {
+    private string file;
+    private string problemName;
+    private int cities;
+    private int vehicles;
+    private double capacity;
+    private List<double> xCoord;
+    private List<double> yCoord;
+    private List<double> demand;
+    private List<double> readyTime;
+    private List<double> dueTime;
+    private List<double> serviceTime;
+    private List<int> pickipDeliveryLocation;
+
+    public int Cities {
+      get {
+        return cities;
+      }
+    }
+
+    public int Vehicles {
+      get {
+        return vehicles;
+      }
+    }
+
+    public double Capacity {
+      get {
+        return capacity;
+      }
+    }
+
+    public double[,] Coordinates {
+      get {
+        double[] x = xCoord.ToArray();
+        double[] y = yCoord.ToArray();
+        double[,] coord = new double[x.Length, 2];
+        for (int i = 0; i < x.Length; i++) {
+          coord[i, 0] = x[i];
+          coord[i, 1] = y[i];
+        }
+        return coord;
+      }
+    }
+
+    public double[] Demands {
+      get {
+        return demand.ToArray();
+      }
+    }
+
+    public double[] Readytimes {
+      get {
+        return readyTime.ToArray();
+      }
+    }
+
+    public double[] Duetimes {
+      get {
+        return dueTime.ToArray();
+      }
+    }
+
+    public double[] Servicetimes {
+      get {
+        return serviceTime.ToArray();
+      }
+    }
+
+    public int[] PickupDeliveryLocations {
+      get {
+        return pickipDeliveryLocation.ToArray();
+      }
+    }
+
+    public String ProblemName {
+      get {
+        return problemName;
+      }
+    }
+
+    public LiLimParser(string file) {
+      this.file = file;
+      xCoord = new List<double>();
+      yCoord = new List<double>();
+      demand = new List<double>();
+      readyTime = new List<double>();
+      dueTime = new List<double>();
+      serviceTime = new List<double>();
+      pickipDeliveryLocation = new List<int>();
+    }
+
+    public void Parse() {
+      string line;
+      Regex reg = new Regex(@"-?\d+");
+      MatchCollection m;
+
+      StreamReader reader = new StreamReader(file);
+
+      problemName = Path.GetFileNameWithoutExtension(file);
+      line = reader.ReadLine();
+
+      m = reg.Matches(line);
+      if (m.Count != 3)
+        throw new InvalidDataException("File has wrong format!");
+
+      vehicles = int.Parse(m[0].Value);
+      capacity = double.Parse(m[1].Value);
+
+      line = reader.ReadLine();
+      while ((line != null) && (line.Length > 5)) {
+        m = reg.Matches(line);
+        if (m.Count != 9) { continue; }
+        xCoord.Add((double)int.Parse(m[1].Value));
+        yCoord.Add((double)int.Parse(m[2].Value));
+        demand.Add((double)int.Parse(m[3].Value));
+        readyTime.Add((double)int.Parse(m[4].Value));
+        double st = (double)int.Parse(m[6].Value);
+        dueTime.Add((double)int.Parse(m[5].Value));
+        serviceTime.Add(st);
+
+        int location = int.Parse(m[7].Value);
+        if (location == 0)
+          location = int.Parse(m[8].Value);
+        pickipDeliveryLocation.Add(location);
+        
+        line = reader.ReadLine();
+      }
+      cities = serviceTime.Count;
+    }
+
+    internal string OnReset() {
+      throw new NotImplementedException();
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPProblemInstance.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPProblemInstance.cs	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPProblemInstance.cs	(revision 6710)
@@ -76,5 +76,5 @@
     public CVRPProblemInstance() {
       Parameters.Add(new ValueParameter<DoubleValue>("Capacity", "The capacity of each vehicle.", new DoubleValue(0)));
-      Parameters.Add(new ValueParameter<DoubleValue>("EvalOverloadPenalty", "The overload penalty considered in the evaluation.", new DoubleValue(1)));
+      Parameters.Add(new ValueParameter<DoubleValue>("EvalOverloadPenalty", "The overload penalty considered in the evaluation.", new DoubleValue(100)));
 
       AttachEventHandlers();
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPTW/CVRPPDTW/CVRPPDTWEvaluation.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPTW/CVRPPDTW/CVRPPDTWEvaluation.cs	(revision 6710)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPTW/CVRPPDTW/CVRPPDTWEvaluation.cs	(revision 6710)
@@ -0,0 +1,31 @@
+﻿#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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace HeuristicLab.Problems.VehicleRouting.ProblemInstances {
+  public class CVRPPDTWEvaluation: CVRPTWEvaluation {
+    public int PickupViolations { get; set; }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPTW/CVRPPDTW/CVRPPDTWEvaluator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPTW/CVRPPDTW/CVRPPDTWEvaluator.cs	(revision 6710)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPTW/CVRPPDTW/CVRPPDTWEvaluator.cs	(revision 6710)
@@ -0,0 +1,174 @@
+﻿#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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+using HeuristicLab.Problems.VehicleRouting.Encodings;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.VehicleRouting.ProblemInstances {
+  [Item("CVRPPDTWEvaluator", "Represents a single depot CVRPPDTW evaluator.")]
+  [StorableClass]
+  public class CVRPPDTWEvaluator: CVRPTWEvaluator {
+    public ILookupParameter<IntValue> PickupViolationsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["PickupViolations"]; }
+    }
+
+    protected override VRPEvaluation CreateTourEvaluation() {
+      return new CVRPPDTWEvaluation();
+    }
+
+    protected override void EvaluateTour(VRPEvaluation eval, IVRPProblemInstance instance, Tour tour) {
+      IHomogenousCapacitatedProblemInstance cvrpInstance = instance as IHomogenousCapacitatedProblemInstance;
+      DoubleArray demand = instance.Demand;
+
+      ITimeWindowedProblemInstance vrptw = instance as ITimeWindowedProblemInstance;
+      DoubleArray dueTime = vrptw.DueTime;
+      DoubleArray readyTime = vrptw.ReadyTime;
+      DoubleArray serviceTimes = vrptw.ServiceTime;
+
+      IPickupAndDeliveryProblemInstance pdp = instance as IPickupAndDeliveryProblemInstance;
+      IntArray pickupDeliveryLocation = pdp.PickupDeliveryLocation;
+
+      double capacity = cvrpInstance.Capacity.Value;
+
+      double time = 0.0;
+      double waitingTime = 0.0;
+      double serviceTime = 0.0;
+      double tardiness = 0.0;
+      double overweight = 0.0;
+      double distance = 0.0;
+
+      double currentLoad = 0.0;
+      Dictionary<int, bool> stops = new Dictionary<int, bool>();
+      int pickupViolations = 0;
+
+      //simulate a tour, start and end at depot
+      for (int i = 0; i <= tour.Stops.Count; i++) {
+        int start = 0;
+        if (i > 0)
+          start = tour.Stops[i - 1];
+        int end = 0;
+        if (i < tour.Stops.Count)
+          end = tour.Stops[i];
+
+        //drive there
+        double currentDistace = vrptw.GetDistance(start, end);
+        time += currentDistace;
+        distance += currentDistace;
+
+        //check if it was serviced on time
+        if (time > dueTime[end])
+          tardiness += time - dueTime[end];
+
+        //wait
+        double currentWaitingTime = 0.0;
+        if (time < readyTime[end])
+          currentWaitingTime = readyTime[end] - time;
+        waitingTime += currentWaitingTime;
+        time += currentWaitingTime;
+
+        //service
+        double currentServiceTime = serviceTimes[end];
+        serviceTime += currentServiceTime;
+        time += currentServiceTime;
+
+        //Pickup / deliver
+        bool validPickupDelivery = 
+          validPickupDelivery =
+          ((demand[end] >= 0) ||
+           (stops.ContainsKey(pickupDeliveryLocation[end])));
+
+        if (validPickupDelivery) {
+          currentLoad += demand[end];
+
+          if (currentLoad > capacity)
+            overweight += currentLoad - capacity;
+        } else {
+          pickupViolations++;
+        }
+
+        stops.Add(end, true);
+      }
+
+      eval.Quality += instance.FleetUsageFactor.Value;
+      eval.Quality += instance.DistanceFactor.Value * distance;
+      eval.Distance += distance;
+      eval.VehicleUtilization += 1;
+
+      (eval as CVRPEvaluation).Overload += overweight;
+      double penalty = overweight * cvrpInstance.OverloadPenalty.Value;
+      eval.Penalty += penalty;
+      eval.Quality += penalty;
+
+      (eval as CVRPTWEvaluation).Tardiness += tardiness;
+      (eval as CVRPTWEvaluation).TravelTime += time;
+
+      penalty = tardiness * vrptw.TardinessPenalty.Value;
+      eval.Penalty += penalty;
+      eval.Quality += penalty;
+
+      (eval as CVRPPDTWEvaluation).PickupViolations += pickupViolations;
+      penalty = pickupViolations * pdp.PickupViolationPenalty.Value;
+      eval.Penalty += penalty;
+
+      eval.Quality += penalty;
+      eval.Quality += time * vrptw.TimeFactor.Value;
+    }
+
+    protected override void InitResultParameters() {
+      base.InitResultParameters();
+
+      PickupViolationsParameter.ActualValue = new IntValue(0);
+    }
+
+    protected override void SetResultParameters(VRPEvaluation tourEvaluation) {
+      base.SetResultParameters(tourEvaluation);
+
+      PickupViolationsParameter.ActualValue.Value = (tourEvaluation as CVRPPDTWEvaluation).PickupViolations;
+    }
+    
+    [StorableConstructor]
+    protected CVRPPDTWEvaluator(bool deserializing) : base(deserializing) { }
+
+    public CVRPPDTWEvaluator() {
+      Parameters.Add(new LookupParameter<IntValue>("PickupViolations", "The number of pickup violations."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CVRPPDTWEvaluator(this, cloner);
+    }
+
+    protected CVRPPDTWEvaluator(CVRPPDTWEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPTW/CVRPPDTW/CVRPPDTWProblemInstance.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPTW/CVRPPDTW/CVRPPDTWProblemInstance.cs	(revision 6710)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPTW/CVRPPDTW/CVRPPDTWProblemInstance.cs	(revision 6710)
@@ -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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.VehicleRouting.ProblemInstances {
+  [Item("CVRPPDTWProblemInstance", "Represents a single depot CVRPPDTW instance.")]
+  [StorableClass]
+  public class CVRPPDTWProblemInstance: CVRPTWProblemInstance, IPickupAndDeliveryProblemInstance {
+    protected IValueParameter<IntArray> PickupDeliveryLocationParameter {
+      get { return (IValueParameter<IntArray>)Parameters["PickupDeliveryLocation"]; }
+    }
+    protected IValueParameter<DoubleValue> PickupViolationPenaltyParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["EvalPickupViolationPenalty"]; }
+    }
+    
+    public IntArray PickupDeliveryLocation {
+      get { return PickupDeliveryLocationParameter.Value; }
+      set { PickupDeliveryLocationParameter.Value = value; }
+    }
+
+    public DoubleValue PickupViolationPenalty {
+      get { return PickupViolationPenaltyParameter.Value; }
+      set { PickupViolationPenaltyParameter.Value = value; }
+    }
+
+    protected override IEnumerable<IOperator> GetOperators() {
+      return 
+        ApplicationManager.Manager.GetInstances<IPickupAndDeliveryOperator>()
+        .Cast<IOperator>().Union(base.GetOperators());
+    }
+
+    protected override IEnumerable<IOperator> GetAnalyzers() {
+      return ApplicationManager.Manager.GetInstances<IPickupAndDeliveryOperator>()
+        .Where(o => o is IAnalyzer)
+        .Cast<IOperator>().Union(base.GetAnalyzers());
+    }
+    
+    protected override IVRPEvaluator Evaluator {
+      get {
+        return new CVRPPDTWEvaluator();
+      }
+    }
+    
+    [StorableConstructor]
+    protected CVRPPDTWProblemInstance(bool deserializing) : base(deserializing) { }
+
+    public CVRPPDTWProblemInstance() {
+      Parameters.Add(new ValueParameter<IntArray>("PickupDeliveryLocation", "The pickup and delivery location for each customer.", new IntArray()));
+
+      Parameters.Add(new ValueParameter<DoubleValue>("EvalPickupViolationPenalty", "The pickup violation penalty considered in the evaluation.", new DoubleValue(100)));
+
+      AttachEventHandlers();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CVRPPDTWProblemInstance(this, cloner);
+    }
+
+    protected CVRPPDTWProblemInstance(CVRPPDTWProblemInstance original, Cloner cloner)
+      : base(original, cloner) {
+        AttachEventHandlers();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserializationHook() {
+      AttachEventHandlers();
+    }
+
+    private void AttachEventHandlers() {
+      PickupDeliveryLocationParameter.ValueChanged += new EventHandler(PickupDeliveryLocationParameter_ValueChanged);
+    }
+
+    #region Event handlers
+    void PickupDeliveryLocationParameter_ValueChanged(object sender, EventArgs e) {
+      PickupDeliveryLocationParameter.Value.ItemChanged += new EventHandler<EventArgs<int>>(Value_ItemChanged);
+      EvalBestKnownSolution();
+    }
+
+    void Value_ItemChanged(object sender, EventArgs<int> e) {
+      EvalBestKnownSolution();
+    }
+    #endregion
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPTW/CVRPTWProblemInstance.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPTW/CVRPTWProblemInstance.cs	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/ProblemInstances/SingleDepotVRP/CVRP/CVRPTW/CVRPTWProblemInstance.cs	(revision 6710)
@@ -102,5 +102,5 @@
 
       Parameters.Add(new ValueParameter<DoubleValue>("EvalTimeFactor", "The time factor considered in the evaluation.", new DoubleValue(0)));
-      Parameters.Add(new ValueParameter<DoubleValue>("EvalTardinessPenalty", "The tardiness penalty considered in the evaluation.", new DoubleValue(1)));
+      Parameters.Add(new ValueParameter<DoubleValue>("EvalTardinessPenalty", "The tardiness penalty considered in the evaluation.", new DoubleValue(100)));
 
       AttachEventHandlers();
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/Capacitated/Heterogenous/IHeterogenousCapacitatedEncoding.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/Capacitated/Heterogenous/IHeterogenousCapacitatedEncoding.cs	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/Capacitated/Heterogenous/IHeterogenousCapacitatedEncoding.cs	(revision 6710)
@@ -24,7 +24,8 @@
 using System.Linq;
 using System.Text;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
 
 namespace HeuristicLab.Problems.VehicleRouting.Variants {
-  public interface IHeterogenousCapacitatedEncoding : IHomogenousCapacitatedEncoding {
+  public interface IHeterogenousCapacitatedEncoding : IVRPEncoding {
     int GetVehicleAssignment(int tour);
   }
Index: anches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/Capacitated/Homogenous/IHomogenousCapacitatedEncoding.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/Capacitated/Homogenous/IHomogenousCapacitatedEncoding.cs	(revision 6709)
+++ 	(revision )
@@ -1,31 +1,0 @@
-﻿#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 <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Problems.VehicleRouting.Interfaces;
-
-namespace HeuristicLab.Problems.VehicleRouting.Variants {
-  public interface IHomogenousCapacitatedEncoding : IVRPEncoding {
-  }
-}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/PickupAndDelivery/IPickupAndDeliveryOperator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/PickupAndDelivery/IPickupAndDeliveryOperator.cs	(revision 6710)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/PickupAndDelivery/IPickupAndDeliveryOperator.cs	(revision 6710)
@@ -0,0 +1,31 @@
+﻿#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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+
+namespace HeuristicLab.Problems.VehicleRouting.Variants {
+  public interface IPickupAndDeliveryOperator: IVRPOperator {
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/PickupAndDelivery/IPickupAndDeliveryProblemInstance.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/PickupAndDelivery/IPickupAndDeliveryProblemInstance.cs	(revision 6710)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/PickupAndDelivery/IPickupAndDeliveryProblemInstance.cs	(revision 6710)
@@ -0,0 +1,34 @@
+﻿#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 <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Variants {
+  public interface IPickupAndDeliveryProblemInstance: IVRPProblemInstance {
+    IntArray PickupDeliveryLocation { get; }
+    DoubleValue PickupViolationPenalty { get; }
+  }
+}
Index: anches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/SingleDepot/ISingleDepotEncoding.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/SingleDepot/ISingleDepotEncoding.cs	(revision 6709)
+++ 	(revision )
@@ -1,31 +1,0 @@
-﻿#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 <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Problems.VehicleRouting.Interfaces;
-
-namespace HeuristicLab.Problems.VehicleRouting.Variants {
-  public interface ISingleDepotEncoding: IVRPEncoding {
-  }
-}
Index: anches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/TimeWindowed/ITimeWindowedEncoding.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Variants/TimeWindowed/ITimeWindowedEncoding.cs	(revision 6709)
+++ 	(revision )
@@ -1,31 +1,0 @@
-﻿#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 <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Problems.VehicleRouting.Interfaces;
-
-namespace HeuristicLab.Problems.VehicleRouting.Variants {
-  public interface ITimeWindowedEncoding: IVRPEncoding {
-  }
-}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/VehicleRoutingProblem.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/VehicleRoutingProblem.cs	(revision 6709)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/VehicleRoutingProblem.cs	(revision 6710)
@@ -243,4 +243,24 @@
     #endregion
 
+    public void ImportFromLiLim(string liLimFileName) {
+      LiLimParser parser = new LiLimParser(liLimFileName);
+      parser.Parse();
+      
+      CVRPPDTWProblemInstance problem = new CVRPPDTWProblemInstance();
+
+      problem.Coordinates = new DoubleMatrix(parser.Coordinates);
+      problem.Vehicles.Value = parser.Vehicles;
+      problem.Capacity.Value = parser.Capacity;
+      problem.Demand = new DoubleArray(parser.Demands);
+      problem.ReadyTime = new DoubleArray(parser.Readytimes);
+      problem.DueTime = new DoubleArray(parser.Duetimes);
+      problem.ServiceTime = new DoubleArray(parser.Servicetimes);
+      problem.PickupDeliveryLocation = new IntArray(parser.PickupDeliveryLocations);
+
+      this.ProblemInstance = problem;
+
+      OnReset();
+    }
+
     public void ImportFromSolomon(string solomonFileName) {
       SolomonParser parser = new SolomonParser(solomonFileName);
