Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/IPotvinPDExchangeMoveOperator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/IPotvinPDExchangeMoveOperator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/IPotvinPDExchangeMoveOperator.cs	(revision 6773)
@@ -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 HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  public interface IPotvinPDExchangeMoveOperator : IVRPMoveOperator {
+    ILookupParameter<PotvinPDExchangeMove> PDExchangeMoveParameter { get; }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeExhaustiveMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeExhaustiveMoveGenerator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeExhaustiveMoveGenerator.cs	(revision 6773)
@@ -0,0 +1,90 @@
+﻿#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.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDExchangeExhaustiveMoveGenerator", "Generates exchange moves from a given PDP encoding.")]
+  [StorableClass]
+  public sealed class PotvinPDExchangeExhaustiveMoveGenerator : PotvinPDExchangeMoveGenerator, IExhaustiveMoveGenerator {
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDExchangeExhaustiveMoveGenerator(this, cloner);
+    }
+
+    [StorableConstructor]
+    private PotvinPDExchangeExhaustiveMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDExchangeExhaustiveMoveGenerator()
+      : base() {
+    }
+
+    private PotvinPDExchangeExhaustiveMoveGenerator(PotvinPDExchangeExhaustiveMoveGenerator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected override PotvinPDExchangeMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
+      List<PotvinPDExchangeMove> result = new List<PotvinPDExchangeMove>();
+      IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
+
+      int max = individual.Tours.Count;
+      if (individual.Tours.Count < problemInstance.Vehicles.Value)
+        max = max - 1;
+
+      for (int i = 0; i < individual.Tours.Count; i++) {
+        for (int j = 0; j < individual.Tours[i].Stops.Count; j++) {
+          for (int k = 0; k <= max; k++) {
+            if (k != i) {
+              int city1 = individual.Tours[i].Stops[j];
+              if (pdp == null || pdp.Demand[city1] >= 0) {
+                for (int l = 0; l < individual.Tours[k].Stops.Count; l++) {
+                  int city2 = individual.Tours[k].Stops[l];
+                  if (pdp == null || pdp.Demand[city2] >= 0) {
+                    bool valid = pdp == null ||
+                      (pdp.PickupDeliveryLocation[city2] != pdp.PickupDeliveryLocation[city1] &&
+                       pdp.PickupDeliveryLocation[city2] != city1 &&
+                       pdp.PickupDeliveryLocation[city1] != city2);
+
+                    if (valid) {
+                      PotvinPDExchangeMove move = new PotvinPDExchangeMove(
+                        city1, i, k, city2, individual);
+
+                      result.Add(move);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      return result.ToArray();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMove.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMove.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMove.cs	(revision 6773)
@@ -0,0 +1,129 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDExchangeMove", "Item that describes a exchange move on a PDP representation.")]
+  [StorableClass]
+  public class PotvinPDExchangeMove: Item, IVRPMove {
+    [Storable]
+    public IVRPEncoding Individual { get; protected set; }
+    
+    [Storable]
+    public int City { get; protected set; }
+
+    [Storable]
+    public int OldTour { get; protected set; }
+
+    [Storable]
+    public int Tour { get; protected set; }
+
+    [Storable]
+    public int Replaced { get; protected set; }
+   
+    public PotvinPDExchangeMove(): base() {
+      City = -1;
+      Tour = -1;
+
+      Individual = null;
+    }
+
+    public PotvinPDExchangeMove(int city, int oldTour, int tour, int replaced, PotvinEncoding individual) {
+      City = city;
+      OldTour = oldTour;
+      Tour = tour;
+      Replaced = replaced;
+
+      this.Individual = individual.Clone() as PotvinEncoding;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDExchangeMove(this, cloner);
+    }
+
+    protected PotvinPDExchangeMove(PotvinPDExchangeMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.City = original.City;
+      this.OldTour = original.OldTour;
+      this.Tour = original.Tour;
+      this.Replaced = original.Replaced;
+
+      this.Individual = cloner.Clone(Individual) as PotvinEncoding;
+    }
+
+    #region IVRPMove Members
+
+    private static PotvinPDExchangeMoveEvaluator moveEvaluator;
+    public VRPMoveEvaluator GetMoveEvaluator() {
+      if (moveEvaluator == null)
+        moveEvaluator = new PotvinPDExchangeMoveEvaluator();
+
+      return moveEvaluator;
+    }
+
+    private static PotvinPDExchangeMoveMaker moveMaker; 
+    public VRPMoveMaker GetMoveMaker() {
+      if (moveMaker == null)
+        moveMaker = new PotvinPDExchangeMoveMaker();
+
+      return moveMaker;
+    }
+
+    private static PotvinPDExchangeMoveTabuMaker tabuMaker;
+    public ITabuMaker GetTabuMaker() {
+      if (tabuMaker == null)
+        tabuMaker = new PotvinPDExchangeMoveTabuMaker();
+
+      return tabuMaker;
+    }
+
+    private static PotvinPDExchangeTabuCriterion tabuChecker;
+    public ITabuChecker GetTabuChecker() {
+      if (tabuChecker == null) {
+        tabuChecker = new PotvinPDExchangeTabuCriterion();
+        tabuChecker.UseAspirationCriterion.Value = false;
+      }
+
+      return tabuChecker;
+    }
+
+    private static PotvinPDExchangeTabuCriterion softTabuChecker;
+    public ITabuChecker GetSoftTabuChecker() {
+      if (softTabuChecker == null) {
+        softTabuChecker = new PotvinPDExchangeTabuCriterion();
+        softTabuChecker.UseAspirationCriterion.Value = true;
+      }
+
+      return softTabuChecker;
+    }
+
+    #endregion
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveEvaluator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveEvaluator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveEvaluator.cs	(revision 6773)
@@ -0,0 +1,83 @@
+﻿#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.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using HeuristicLab.Common;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDExchangeMoveEvaluator", "Evaluates a exchange move for a PDP representation. ")]
+  [StorableClass]
+  public sealed class PotvinPDExchangeMoveEvaluator : PotvinMoveEvaluator, IPotvinPDExchangeMoveOperator {
+    public ILookupParameter<PotvinPDExchangeMove> PDExchangeMoveParameter {
+      get { return (ILookupParameter<PotvinPDExchangeMove>)Parameters["PotvinPDExchangeMove"]; }
+    }
+
+    public override ILookupParameter VRPMoveParameter {
+      get { return PDExchangeMoveParameter; }
+    }
+
+    public ILookupParameter<VariableCollection> MemoriesParameter {
+      get { return (ILookupParameter<VariableCollection>)Parameters["Memories"]; }
+    }
+
+    public IValueParameter<StringValue> AdditionFrequencyMemoryKeyParameter {
+      get { return (IValueParameter<StringValue>)Parameters["AdditionFrequencyMemoryKey"]; }
+    }
+
+    public IValueParameter<DoubleValue> LambdaParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["Lambda"]; }
+    }
+
+    [StorableConstructor]
+    private PotvinPDExchangeMoveEvaluator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDExchangeMoveEvaluator()
+      : base() {
+        Parameters.Add(new LookupParameter<PotvinPDExchangeMove>("PotvinPDExchangeMove", "The move that should be evaluated."));
+
+       Parameters.Add(new LookupParameter<VariableCollection>("Memories", "The TS memory collection."));
+       Parameters.Add(new ValueParameter<StringValue>("AdditionFrequencyMemoryKey", "The key that is used for the addition frequency in the TS memory.", new StringValue("AdditionFrequency")));
+       Parameters.Add(new ValueParameter<DoubleValue>("Lambda", "The lambda parameter.", new DoubleValue(0.015)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDExchangeMoveEvaluator(this, cloner);
+    }
+
+    private PotvinPDExchangeMoveEvaluator(PotvinPDExchangeMoveEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected override void EvaluateMove() {
+      PotvinPDExchangeMove move = PDExchangeMoveParameter.ActualValue;
+
+      PotvinEncoding newSolution = PDExchangeMoveParameter.ActualValue.Individual.Clone() as PotvinEncoding;
+      PotvinPDExchangeMoveMaker.Apply(newSolution, move, ProblemInstance);
+
+      UpdateEvaluation(newSolution);
+    } 
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveGenerator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveGenerator.cs	(revision 6773)
@@ -0,0 +1,77 @@
+﻿#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.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDExchangeMoveGenerator", "Generates exchange moves from a given PDP encoding.")]
+  [StorableClass]
+  public abstract class PotvinPDExchangeMoveGenerator : PotvinMoveGenerator, IPotvinPDExchangeMoveOperator {
+    public ILookupParameter<PotvinPDExchangeMove> PDExchangeMoveParameter {
+      get { return (ILookupParameter<PotvinPDExchangeMove>)Parameters["PotvinPDExchangeMove"]; }
+    }
+
+    public override ILookupParameter VRPMoveParameter {
+      get { return PDExchangeMoveParameter; }
+    }
+
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    [StorableConstructor]
+    protected PotvinPDExchangeMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDExchangeMoveGenerator()
+      : base() {
+        Parameters.Add(new LookupParameter<PotvinPDExchangeMove>("PotvinPDExchangeMove", "The moves that should be generated in subscopes."));
+        Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
+    }
+
+    protected PotvinPDExchangeMoveGenerator(PotvinPDExchangeMoveGenerator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected abstract PotvinPDExchangeMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
+
+    public override IOperation Apply() {
+      IOperation next = base.Apply();
+
+      PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
+      PotvinPDExchangeMove[] moves = GenerateMoves(individual, ProblemInstance);
+      Scope[] moveScopes = new Scope[moves.Length];
+      for (int i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        moveScopes[i].Variables.Add(new Variable(PDExchangeMoveParameter.ActualName, moves[i]));
+      }
+      CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
+
+      return next;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveMaker.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveMaker.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveMaker.cs	(revision 6773)
@@ -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 HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDExchangeMoveMaker", "Peforms the exchange move on a given PDP encoding and updates the quality.")]
+  [StorableClass]
+  public class PotvinPDExchangeMoveMaker : PotvinMoveMaker, IPotvinPDExchangeMoveOperator, IMoveMaker {
+    public ILookupParameter<PotvinPDExchangeMove> PDExchangeMoveParameter {
+      get { return (ILookupParameter<PotvinPDExchangeMove>)Parameters["PotvinPDExchangeMove"]; }
+    }
+
+    public override ILookupParameter VRPMoveParameter {
+      get { return PDExchangeMoveParameter; }
+    }
+
+    [StorableConstructor]
+    private PotvinPDExchangeMoveMaker(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDExchangeMoveMaker()
+      : base() {
+        Parameters.Add(new LookupParameter<PotvinPDExchangeMove>("PotvinPDExchangeMove", "The moves that should be made."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDExchangeMoveMaker(this, cloner);
+    }
+
+    protected PotvinPDExchangeMoveMaker(PotvinPDExchangeMoveMaker original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public static void Apply(PotvinEncoding solution, PotvinPDExchangeMove move, IVRPProblemInstance problemInstance) {
+      if (move.Tour >= solution.Tours.Count)
+        solution.Tours.Add(new Tour());
+      Tour tour = solution.Tours[move.Tour];
+
+      Tour oldTour = solution.Tours.Find(t => t.Stops.Contains(move.City));
+      oldTour.Stops.Remove(move.City);
+
+      if (problemInstance is IPickupAndDeliveryProblemInstance) {
+        IntArray pickupLocation =
+          (problemInstance as IPickupAndDeliveryProblemInstance).PickupDeliveryLocation;
+
+        int location = pickupLocation[move.City];
+        Tour oldTour2 = solution.Tours.Find(t => t.Stops.Contains(location));
+        oldTour2.Stops.Remove(location);
+
+        location = pickupLocation[move.Replaced];
+        oldTour2 = solution.Tours.Find(t => t.Stops.Contains(location));
+
+        oldTour2.Stops.Remove(location);
+        tour.Stops.Remove(move.Replaced);
+
+        PotvinPDRearrangeMoveMaker.InsertPair(solution, tour, move.City, pickupLocation[move.City], problemInstance);
+        PotvinPDRearrangeMoveMaker.InsertPair(solution, oldTour, move.Replaced, pickupLocation[move.Replaced], problemInstance);
+      } else {
+        tour.Stops.Remove(move.Replaced);
+
+        int place = solution.FindBestInsertionPlace(tour, move.City);
+        tour.Stops.Insert(place, move.City);
+
+        place = solution.FindBestInsertionPlace(oldTour, move.Replaced);
+        oldTour.Stops.Insert(place, move.Replaced);
+      }
+    }
+
+    protected override void PerformMove() {
+      PotvinPDExchangeMove move = PDExchangeMoveParameter.ActualValue;
+
+      PotvinEncoding newSolution = move.Individual.Clone() as PotvinEncoding;
+      Apply(newSolution, move, ProblemInstance);
+      VRPToursParameter.ActualValue = newSolution;
+
+      //reset move quality
+      VRPEvaluation eval = ProblemInstance.Evaluate(newSolution);
+      MoveQualityParameter.ActualValue.Value = eval.Quality;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveTabuCriterion.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveTabuCriterion.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveTabuCriterion.cs	(revision 6773)
@@ -0,0 +1,147 @@
+﻿#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.Common;
+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;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDExchangeTabuCriterion", @"Checks if a certain exchange move is tabu.")]
+  [StorableClass]
+  public class PotvinPDExchangeTabuCriterion : SingleSuccessorOperator, IPotvinPDExchangeMoveOperator, ITabuChecker, IPotvinOperator, IVRPMoveOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<PotvinPDExchangeMove> PDExchangeMoveParameter {
+      get { return (ILookupParameter<PotvinPDExchangeMove>)Parameters["PotvinPDExchangeMove"]; }
+    }
+    public ILookupParameter VRPMoveParameter {
+      get { return PDExchangeMoveParameter; }
+    }
+    public ILookupParameter<IVRPEncoding> VRPToursParameter {
+      get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPTours"]; }
+    }
+    public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter {
+      get { return (LookupParameter<IVRPProblemInstance>)Parameters["ProblemInstance"]; }
+    }  
+
+    public ILookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (ILookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MoveTabu"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ValueParameter<BoolValue> UseAspirationCriterionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseAspirationCriterion"]; }
+    }
+
+    public ILookupParameter<DoubleValue> MoveDistanceParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveDistance"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveOverloadParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveOverload"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveTardinessParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveTardiness"]; }
+    }
+
+    public BoolValue UseAspirationCriterion {
+      get { return UseAspirationCriterionParameter.Value; }
+      set { UseAspirationCriterionParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected PotvinPDExchangeTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected PotvinPDExchangeTabuCriterion(PotvinPDExchangeTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public PotvinPDExchangeTabuCriterion()
+      : base() {
+      Parameters.Add(new LookupParameter<PotvinPDExchangeMove>("PotvinPDExchangeMove", "The moves that should be made."));
+      Parameters.Add(new LookupParameter<IVRPEncoding>("VRPTours", "The VRP tours considered in the move."));
+      Parameters.Add(new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The VRP problem instance"));
+
+      Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseAspirationCriterion", "Whether to use the aspiration criterion or not.", new BoolValue(true)));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the current move."));
+
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveDistance", "The distance of the move"));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveOverload", "The overload of the move"));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveTardiness", "The tardiness of the move"));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDExchangeTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool useAspiration = UseAspirationCriterion.Value;
+      bool isTabu = false;
+      PotvinPDExchangeMove move = PDExchangeMoveParameter.ActualValue;
+
+      foreach (IItem tabuMove in tabuList) {
+        PotvinPDRelocateMoveAttribute attribute = tabuMove as PotvinPDRelocateMoveAttribute;
+
+        if (!useAspiration || moveQuality >= attribute.MoveQuality) {
+          if ((attribute.City == move.City && attribute.Tour == move.Tour) || 
+            (attribute.City == move.Replaced && attribute.Tour == move.OldTour)) {
+            isTabu = true;
+            break;
+          }
+
+          double distance = 0;
+          if (MoveDistanceParameter.ActualValue != null)
+            distance = MoveDistanceParameter.ActualValue.Value;
+
+          double overload = 0;
+          if (MoveOverloadParameter.ActualValue != null)
+            overload = MoveOverloadParameter.ActualValue.Value;
+
+          double tardiness = 0;
+          if (MoveTardinessParameter.ActualValue != null)
+            tardiness = MoveTardinessParameter.ActualValue.Value;
+
+          if (attribute.Distance == distance && attribute.Overload == overload && attribute.Tardiness == tardiness) {
+            isTabu = true;
+            break;
+          }
+        }
+      }
+      
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveTabuMaker.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveTabuMaker.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMoveTabuMaker.cs	(revision 6773)
@@ -0,0 +1,135 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Operators;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDExchangeMoveTabuMaker", "Declares a given exchange move as tabu.")]
+  [StorableClass]
+  public class PotvinPDExchangeMoveTabuMaker : SingleSuccessorOperator, ITabuMaker, IPotvinPDExchangeMoveOperator, IPotvinOperator, IVRPMoveOperator {
+    public LookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (LookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ValueLookupParameter<IntValue> TabuTenureParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["TabuTenure"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+
+    
+    public ILookupParameter<PotvinPDExchangeMove> PDExchangeMoveParameter {
+      get { return (ILookupParameter<PotvinPDExchangeMove>)Parameters["PotvinPDExchangeMove"]; }
+    }
+    public ILookupParameter VRPMoveParameter {
+      get { return PDExchangeMoveParameter; }
+    }
+    public ILookupParameter<IVRPEncoding> VRPToursParameter {
+      get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPTours"]; }
+    }
+    public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter {
+      get { return (LookupParameter<IVRPProblemInstance>)Parameters["ProblemInstance"]; }
+    }
+
+    public ILookupParameter<DoubleValue> DistanceParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Distance"]; }
+    }
+    public ILookupParameter<DoubleValue> OverloadParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Overload"]; }
+    }
+    public ILookupParameter<DoubleValue> TardinessParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Tardiness"]; }
+    }
+
+    [StorableConstructor]
+    protected PotvinPDExchangeMoveTabuMaker(bool deserializing) : base(deserializing) { }
+    protected PotvinPDExchangeMoveTabuMaker(PotvinPDExchangeMoveTabuMaker original, Cloner cloner) : base(original, cloner) { }
+    public PotvinPDExchangeMoveTabuMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list where move attributes are stored."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("TabuTenure", "The tenure of the tabu list."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the move."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+
+        Parameters.Add(new LookupParameter<PotvinPDExchangeMove>("PotvinPDExchangeMove", "The moves that should be made."));
+        Parameters.Add(new LookupParameter<IVRPEncoding>("VRPTours", "The VRP tours considered in the move."));
+        Parameters.Add(new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The VRP problem instance"));
+
+        Parameters.Add(new LookupParameter<DoubleValue>("Distance", "The distance of the individual"));
+        Parameters.Add(new LookupParameter<DoubleValue>("Overload", "The overload of the individual"));
+        Parameters.Add(new LookupParameter<DoubleValue>("Tardiness", "The tardiness of the individual"));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDExchangeMoveTabuMaker(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      int tabuTenure = TabuTenureParameter.ActualValue.Value;
+
+      int overlength = tabuList.Count - tabuTenure;
+      if (overlength >= 0) {
+        for (int i = 0; i < tabuTenure - 1; i++)
+          tabuList[i] = tabuList[i + overlength + 1];
+        while (tabuList.Count >= tabuTenure)
+          tabuList.RemoveAt(tabuList.Count - 1);
+      }
+
+      PotvinPDExchangeMove move = PDExchangeMoveParameter.ActualValue;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      double quality = QualityParameter.ActualValue.Value;
+      double baseQuality = moveQuality;
+      if (quality < moveQuality) baseQuality = quality; // we make an uphill move, the lower bound is the solution quality
+
+      double distance = 0;
+      if (DistanceParameter.ActualValue != null)
+        distance = DistanceParameter.ActualValue.Value;
+
+      double overload = 0;
+      if (OverloadParameter.ActualValue != null)
+        overload = OverloadParameter.ActualValue.Value;
+
+      double tardiness = 0;
+      if (TardinessParameter.ActualValue != null)
+        tardiness = TardinessParameter.ActualValue.Value;
+
+      tabuList.Add(new PotvinPDRelocateMoveAttribute(baseQuality, move.OldTour, move.City, distance, overload, tardiness));
+      tabuList.Add(new PotvinPDRelocateMoveAttribute(baseQuality, move.Tour, move.Replaced, distance, overload, tardiness));
+      return base.Apply();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMultiMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMultiMoveGenerator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeMultiMoveGenerator.cs	(revision 6773)
@@ -0,0 +1,72 @@
+﻿#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.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDExchangeMultiMoveGenerator", "Generates exchange moves from a given PDP encoding.")]
+  [StorableClass]
+  public sealed class PotvinPDExchangeMultiMoveGenerator : PotvinPDExchangeMoveGenerator, IMultiMoveGenerator, IMultiVRPMoveGenerator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDExchangeMultiMoveGenerator(this, cloner);
+    }
+
+    [StorableConstructor]
+    private PotvinPDExchangeMultiMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDExchangeMultiMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));
+    }
+
+    private PotvinPDExchangeMultiMoveGenerator(PotvinPDExchangeMultiMoveGenerator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected override PotvinPDExchangeMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
+      List<PotvinPDExchangeMove> result = new List<PotvinPDExchangeMove>();
+
+      for (int i = 0; i < SampleSizeParameter.ActualValue.Value; i++) {
+        result.Add(PotvinPDExchangeSingleMoveGenerator.Apply(individual, ProblemInstance, RandomParameter.ActualValue));
+      }
+
+      return result.ToArray();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeSingleMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeSingleMoveGenerator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDExchange/PotvinPDExchangeSingleMoveGenerator.cs	(revision 6773)
@@ -0,0 +1,112 @@
+﻿#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.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDExchangeSingleMoveGenerator", "Generates a single exchange move from a given PDP encoding.")]
+  [StorableClass]
+  public sealed class PotvinPDExchangeSingleMoveGenerator : PotvinPDExchangeMoveGenerator,
+    ISingleMoveGenerator {    
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDExchangeSingleMoveGenerator(this, cloner);
+    }
+
+    [StorableConstructor]
+    private PotvinPDExchangeSingleMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDExchangeSingleMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+    }
+
+    private PotvinPDExchangeSingleMoveGenerator(PotvinPDExchangeSingleMoveGenerator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public static PotvinPDExchangeMove Apply(PotvinEncoding individual, IVRPProblemInstance problemInstance, IRandom rand) {
+      List<int> cities = new List<int>();
+
+      IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
+      for (int i = 1; i <= individual.Cities; i++) {
+        if (pdp == null || pdp.Demand[i] >= 0)
+          cities.Add(i);
+      }
+
+      PotvinPDExchangeMove move = null;
+      while (cities.Count > 0 && move == null) {
+        int city = cities[rand.Next(cities.Count)];
+        Tour oldTour = individual.Tours.Find(t => t.Stops.Contains(city));
+        int oldTourIndex = individual.Tours.IndexOf(oldTour);
+
+        int max = individual.Tours.Count;
+        if (individual.Tours.Count < problemInstance.Vehicles.Value)
+          max = max - 1;
+
+        int newTourIndex = rand.Next(max);
+        if (newTourIndex >= oldTourIndex)
+          newTourIndex++;
+
+        Tour newTour = individual.Tours[newTourIndex];
+        List<int> tourCities = new List<int>();
+        foreach (int stop in newTour.Stops) {
+          if (pdp == null ||
+            (pdp.Demand[stop] >= 0 &&
+             pdp.PickupDeliveryLocation[stop] != pdp.PickupDeliveryLocation[city] &&
+             pdp.PickupDeliveryLocation[stop] != city &&
+             pdp.PickupDeliveryLocation[city] != stop))
+            tourCities.Add(stop);
+        }
+
+        if (tourCities.Count > 0) {
+          int replaced = tourCities[rand.Next(tourCities.Count)];
+          move = new PotvinPDExchangeMove(city, oldTourIndex, newTourIndex, replaced, individual);
+        }
+      }
+
+      return move;
+    }
+
+    protected override PotvinPDExchangeMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
+      List<PotvinPDExchangeMove> result = new List<PotvinPDExchangeMove>();
+
+      PotvinPDExchangeMove move = Apply(individual, ProblemInstance, RandomParameter.ActualValue);
+      if (move != null)
+        result.Add(move);
+
+      return result.ToArray();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/IPotvinPDRearrangeMoveOperator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/IPotvinPDRearrangeMoveOperator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/IPotvinPDRearrangeMoveOperator.cs	(revision 6773)
@@ -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 HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  public interface IPotvinPDRearrangeMoveOperator : IVRPMoveOperator {
+    ILookupParameter<PotvinPDRearrangeMove> PDRearrangeMoveParameter { get; }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeExhaustiveMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeExhaustiveMoveGenerator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeExhaustiveMoveGenerator.cs	(revision 6773)
@@ -0,0 +1,66 @@
+﻿#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.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDRearrangeExhaustiveMoveGenerator", "Generates rearrange moves from a given PDP encoding.")]
+  [StorableClass]
+  public sealed class PotvinPDRearrangeExhaustiveMoveGenerator : PotvinPDRearrangeMoveGenerator, IExhaustiveMoveGenerator {
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDRearrangeExhaustiveMoveGenerator(this, cloner);
+    }
+
+    [StorableConstructor]
+    private PotvinPDRearrangeExhaustiveMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDRearrangeExhaustiveMoveGenerator()
+      : base() {
+    }
+
+    private PotvinPDRearrangeExhaustiveMoveGenerator(PotvinPDRearrangeExhaustiveMoveGenerator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected override PotvinPDRearrangeMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
+      List<PotvinPDRearrangeMove> result = new List<PotvinPDRearrangeMove>();
+      IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
+
+      for (int i = 1; i <= problemInstance.Cities.Value; i++) {
+        if (pdp == null || pdp.Demand[i] >= 0) {
+          int tour = individual.Tours.FindIndex(t => t.Stops.Contains(i));
+
+          result.Add(new PotvinPDRearrangeMove(i, tour, individual));
+        }
+      }
+
+      return result.ToArray();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMove.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMove.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMove.cs	(revision 6773)
@@ -0,0 +1,119 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDRearrangeMove", "Item that describes a rearrange move on a PDP representation.")]
+  [StorableClass]
+  public class PotvinPDRearrangeMove: Item, IVRPMove {
+    [Storable]
+    public IVRPEncoding Individual { get; protected set; }
+    
+    [Storable]
+    public int City { get; protected set; }
+
+    [Storable]
+    public int Tour { get; protected set; }
+   
+    public PotvinPDRearrangeMove(): base() {
+      City = -1;
+      Tour = -1;
+
+      Individual = null;
+    }
+
+    public PotvinPDRearrangeMove(int city, int tour, PotvinEncoding individual) {
+      City = city;
+      Tour = tour;
+
+      this.Individual = individual.Clone() as PotvinEncoding;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDRearrangeMove(this, cloner);
+    }
+
+    protected PotvinPDRearrangeMove(PotvinPDRearrangeMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.City = original.City;
+      this.Tour = original.Tour;
+
+      this.Individual = cloner.Clone(Individual) as PotvinEncoding;
+    }
+
+    #region IVRPMove Members
+
+    private static PotvinPDRearrangeMoveEvaluator moveEvaluator;
+    public VRPMoveEvaluator GetMoveEvaluator() {
+      if(moveEvaluator == null)
+        moveEvaluator = new PotvinPDRearrangeMoveEvaluator();
+
+      return moveEvaluator;
+    }
+
+    private static PotvinPDRearrangeMoveMaker moveMaker;
+    public VRPMoveMaker GetMoveMaker() {
+      if (moveMaker == null)
+        moveMaker = new PotvinPDRearrangeMoveMaker();
+
+      return moveMaker;
+    }
+
+    private static PotvinPDRearrangeMoveTabuMaker tabuMaker;
+    public ITabuMaker GetTabuMaker() {
+      if (tabuMaker == null)
+        tabuMaker = new PotvinPDRearrangeMoveTabuMaker();
+
+      return tabuMaker;
+    }
+
+    private static PotvinPDRearrangeTabuCriterion tabuChecker;
+    public ITabuChecker GetTabuChecker() {
+      if (tabuChecker == null) {
+        tabuChecker = new PotvinPDRearrangeTabuCriterion();
+        tabuChecker.UseAspirationCriterion.Value = false;
+      }
+
+      return tabuChecker;
+    }
+
+    private static PotvinPDRearrangeTabuCriterion softTabuChecker;
+    public ITabuChecker GetSoftTabuChecker() {
+      if (softTabuChecker == null) {
+        softTabuChecker = new PotvinPDRearrangeTabuCriterion();
+        softTabuChecker.UseAspirationCriterion.Value = true;
+      }
+
+      return softTabuChecker;
+    }
+
+    #endregion
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveEvaluator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveEvaluator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveEvaluator.cs	(revision 6773)
@@ -0,0 +1,83 @@
+﻿#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.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using HeuristicLab.Common;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDRearrangeMoveEvaluator", "Evaluates a rearrange move for a PDP representation. ")]
+  [StorableClass]
+  public sealed class PotvinPDRearrangeMoveEvaluator : PotvinMoveEvaluator, IPotvinPDRearrangeMoveOperator {
+    public ILookupParameter<PotvinPDRearrangeMove> PDRearrangeMoveParameter {
+      get { return (ILookupParameter<PotvinPDRearrangeMove>)Parameters["PotvinPDRearrangeMove"]; }
+    }
+
+    public override ILookupParameter VRPMoveParameter {
+      get { return PDRearrangeMoveParameter; }
+    }
+
+    public ILookupParameter<VariableCollection> MemoriesParameter {
+      get { return (ILookupParameter<VariableCollection>)Parameters["Memories"]; }
+    }
+
+    public IValueParameter<StringValue> AdditionFrequencyMemoryKeyParameter {
+      get { return (IValueParameter<StringValue>)Parameters["AdditionFrequencyMemoryKey"]; }
+    }
+
+    public IValueParameter<DoubleValue> LambdaParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["Lambda"]; }
+    }
+
+    [StorableConstructor]
+    private PotvinPDRearrangeMoveEvaluator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDRearrangeMoveEvaluator()
+      : base() {
+        Parameters.Add(new LookupParameter<PotvinPDRearrangeMove>("PotvinPDRearrangeMove", "The move that should be evaluated."));
+
+       Parameters.Add(new LookupParameter<VariableCollection>("Memories", "The TS memory collection."));
+       Parameters.Add(new ValueParameter<StringValue>("AdditionFrequencyMemoryKey", "The key that is used for the addition frequency in the TS memory.", new StringValue("AdditionFrequency")));
+       Parameters.Add(new ValueParameter<DoubleValue>("Lambda", "The lambda parameter.", new DoubleValue(0.015)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDRearrangeMoveEvaluator(this, cloner);
+    }
+
+    private PotvinPDRearrangeMoveEvaluator(PotvinPDRearrangeMoveEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected override void EvaluateMove() {
+      PotvinPDRearrangeMove move = PDRearrangeMoveParameter.ActualValue;
+
+      PotvinEncoding newSolution = PDRearrangeMoveParameter.ActualValue.Individual.Clone() as PotvinEncoding;
+      PotvinPDRearrangeMoveMaker.Apply(newSolution, move, ProblemInstance);
+
+      UpdateEvaluation(newSolution);
+    } 
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveGenerator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveGenerator.cs	(revision 6773)
@@ -0,0 +1,77 @@
+﻿#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.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDRearrangeMoveGenerator", "Generates rearrange moves from a given PDP encoding.")]
+  [StorableClass]
+  public abstract class PotvinPDRearrangeMoveGenerator : PotvinMoveGenerator, IPotvinPDRearrangeMoveOperator {
+    public ILookupParameter<PotvinPDRearrangeMove> PDRearrangeMoveParameter {
+      get { return (ILookupParameter<PotvinPDRearrangeMove>)Parameters["PotvinPDRearrangeMove"]; }
+    }
+
+    public override ILookupParameter VRPMoveParameter {
+      get { return PDRearrangeMoveParameter; }
+    }
+
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    [StorableConstructor]
+    protected PotvinPDRearrangeMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDRearrangeMoveGenerator()
+      : base() {
+        Parameters.Add(new LookupParameter<PotvinPDRearrangeMove>("PotvinPDRearrangeMove", "The moves that should be generated in subscopes."));
+        Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
+    }
+
+    protected PotvinPDRearrangeMoveGenerator(PotvinPDRearrangeMoveGenerator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected abstract PotvinPDRearrangeMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
+
+    public override IOperation Apply() {
+      IOperation next = base.Apply();
+
+      PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
+      PotvinPDRearrangeMove[] moves = GenerateMoves(individual, ProblemInstance);
+      Scope[] moveScopes = new Scope[moves.Length];
+      for (int i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        moveScopes[i].Variables.Add(new Variable(PDRearrangeMoveParameter.ActualName, moves[i]));
+      }
+      CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
+
+      return next;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveMaker.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveMaker.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveMaker.cs	(revision 6773)
@@ -0,0 +1,126 @@
+﻿#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.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDRearrangeMoveMaker", "Peforms the rearrange move on a given PDP encoding and updates the quality.")]
+  [StorableClass]
+  public class PotvinPDRearrangeMoveMaker : PotvinMoveMaker, IPotvinPDRearrangeMoveOperator, IMoveMaker {
+    public ILookupParameter<PotvinPDRearrangeMove> PDRearrangeMoveParameter {
+      get { return (ILookupParameter<PotvinPDRearrangeMove>)Parameters["PotvinPDRearrangeMove"]; }
+    }
+
+    public override ILookupParameter VRPMoveParameter {
+      get { return PDRearrangeMoveParameter; }
+    }
+
+    [StorableConstructor]
+    private PotvinPDRearrangeMoveMaker(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDRearrangeMoveMaker()
+      : base() {
+        Parameters.Add(new LookupParameter<PotvinPDRearrangeMove>("PotvinPDRearrangeMove", "The moves that should be made."));
+     }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDRearrangeMoveMaker(this, cloner);
+    }
+
+    protected PotvinPDRearrangeMoveMaker(PotvinPDRearrangeMoveMaker original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public static void InsertPair(PotvinEncoding solution, Tour tour, int source, int target, IVRPProblemInstance problemInstance, int positionToAvoid = -1, int positionToAvoid2 = -1) {
+      int stops = tour.Stops.Count;
+      VRPEvaluation eval = problemInstance.Evaluate(tour);
+      double minCosts = double.MaxValue;
+      int sourceLocation = -1;
+      int targetLocation = -1;
+
+      for (int i = 0; i <= stops; i++) {
+        tour.Stops.Insert(i, source);
+        VRPEvaluation tourEval = problemInstance.Evaluate(tour);
+        double sourceCosts = tourEval.Quality - eval.Quality;
+
+        for (int j = i + 1; j <= stops + 1; j++) {
+          if (positionToAvoid != i || positionToAvoid2 != j) {
+            bool feasible;
+            double targetCosts = problemInstance.GetInsertionCosts(tourEval, target, 0, j, out feasible);
+
+            double costs = sourceCosts + targetCosts;
+            if (costs < minCosts) {
+              minCosts = costs;
+              sourceLocation = i;
+              targetLocation = j;
+            }
+          }
+        }
+        tour.Stops.Remove(source);
+      }
+
+      tour.Stops.Insert(sourceLocation, source);
+      tour.Stops.Insert(targetLocation, target);
+    }
+
+    public static void Apply(PotvinEncoding solution, PotvinPDRearrangeMove move, IVRPProblemInstance problemInstance) {
+      Tour tour = solution.Tours[move.Tour];
+      int position = tour.Stops.IndexOf(move.City);
+
+      IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
+      if (pdp != null) {
+        int location = pdp.PickupDeliveryLocation[move.City];
+        Tour tour2 = solution.Tours.Find(t => t.Stops.Contains(location));
+        int position2 = tour2.Stops.IndexOf(location);
+
+        tour.Stops.Remove(move.City);
+        tour2.Stops.Remove(location);
+
+        PotvinPDRearrangeMoveMaker.InsertPair(solution, tour, move.City, location, problemInstance, position, position2);
+      } else {
+        tour.Stops.Remove(move.City);
+        int place = solution.FindBestInsertionPlace(tour, move.City, position);
+        tour.Stops.Insert(place, move.City);
+      }
+    }
+
+    protected override void PerformMove() {
+      PotvinPDRearrangeMove move = PDRearrangeMoveParameter.ActualValue;
+
+      PotvinEncoding newSolution = move.Individual.Clone() as PotvinEncoding;
+      Apply(newSolution, move, ProblemInstance);
+      VRPToursParameter.ActualValue = newSolution;
+
+      //reset move quality
+      VRPEvaluation eval = ProblemInstance.Evaluate(newSolution);
+      MoveQualityParameter.ActualValue.Value = eval.Quality;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveTabuCriterion.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveTabuCriterion.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveTabuCriterion.cs	(revision 6773)
@@ -0,0 +1,146 @@
+﻿#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.Common;
+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;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDRearrangeTabuCriterion", @"Checks if a certain rearrange move is tabu.")]
+  [StorableClass]
+  public class PotvinPDRearrangeTabuCriterion : SingleSuccessorOperator, IPotvinPDRearrangeMoveOperator, ITabuChecker, IPotvinOperator, IVRPMoveOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<PotvinPDRearrangeMove> PDRearrangeMoveParameter {
+      get { return (ILookupParameter<PotvinPDRearrangeMove>)Parameters["PotvinPDRearrangeMove"]; }
+    }
+    public ILookupParameter VRPMoveParameter {
+      get { return PDRearrangeMoveParameter; }
+    }
+    public ILookupParameter<IVRPEncoding> VRPToursParameter {
+      get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPTours"]; }
+    }
+    public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter {
+      get { return (LookupParameter<IVRPProblemInstance>)Parameters["ProblemInstance"]; }
+    }  
+
+    public ILookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (ILookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MoveTabu"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ValueParameter<BoolValue> UseAspirationCriterionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseAspirationCriterion"]; }
+    }
+
+    public ILookupParameter<DoubleValue> MoveDistanceParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveDistance"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveOverloadParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveOverload"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveTardinessParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveTardiness"]; }
+    }
+
+    public BoolValue UseAspirationCriterion {
+      get { return UseAspirationCriterionParameter.Value; }
+      set { UseAspirationCriterionParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected PotvinPDRearrangeTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected PotvinPDRearrangeTabuCriterion(PotvinPDRearrangeTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public PotvinPDRearrangeTabuCriterion()
+      : base() {
+      Parameters.Add(new LookupParameter<PotvinPDRearrangeMove>("PotvinPDRearrangeMove", "The moves that should be made."));
+      Parameters.Add(new LookupParameter<IVRPEncoding>("VRPTours", "The VRP tours considered in the move."));
+      Parameters.Add(new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The VRP problem instance"));
+
+      Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseAspirationCriterion", "Whether to use the aspiration criterion or not.", new BoolValue(true)));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the current move."));
+
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveDistance", "The distance of the move"));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveOverload", "The overload of the move"));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveTardiness", "The tardiness of the move"));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDRearrangeTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool useAspiration = UseAspirationCriterion.Value;
+      bool isTabu = false;
+      PotvinPDRearrangeMove move = PDRearrangeMoveParameter.ActualValue;
+
+      foreach (IItem tabuMove in tabuList) {
+        PotvinPDRelocateMoveAttribute attribute = tabuMove as PotvinPDRelocateMoveAttribute;
+
+        if (!useAspiration || moveQuality >= attribute.MoveQuality) {
+          if (attribute.City == move.City && attribute.Tour == move.Tour) {
+            isTabu = true;
+            break;
+          }
+
+          double distance = 0;
+          if (MoveDistanceParameter.ActualValue != null)
+            distance = MoveDistanceParameter.ActualValue.Value;
+
+          double overload = 0;
+          if (MoveOverloadParameter.ActualValue != null)
+            overload = MoveOverloadParameter.ActualValue.Value;
+
+          double tardiness = 0;
+          if (MoveTardinessParameter.ActualValue != null)
+            tardiness = MoveTardinessParameter.ActualValue.Value;
+
+          if (attribute.Distance == distance && attribute.Overload == overload && attribute.Tardiness == tardiness) {
+            isTabu = true;
+            break;
+          }
+        }
+      }
+      
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveTabuMaker.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveTabuMaker.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMoveTabuMaker.cs	(revision 6773)
@@ -0,0 +1,96 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using System.Collections.Generic;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDRearrangeMoveTabuMaker", "Declares a given rearrange move as tabu.")]
+  [StorableClass]
+  public class PotvinPDRearrangeMoveTabuMaker : TabuMaker, IPotvinPDRearrangeMoveOperator, IPotvinOperator, IVRPMoveOperator {
+    public ILookupParameter<PotvinPDRearrangeMove> PDRearrangeMoveParameter {
+      get { return (ILookupParameter<PotvinPDRearrangeMove>)Parameters["PotvinPDRearrangeMove"]; }
+    }
+    public ILookupParameter VRPMoveParameter {
+      get { return PDRearrangeMoveParameter; }
+    }
+    public ILookupParameter<IVRPEncoding> VRPToursParameter {
+      get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPTours"]; }
+    }
+    public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter {
+      get { return (LookupParameter<IVRPProblemInstance>)Parameters["ProblemInstance"]; }
+    }
+
+    public ILookupParameter<DoubleValue> DistanceParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Distance"]; }
+    }
+    public ILookupParameter<DoubleValue> OverloadParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Overload"]; }
+    }
+    public ILookupParameter<DoubleValue> TardinessParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Tardiness"]; }
+    }
+
+    [StorableConstructor]
+    protected PotvinPDRearrangeMoveTabuMaker(bool deserializing) : base(deserializing) { }
+    protected PotvinPDRearrangeMoveTabuMaker(PotvinPDRearrangeMoveTabuMaker original, Cloner cloner) : base(original, cloner) { }
+    public PotvinPDRearrangeMoveTabuMaker()
+      : base() {
+        Parameters.Add(new LookupParameter<PotvinPDRearrangeMove>("PotvinPDRearrangeMove", "The moves that should be made."));
+        Parameters.Add(new LookupParameter<IVRPEncoding>("VRPTours", "The VRP tours considered in the move."));
+        Parameters.Add(new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The VRP problem instance"));
+
+        Parameters.Add(new LookupParameter<DoubleValue>("Distance", "The distance of the individual"));
+        Parameters.Add(new LookupParameter<DoubleValue>("Overload", "The overload of the individual"));
+        Parameters.Add(new LookupParameter<DoubleValue>("Tardiness", "The tardiness of the individual"));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDRearrangeMoveTabuMaker(this, cloner);
+    }
+
+    protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) {
+      PotvinPDRearrangeMove move = PDRearrangeMoveParameter.ActualValue;
+      double baseQuality = moveQuality;
+      if (quality < moveQuality) baseQuality = quality; // we make an uphill move, the lower bound is the solution quality
+
+      double distance = 0;
+      if (DistanceParameter.ActualValue != null)
+        distance = DistanceParameter.ActualValue.Value;
+
+      double overload = 0;
+      if (OverloadParameter.ActualValue != null)
+        overload = OverloadParameter.ActualValue.Value;
+
+      double tardiness = 0;
+      if (TardinessParameter.ActualValue != null)
+        tardiness = TardinessParameter.ActualValue.Value;
+
+      return new PotvinPDRelocateMoveAttribute(baseQuality, move.Tour, move.City, distance, overload, tardiness);
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMultiMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMultiMoveGenerator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeMultiMoveGenerator.cs	(revision 6773)
@@ -0,0 +1,72 @@
+﻿#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.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDRearrangeMultiMoveGenerator", "Generates rearrange moves from a given PDP encoding.")]
+  [StorableClass]
+  public sealed class PotvinPDRearrangeMultiMoveGenerator : PotvinPDRearrangeMoveGenerator, IMultiMoveGenerator, IMultiVRPMoveGenerator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDRearrangeMultiMoveGenerator(this, cloner);
+    }
+
+    [StorableConstructor]
+    private PotvinPDRearrangeMultiMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDRearrangeMultiMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));
+    }
+
+    private PotvinPDRearrangeMultiMoveGenerator(PotvinPDRearrangeMultiMoveGenerator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected override PotvinPDRearrangeMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
+      List<PotvinPDRearrangeMove> result = new List<PotvinPDRearrangeMove>();
+
+      for (int i = 0; i < SampleSizeParameter.ActualValue.Value; i++) {
+        result.Add(PotvinPDRearrangeSingleMoveGenerator.Apply(individual, ProblemInstance, RandomParameter.ActualValue));
+      }
+
+      return result.ToArray();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeSingleMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeSingleMoveGenerator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDRearrange/PotvinPDRearrangeSingleMoveGenerator.cs	(revision 6773)
@@ -0,0 +1,83 @@
+﻿#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.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDRearrangeSingleMoveGenerator", "Generates a single rearrange move from a given PDP encoding.")]
+  [StorableClass]
+  public sealed class PotvinPDRearrangeSingleMoveGenerator : PotvinPDRearrangeMoveGenerator,
+    ISingleMoveGenerator {    
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDRearrangeSingleMoveGenerator(this, cloner);
+    }
+
+    [StorableConstructor]
+    private PotvinPDRearrangeSingleMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDRearrangeSingleMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+    }
+
+    private PotvinPDRearrangeSingleMoveGenerator(PotvinPDRearrangeSingleMoveGenerator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public static PotvinPDRearrangeMove Apply(PotvinEncoding individual, IVRPProblemInstance problemInstance, IRandom rand) {
+      List<int> cities = new List<int>();
+
+      IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
+      for (int i = 1; i <= individual.Cities; i++) {
+        if(pdp == null || pdp.Demand[i] >= 0)
+          cities.Add(i);
+      }
+
+      int city = cities[rand.Next(cities.Count)];
+      int tour = individual.Tours.FindIndex(t => t.Stops.Contains(city));
+      return new PotvinPDRearrangeMove(city, tour, individual);
+    }
+
+    protected override PotvinPDRearrangeMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
+      List<PotvinPDRearrangeMove> result = new List<PotvinPDRearrangeMove>();
+
+      PotvinPDRearrangeMove move = Apply(individual, ProblemInstance, RandomParameter.ActualValue);
+      if (move != null)
+        result.Add(move);
+
+      return result.ToArray();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/IPotvinPDShiftMoveOperator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/IPotvinPDShiftMoveOperator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/IPotvinPDShiftMoveOperator.cs	(revision 6773)
@@ -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 HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  public interface IPotvinPDShiftMoveOperator : IVRPMoveOperator {
+    ILookupParameter<PotvinPDShiftMove> PDShiftMoveParameter { get; }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftExhaustiveMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftExhaustiveMoveGenerator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftExhaustiveMoveGenerator.cs	(revision 6773)
@@ -0,0 +1,78 @@
+﻿#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.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDShiftExhaustiveMoveGenerator", "Generates shift moves from a given PDP encoding.")]
+  [StorableClass]
+  public sealed class PotvinPDShiftExhaustiveMoveGenerator : PotvinPDShiftMoveGenerator, IExhaustiveMoveGenerator {
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDShiftExhaustiveMoveGenerator(this, cloner);
+    }
+
+    [StorableConstructor]
+    private PotvinPDShiftExhaustiveMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDShiftExhaustiveMoveGenerator()
+      : base() {
+    }
+
+    private PotvinPDShiftExhaustiveMoveGenerator(PotvinPDShiftExhaustiveMoveGenerator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected override PotvinPDShiftMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
+      List<PotvinPDShiftMove> result = new List<PotvinPDShiftMove>();
+      IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
+
+      int max = individual.Tours.Count;
+      if (individual.Tours.Count < problemInstance.Vehicles.Value)
+        max = max - 1;
+
+      for (int i = 0; i < individual.Tours.Count; i++) {
+        for (int j = 0; j < individual.Tours[i].Stops.Count; j++) {
+          for (int k = 0; k <= max; k++) {
+            if (k != i) {
+              int city = individual.Tours[i].Stops[j];
+              if (pdp == null || pdp.Demand[city] >= 0) {
+                PotvinPDShiftMove move = new PotvinPDShiftMove(
+                  city, i, k, individual);
+
+                result.Add(move);
+              }
+            }
+          }
+        }
+      }
+
+      return result.ToArray();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMove.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMove.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMove.cs	(revision 6773)
@@ -0,0 +1,123 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDShiftMove", "Item that describes a shift move on a PDP representation.")]
+  [StorableClass]
+  public class PotvinPDShiftMove: Item, IVRPMove {
+    [Storable]
+    public IVRPEncoding Individual { get; protected set; }
+    
+    [Storable]
+    public int City { get; protected set; }
+
+    [Storable]
+    public int OldTour { get; protected set; }
+
+    [Storable]
+    public int Tour { get; protected set; }
+   
+    public PotvinPDShiftMove(): base() {
+      City = -1;
+      Tour = -1;
+
+      Individual = null;
+    }
+
+    public PotvinPDShiftMove(int city, int oldTour, int tour, PotvinEncoding individual) {
+      City = city;
+      OldTour = oldTour;
+      Tour = tour;
+
+      this.Individual = individual.Clone() as PotvinEncoding;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDShiftMove(this, cloner);
+    }
+
+    protected PotvinPDShiftMove(PotvinPDShiftMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.City = original.City;
+      this.OldTour = original.OldTour;
+      this.Tour = original.Tour;
+
+      this.Individual = cloner.Clone(Individual) as PotvinEncoding;
+    }
+
+    #region IVRPMove Members
+
+    private static PotvinPDShiftMoveEvaluator moveEvaluator;
+    public VRPMoveEvaluator GetMoveEvaluator() {
+      if (moveEvaluator == null)
+        moveEvaluator = new PotvinPDShiftMoveEvaluator();
+
+      return moveEvaluator;
+    }
+
+    private static PotvinPDShiftMoveMaker moveMaker;
+    public VRPMoveMaker GetMoveMaker() {
+      if (moveMaker == null)
+        moveMaker = new PotvinPDShiftMoveMaker();
+
+      return moveMaker;
+    }
+
+    private static PotvinPDShiftMoveTabuMaker tabuMaker;
+    public ITabuMaker GetTabuMaker() {
+      if (tabuMaker == null)
+        tabuMaker = new PotvinPDShiftMoveTabuMaker();
+
+      return tabuMaker;
+    }
+
+    private static PotvinPDShiftTabuCriterion tabuChecker;
+    public ITabuChecker GetTabuChecker() {
+      if (tabuChecker == null) {
+        tabuChecker = new PotvinPDShiftTabuCriterion();
+        tabuChecker.UseAspirationCriterion.Value = false;
+      }
+
+      return tabuChecker;
+    }
+
+    private static PotvinPDShiftTabuCriterion softTabuChecker;
+    public ITabuChecker GetSoftTabuChecker() {
+      if (softTabuChecker == null) {
+        softTabuChecker = new PotvinPDShiftTabuCriterion();
+        softTabuChecker.UseAspirationCriterion.Value = true;
+      }
+
+      return softTabuChecker;
+    }
+    #endregion
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveEvaluator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveEvaluator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveEvaluator.cs	(revision 6773)
@@ -0,0 +1,83 @@
+﻿#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.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using HeuristicLab.Common;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDShiftMoveEvaluator", "Evaluates a shift move for a PDP representation. ")]
+  [StorableClass]
+  public sealed class PotvinPDShiftMoveEvaluator : PotvinMoveEvaluator, IPotvinPDShiftMoveOperator {
+    public ILookupParameter<PotvinPDShiftMove> PDShiftMoveParameter {
+      get { return (ILookupParameter<PotvinPDShiftMove>)Parameters["PotvinPDShiftMove"]; }
+    }
+
+    public override ILookupParameter VRPMoveParameter {
+      get { return PDShiftMoveParameter; }
+    }
+
+    public ILookupParameter<VariableCollection> MemoriesParameter {
+      get { return (ILookupParameter<VariableCollection>)Parameters["Memories"]; }
+    }
+
+    public IValueParameter<StringValue> AdditionFrequencyMemoryKeyParameter {
+      get { return (IValueParameter<StringValue>)Parameters["AdditionFrequencyMemoryKey"]; }
+    }
+
+    public IValueParameter<DoubleValue> LambdaParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["Lambda"]; }
+    }
+
+    [StorableConstructor]
+    private PotvinPDShiftMoveEvaluator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDShiftMoveEvaluator()
+      : base() {
+        Parameters.Add(new LookupParameter<PotvinPDShiftMove>("PotvinPDShiftMove", "The move that should be evaluated."));
+
+       Parameters.Add(new LookupParameter<VariableCollection>("Memories", "The TS memory collection."));
+       Parameters.Add(new ValueParameter<StringValue>("AdditionFrequencyMemoryKey", "The key that is used for the addition frequency in the TS memory.", new StringValue("AdditionFrequency")));
+       Parameters.Add(new ValueParameter<DoubleValue>("Lambda", "The lambda parameter.", new DoubleValue(0.015)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDShiftMoveEvaluator(this, cloner);
+    }
+
+    private PotvinPDShiftMoveEvaluator(PotvinPDShiftMoveEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected override void EvaluateMove() {
+      PotvinPDShiftMove move = PDShiftMoveParameter.ActualValue;
+
+      PotvinEncoding newSolution = PDShiftMoveParameter.ActualValue.Individual.Clone() as PotvinEncoding;
+      PotvinPDShiftMoveMaker.Apply(newSolution, move, ProblemInstance);
+
+      UpdateEvaluation(newSolution);
+    } 
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveGenerator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveGenerator.cs	(revision 6773)
@@ -0,0 +1,77 @@
+﻿#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.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDShiftMoveGenerator", "Generates shift moves from a given PDP encoding.")]
+  [StorableClass]
+  public abstract class PotvinPDShiftMoveGenerator : PotvinMoveGenerator, IPotvinPDShiftMoveOperator {
+    public ILookupParameter<PotvinPDShiftMove> PDShiftMoveParameter {
+      get { return (ILookupParameter<PotvinPDShiftMove>)Parameters["PotvinPDShiftMove"]; }
+    }
+
+    public override ILookupParameter VRPMoveParameter {
+      get { return PDShiftMoveParameter; }
+    }
+
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    [StorableConstructor]
+    protected PotvinPDShiftMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDShiftMoveGenerator()
+      : base() {
+        Parameters.Add(new LookupParameter<PotvinPDShiftMove>("PotvinPDShiftMove", "The moves that should be generated in subscopes."));
+        Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
+    }
+
+    protected PotvinPDShiftMoveGenerator(PotvinPDShiftMoveGenerator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected abstract PotvinPDShiftMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance);
+
+    public override IOperation Apply() {
+      IOperation next = base.Apply();
+
+      PotvinEncoding individual = VRPToursParameter.ActualValue as PotvinEncoding;
+      PotvinPDShiftMove[] moves = GenerateMoves(individual, ProblemInstance);
+      Scope[] moveScopes = new Scope[moves.Length];
+      for (int i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        moveScopes[i].Variables.Add(new Variable(PDShiftMoveParameter.ActualName, moves[i]));
+      }
+      CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
+
+      return next;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveMaker.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveMaker.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveMaker.cs	(revision 6773)
@@ -0,0 +1,96 @@
+﻿#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.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDShiftMoveMaker", "Peforms the shift move on a given PDP encoding and updates the quality.")]
+  [StorableClass]
+  public class PotvinPDShiftMoveMaker : PotvinMoveMaker, IPotvinPDShiftMoveOperator, IMoveMaker {
+    public ILookupParameter<PotvinPDShiftMove> PDShiftMoveParameter {
+      get { return (ILookupParameter<PotvinPDShiftMove>)Parameters["PotvinPDShiftMove"]; }
+    }
+
+    public override ILookupParameter VRPMoveParameter {
+      get { return PDShiftMoveParameter; }
+    }
+
+    [StorableConstructor]
+    private PotvinPDShiftMoveMaker(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDShiftMoveMaker()
+      : base() {
+        Parameters.Add(new LookupParameter<PotvinPDShiftMove>("PotvinPDShiftMove", "The moves that should be made."));
+     }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDShiftMoveMaker(this, cloner);
+    }
+
+    protected PotvinPDShiftMoveMaker(PotvinPDShiftMoveMaker original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public static void Apply(PotvinEncoding solution, PotvinPDShiftMove move, IVRPProblemInstance problemInstance) {
+      if (move.Tour >= solution.Tours.Count)
+        solution.Tours.Add(new Tour());
+      Tour tour = solution.Tours[move.Tour];
+
+      Tour oldTour = solution.Tours.Find(t => t.Stops.Contains(move.City));
+      oldTour.Stops.Remove(move.City);
+
+      if (problemInstance is IPickupAndDeliveryProblemInstance) {
+        IntArray pickupLocation =
+          (problemInstance as IPickupAndDeliveryProblemInstance).PickupDeliveryLocation;
+
+        int location = pickupLocation[move.City];
+        Tour oldTour2 = solution.Tours.Find(t => t.Stops.Contains(location));
+        oldTour2.Stops.Remove(location);
+
+        PotvinPDRearrangeMoveMaker.InsertPair(solution, tour, move.City, pickupLocation[move.City], problemInstance);
+      } else {
+        int place = solution.FindBestInsertionPlace(tour, move.City);
+        tour.Stops.Insert(place, move.City);
+      }
+    }
+
+    protected override void PerformMove() {
+      PotvinPDShiftMove move = PDShiftMoveParameter.ActualValue;
+
+      PotvinEncoding newSolution = move.Individual.Clone() as PotvinEncoding;
+      Apply(newSolution, move, ProblemInstance);
+      VRPToursParameter.ActualValue = newSolution;
+
+      //reset move quality
+      VRPEvaluation eval = ProblemInstance.Evaluate(newSolution);
+      MoveQualityParameter.ActualValue.Value = eval.Quality;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveTabuCriterion.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveTabuCriterion.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveTabuCriterion.cs	(revision 6773)
@@ -0,0 +1,146 @@
+﻿#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.Common;
+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;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDShiftTabuCriterion", @"Checks if a certain shift move is tabu.")]
+  [StorableClass]
+  public class PotvinPDShiftTabuCriterion : SingleSuccessorOperator, IPotvinPDShiftMoveOperator, ITabuChecker, IPotvinOperator, IVRPMoveOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<PotvinPDShiftMove> PDShiftMoveParameter {
+      get { return (ILookupParameter<PotvinPDShiftMove>)Parameters["PotvinPDShiftMove"]; }
+    }
+    public ILookupParameter VRPMoveParameter {
+      get { return PDShiftMoveParameter; }
+    }
+    public ILookupParameter<IVRPEncoding> VRPToursParameter {
+      get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPTours"]; }
+    }
+    public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter {
+      get { return (LookupParameter<IVRPProblemInstance>)Parameters["ProblemInstance"]; }
+    }  
+
+    public ILookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (ILookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MoveTabu"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ValueParameter<BoolValue> UseAspirationCriterionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseAspirationCriterion"]; }
+    }
+
+    public ILookupParameter<DoubleValue> MoveDistanceParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveDistance"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveOverloadParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveOverload"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveTardinessParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveTardiness"]; }
+    }
+
+    public BoolValue UseAspirationCriterion {
+      get { return UseAspirationCriterionParameter.Value; }
+      set { UseAspirationCriterionParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected PotvinPDShiftTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected PotvinPDShiftTabuCriterion(PotvinPDShiftTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public PotvinPDShiftTabuCriterion()
+      : base() {
+      Parameters.Add(new LookupParameter<PotvinPDShiftMove>("PotvinPDShiftMove", "The moves that should be made."));
+      Parameters.Add(new LookupParameter<IVRPEncoding>("VRPTours", "The VRP tours considered in the move."));
+      Parameters.Add(new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The VRP problem instance"));
+
+      Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseAspirationCriterion", "Whether to use the aspiration criterion or not.", new BoolValue(true)));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the current move."));
+
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveDistance", "The distance of the move"));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveOverload", "The overload of the move"));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveTardiness", "The tardiness of the move"));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDShiftTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool useAspiration = UseAspirationCriterion.Value;
+      bool isTabu = false;
+      PotvinPDShiftMove move = PDShiftMoveParameter.ActualValue;
+
+      foreach (IItem tabuMove in tabuList) {
+        PotvinPDRelocateMoveAttribute attribute = tabuMove as PotvinPDRelocateMoveAttribute;
+
+        if (!useAspiration || moveQuality >= attribute.MoveQuality) {
+          if (attribute.City == move.City && attribute.Tour == move.Tour) {
+            isTabu = true;
+            break;
+          }
+
+          double distance = 0;
+          if (MoveDistanceParameter.ActualValue != null)
+            distance = MoveDistanceParameter.ActualValue.Value;
+
+          double overload = 0;
+          if (MoveOverloadParameter.ActualValue != null)
+            overload = MoveOverloadParameter.ActualValue.Value;
+
+          double tardiness = 0;
+          if (MoveTardinessParameter.ActualValue != null)
+            tardiness = MoveTardinessParameter.ActualValue.Value;
+
+          if (attribute.Distance == distance && attribute.Overload == overload && attribute.Tardiness == tardiness) {
+            isTabu = true;
+            break;
+          }
+        }
+      }
+      
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveTabuMaker.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveTabuMaker.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMoveTabuMaker.cs	(revision 6773)
@@ -0,0 +1,95 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDShiftMoveTabuMaker", "Declares a given shift move as tabu.")]
+  [StorableClass]
+  public class PotvinPDShiftMoveTabuMaker : TabuMaker, IPotvinPDShiftMoveOperator, IPotvinOperator, IVRPMoveOperator {
+    public ILookupParameter<PotvinPDShiftMove> PDShiftMoveParameter {
+      get { return (ILookupParameter<PotvinPDShiftMove>)Parameters["PotvinPDShiftMove"]; }
+    }
+    public ILookupParameter VRPMoveParameter {
+      get { return PDShiftMoveParameter; }
+    }
+    public ILookupParameter<IVRPEncoding> VRPToursParameter {
+      get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPTours"]; }
+    }
+    public ILookupParameter<IVRPProblemInstance> ProblemInstanceParameter {
+      get { return (LookupParameter<IVRPProblemInstance>)Parameters["ProblemInstance"]; }
+    }
+
+    public ILookupParameter<DoubleValue> DistanceParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Distance"]; }
+    }
+    public ILookupParameter<DoubleValue> OverloadParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Overload"]; }
+    }
+    public ILookupParameter<DoubleValue> TardinessParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Tardiness"]; }
+    }
+
+    [StorableConstructor]
+    protected PotvinPDShiftMoveTabuMaker(bool deserializing) : base(deserializing) { }
+    protected PotvinPDShiftMoveTabuMaker(PotvinPDShiftMoveTabuMaker original, Cloner cloner) : base(original, cloner) { }
+    public PotvinPDShiftMoveTabuMaker()
+      : base() {
+        Parameters.Add(new LookupParameter<PotvinPDShiftMove>("PotvinPDShiftMove", "The moves that should be made."));
+        Parameters.Add(new LookupParameter<IVRPEncoding>("VRPTours", "The VRP tours considered in the move."));
+        Parameters.Add(new LookupParameter<IVRPProblemInstance>("ProblemInstance", "The VRP problem instance"));
+
+        Parameters.Add(new LookupParameter<DoubleValue>("Distance", "The distance of the individual"));
+        Parameters.Add(new LookupParameter<DoubleValue>("Overload", "The overload of the individual"));
+        Parameters.Add(new LookupParameter<DoubleValue>("Tardiness", "The tardiness of the individual"));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDShiftMoveTabuMaker(this, cloner);
+    }
+
+    protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) {
+      PotvinPDShiftMove move = PDShiftMoveParameter.ActualValue;
+      double baseQuality = moveQuality;
+      if (quality < moveQuality) baseQuality = quality; // we make an uphill move, the lower bound is the solution quality
+
+      double distance = 0;
+      if (DistanceParameter.ActualValue != null)
+        distance = DistanceParameter.ActualValue.Value;
+
+      double overload = 0;
+      if (OverloadParameter.ActualValue != null)
+        overload = OverloadParameter.ActualValue.Value;
+
+      double tardiness = 0;
+      if (TardinessParameter.ActualValue != null)
+        tardiness = TardinessParameter.ActualValue.Value;
+      
+      return new PotvinPDRelocateMoveAttribute(baseQuality, move.OldTour, move.City, distance, overload, tardiness);
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMultiMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMultiMoveGenerator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftMultiMoveGenerator.cs	(revision 6773)
@@ -0,0 +1,72 @@
+﻿#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.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDShiftMultiMoveGenerator", "Generates shift moves from a given PDP encoding.")]
+  [StorableClass]
+  public sealed class PotvinPDShiftMultiMoveGenerator : PotvinPDShiftMoveGenerator, IMultiMoveGenerator, IMultiVRPMoveGenerator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDShiftMultiMoveGenerator(this, cloner);
+    }
+
+    [StorableConstructor]
+    private PotvinPDShiftMultiMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDShiftMultiMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));
+    }
+
+    private PotvinPDShiftMultiMoveGenerator(PotvinPDShiftMultiMoveGenerator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    protected override PotvinPDShiftMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
+      List<PotvinPDShiftMove> result = new List<PotvinPDShiftMove>();
+
+      for (int i = 0; i < SampleSizeParameter.ActualValue.Value; i++) {
+        result.Add(PotvinPDShiftSingleMoveGenerator.Apply(individual, ProblemInstance, RandomParameter.ActualValue));
+      }
+
+      return result.ToArray();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftSingleMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftSingleMoveGenerator.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PDShift/PotvinPDShiftSingleMoveGenerator.cs	(revision 6773)
@@ -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 System;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDShiftSingleMoveGenerator", "Generates a single shift move from a given PDP encoding.")]
+  [StorableClass]
+  public sealed class PotvinPDShiftSingleMoveGenerator : PotvinPDShiftMoveGenerator,
+    ISingleMoveGenerator {    
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDShiftSingleMoveGenerator(this, cloner);
+    }
+
+    [StorableConstructor]
+    private PotvinPDShiftSingleMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public PotvinPDShiftSingleMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+    }
+
+    private PotvinPDShiftSingleMoveGenerator(PotvinPDShiftSingleMoveGenerator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public static PotvinPDShiftMove Apply(PotvinEncoding individual, IVRPProblemInstance problemInstance, IRandom rand) {
+      List<int> cities = new List<int>();
+
+      IPickupAndDeliveryProblemInstance pdp = problemInstance as IPickupAndDeliveryProblemInstance;
+      for (int i = 1; i <= individual.Cities; i++) {
+        if(pdp == null || pdp.Demand[i] >= 0)
+          cities.Add(i);
+      }
+
+      int city = cities[rand.Next(cities.Count)];
+      Tour oldTour = individual.Tours.Find(t => t.Stops.Contains(city));
+      int oldTourIndex = individual.Tours.IndexOf(oldTour);
+
+      int max = individual.Tours.Count;
+      if (individual.Tours.Count < problemInstance.Vehicles.Value)
+        max = max - 1;
+
+      int newTourIndex = rand.Next(max);
+      if (newTourIndex >= oldTourIndex)
+        newTourIndex++;
+
+      return new PotvinPDShiftMove(city, oldTourIndex, newTourIndex, individual);
+    }
+
+    protected override PotvinPDShiftMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance) {
+      List<PotvinPDShiftMove> result = new List<PotvinPDShiftMove>();
+
+      PotvinPDShiftMove move = Apply(individual, ProblemInstance, RandomParameter.ActualValue);
+      if (move != null)
+        result.Add(move);
+
+      return result.ToArray();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PotvinPDRelocateMoveAttribute.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PotvinPDRelocateMoveAttribute.cs	(revision 6773)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Potvin/Moves/PickupDelivery/PotvinPDRelocateMoveAttribute.cs	(revision 6773)
@@ -0,0 +1,81 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPDRelocateMoveAttribute", "PD relocation move attribute")]
+  [StorableClass]
+  public class PotvinPDRelocateMoveAttribute : VRPMoveAttribute {
+    [Storable]
+    public int Tour { get; private set; }
+    [Storable]
+    public int City { get; private set; }
+
+    [Storable]
+    public double Distance { get; private set; }
+    [Storable]
+    public double Overload { get; private set; }
+    [Storable]
+    public double Tardiness { get; private set; }
+
+    [StorableConstructor]
+    protected PotvinPDRelocateMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected PotvinPDRelocateMoveAttribute(PotvinPDRelocateMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+        this.Tour = original.Tour;
+        this.City = original.City;
+        this.Distance = original.Distance;
+        this.Overload = original.Overload;
+        this.Tardiness = original.Tardiness;
+    }
+    public PotvinPDRelocateMoveAttribute(double moveQuality, int tour, int city, 
+      double distance, double overload, double tardiness)
+      : base(moveQuality) {
+      Tour = tour;
+      City = city;
+      Distance = distance;
+      Overload = overload;
+      Tardiness = tardiness;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinPDRelocateMoveAttribute(this, cloner);
+    }
+
+    public override int GetHashCode() {
+      return Tour.GetHashCode() + City.GetHashCode();
+    }
+
+    public override bool Equals(object obj) {
+      if (obj is PotvinPDRelocateMoveAttribute) {
+        PotvinPDRelocateMoveAttribute other = obj as PotvinPDRelocateMoveAttribute;
+
+        return Tour == other.Tour && City == other.City;
+      } else {
+        return base.Equals(obj);
+      }
+    }
+  }
+}
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 6772)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/HeuristicLab.Problems.VehicleRouting-3.4.csproj	(revision 6773)
@@ -225,4 +225,35 @@
     <Compile Include="Encodings\Potvin\Moves\CustomerRelocation\PotvinCustomerRelocationMoveAttribute.cs" />
     <Compile Include="Encodings\Potvin\Moves\CustomerRelocation\PotvinCustomerRelocationMoveTabuCriterion.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PotvinPDRelocateMoveAttribute.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDExchange\IPotvinPDExchangeMoveOperator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDExchange\PotvinPDExchangeExhaustiveMoveGenerator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDExchange\PotvinPDExchangeMove.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDExchange\PotvinPDExchangeMoveEvaluator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDExchange\PotvinPDExchangeMoveGenerator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDExchange\PotvinPDExchangeMoveMaker.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDExchange\PotvinPDExchangeMoveTabuCriterion.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDExchange\PotvinPDExchangeMoveTabuMaker.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDExchange\PotvinPDExchangeMultiMoveGenerator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDExchange\PotvinPDExchangeSingleMoveGenerator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDRearrange\IPotvinPDRearrangeMoveOperator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDRearrange\PotvinPDRearrangeExhaustiveMoveGenerator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDRearrange\PotvinPDRearrangeMove.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDRearrange\PotvinPDRearrangeMoveEvaluator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDRearrange\PotvinPDRearrangeMoveGenerator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDRearrange\PotvinPDRearrangeMoveMaker.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDRearrange\PotvinPDRearrangeMoveTabuCriterion.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDRearrange\PotvinPDRearrangeMoveTabuMaker.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDRearrange\PotvinPDRearrangeMultiMoveGenerator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDRearrange\PotvinPDRearrangeSingleMoveGenerator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDShift\IPotvinPDShiftMoveOperator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDShift\PotvinPDShiftMoveTabuCriterion.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDShift\PotvinPDShiftMoveTabuMaker.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDShift\PotvinPDShiftMultiMoveGenerator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDShift\PotvinPDShiftSingleMoveGenerator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDShift\PotvinPDShiftExhaustiveMoveGenerator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDShift\PotvinPDShiftMoveMaker.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDShift\PotvinPDShiftMoveEvaluator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDShift\PotvinPDShiftMoveGenerator.cs" />
+    <Compile Include="Encodings\Potvin\Moves\PickupDelivery\PDShift\PotvinPDShiftMove.cs" />
     <Compile Include="Encodings\Potvin\Moves\PotvinMoveEvaluator.cs" />
     <Compile Include="Encodings\Potvin\Moves\PotvinMoveGenerator.cs" />
