Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Crossovers/GVRCrossover.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Crossovers/GVRCrossover.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Crossovers/GVRCrossover.cs	(revision 4379)
@@ -0,0 +1,115 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.GVR {
+  [Item("GVRCrossover", "The GVR crossover operation. It is implemented as described in Pereira, F.B. et al (2002). GVR: a New Genetic Representation for the Vehicle Routing Problem. AICS 2002, LNAI 2464, pp. 95-102.")]
+  [StorableClass]
+  public sealed class GVRCrossover : VRPCrossover, IStochasticOperator, IGVROperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    [StorableConstructor]
+    private GVRCrossover(bool deserializing) : base(deserializing) { }
+
+    public GVRCrossover() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+    }
+
+    private GVREncoding Crossover(IRandom random, GVREncoding parent1, GVREncoding parent2) {
+      GVREncoding child = parent1.Clone() as GVREncoding;
+
+      Tour tour = parent2.Tours[random.Next(parent2.Tours.Count)];
+      int breakPoint1 = random.Next(tour.Stops.Count);
+      int length = random.Next(1, tour.Stops.Count - breakPoint1 + 1);
+      List<int> subroute = tour.Stops.GetRange(breakPoint1, length);
+      
+      //remove duplicates
+      List<Tour> toBeRemoved = new List<Tour>();
+
+      foreach (Tour route in child.Tours) {
+        foreach (int city in subroute) {
+          route.Stops.Remove(city);
+        }
+
+        if (route.Stops.Count == 0)
+          toBeRemoved.Add(route);
+      }
+      foreach (Tour route in toBeRemoved) {
+        child.Tours.Remove(route);
+      }
+
+      //choose nearest customer
+      double minDistance = -1;
+      int customer = -1;
+      for (int i = 1; i <= ProblemInstance.Cities.Value; i++) {
+        if (!subroute.Contains(i)) {
+          double distance = ProblemInstance.GetDistance(subroute[0], i);
+
+          if (customer == -1 || distance < minDistance) {
+            customer = i;
+            minDistance = distance;
+          }
+        }
+      }
+
+      //insert
+      if (customer != -1) {
+        Tour newTour;
+        int newPosition;
+        child.FindCustomer(customer, out newTour, out newPosition);
+        newTour.Stops.InsertRange(newPosition + 1, subroute);
+      } else {
+        //special case -> only one tour, whole tour has been chosen as subroute
+        child = parent1.Clone() as GVREncoding;
+      }
+
+      return child;
+    }
+   
+    public override IOperation Apply() {
+      ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
+      for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
+        IVRPEncoding solution = ParentsParameter.ActualValue[i];
+        if (!(solution is GVREncoding)) {
+          parents[i] = GVREncoding.ConvertFrom(solution, ProblemInstance);
+        } else {
+          parents[i] = solution;
+        }
+      }
+      ParentsParameter.ActualValue = parents;
+
+      ChildParameter.ActualValue = Crossover(RandomParameter.ActualValue, parents[0] as GVREncoding, parents[1] as GVREncoding);
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/GVREncoding.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/GVREncoding.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/GVREncoding.cs	(revision 4379)
@@ -0,0 +1,134 @@
+﻿#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.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Drawing;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.GVR {
+  [Item("GVREncoding", "Represents a potvin encoding of VRP solutions. It is implemented as described in Pereira, F.B. et al (2002). GVR: a New Genetic Representation for the Vehicle Routing Problem. AICS 2002, LNAI 2464, pp. 95-102.")]
+  [StorableClass]
+  public class GVREncoding : TourEncoding {
+    public override List<Tour> GetTours() {
+      List<Tour> tours = new List<Tour>();    
+
+      foreach (Tour tour in base.Tours) {
+        Tour newTour = new Tour();
+        double currentDemand = 0;
+
+        DoubleArray demand = ProblemInstance.Demand;
+        DoubleValue capacity = new DoubleValue(double.MaxValue);
+        if (ProblemInstance is IHomogenousCapacitatedProblemInstance) {
+          capacity.Value = (ProblemInstance as IHomogenousCapacitatedProblemInstance).Capacity.Value;
+        }
+
+
+        foreach (int city in tour.Stops) {
+          currentDemand += demand[city];
+
+          if (currentDemand > capacity.Value) {
+            if (newTour.Stops.Count > 0)
+              tours.Add(newTour);
+
+            newTour = new Tour();
+            newTour.Stops.Add(city);
+            currentDemand = demand[city];
+          } else {
+            newTour.Stops.Add(city);
+          }
+        }
+
+        if (newTour.Stops.Count > 0)
+          tours.Add(newTour);
+      }
+
+      //repair if there are too many vehicles used
+      while (tours.Count > ProblemInstance.Vehicles.Value) {
+        Tour tour = tours[tours.Count - 1];
+        tours[tours.Count - 2].Stops.AddRange(tour.Stops);
+
+        tours.Remove(tour);
+      } 
+
+      return tours;
+    }
+    
+    public override IDeepCloneable Clone(HeuristicLab.Common.Cloner cloner) {
+      GVREncoding clone = new GVREncoding(ProblemInstance);
+      cloner.RegisterClonedObject(this, clone);
+      clone.Tours = (ItemList<Tour>)cloner.Clone(this.Tours);
+     
+      return clone;
+    }
+
+    public GVREncoding(IVRPProblemInstance problemInstance)
+      : base(problemInstance) {
+    }
+
+    [StorableConstructor]
+    private GVREncoding(bool serializing)
+      : base(serializing) {
+    }
+
+    public static GVREncoding ConvertFrom(IVRPEncoding encoding, IVRPProblemInstance problemInstance) {
+      GVREncoding solution = new GVREncoding(problemInstance);
+
+      TourEncoding.ConvertFrom(encoding, solution, problemInstance);
+
+      return solution;
+    }
+
+    public static GVREncoding ConvertFrom(List<int> route, IVRPProblemInstance problemInstance) {
+      GVREncoding solution = new GVREncoding(problemInstance);
+
+      TourEncoding.ConvertFrom(route, solution);
+
+      return solution;
+    }
+
+    internal void FindCustomer(int customer, out Tour tour, out int index) {
+      tour = null;
+      index = -1;
+
+      int currentTour = 0;
+      while (tour == null && currentTour < Tours.Count) {
+        int currentCity = 0;
+        while (tour == null && currentCity < Tours[currentTour].Stops.Count) {
+          if (Tours[currentTour].Stops[currentCity] == customer) {
+            tour = Tours[currentTour];
+            index = currentCity;
+          }
+
+          currentCity++;
+        }
+
+        currentTour++;
+      }
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/IGVROperator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/IGVROperator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/IGVROperator.cs	(revision 4379)
@@ -0,0 +1,37 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Operators;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.GVR {
+  public interface IGVROperator : 
+    ISingleDepotOperator, IHomogenousCapacitatedOperator, ITimeWindowedOperator {    
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRDisplacementManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRDisplacementManipulator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRDisplacementManipulator.cs	(revision 4379)
@@ -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 HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.GVR {
+  [Item("GVRDisplacementManipulator", "An operator which manipulates a GVR representation by applying a displacement operation. It is implemented as described in Pereira, F.B. et al (2002). GVR: a New Genetic Representation for the Vehicle Routing Problem. AICS 2002, LNAI 2464, pp. 95-102.")]
+  [StorableClass]
+  public sealed class GVRDisplacementManipulator : GVRManipulator {
+    [StorableConstructor]
+    private GVRDisplacementManipulator(bool deserializing) : base(deserializing) { }
+
+    public GVRDisplacementManipulator()
+      : base() {
+    }
+
+    protected override void Manipulate(IRandom random, GVREncoding individual) {
+      Tour tour = individual.Tours[random.Next(individual.Tours.Count)];
+      int breakPoint1 = random.Next(tour.Stops.Count);
+      int length = random.Next(1, tour.Stops.Count - breakPoint1 + 1);
+
+      List<int> displaced = tour.Stops.GetRange(breakPoint1, length);
+      tour.Stops.RemoveRange(breakPoint1, length);
+      //with a probability of 1/(2*V) create a new tour, else insert at another position
+      if (individual.GetTours().Count > 0 &&
+        individual.GetTours().Count < ProblemInstance.Vehicles.Value && 
+        random.Next(individual.GetTours().Count * 2) == 0) {
+        Tour newTour = new Tour();
+        newTour.Stops.InsertRange(0, displaced);
+
+        individual.Tours.Add(newTour);
+      } else {
+        Tour newTour = individual.Tours[random.Next(individual.Tours.Count)];
+        int newPosition = newTour.Stops.Count;
+
+        newTour.Stops.InsertRange(newPosition, displaced);
+      }
+
+      if (tour.Stops.Count == 0)
+        individual.Tours.Remove(tour);
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRInsertionManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRInsertionManipulator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRInsertionManipulator.cs	(revision 4379)
@@ -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 HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.GVR {
+  [Item("GVRInsertionManipulator", "An operator which manipulates a GVR representation by inserting a customer at another location. It is implemented as described in Pereira, F.B. et al (2002). GVR: a New Genetic Representation for the Vehicle Routing Problem. AICS 2002, LNAI 2464, pp. 95-102.")]
+  [StorableClass]
+  public sealed class GVRInsertionManipulator : GVRManipulator {
+    [StorableConstructor]
+    private GVRInsertionManipulator(bool deserializing) : base(deserializing) { }
+
+    public GVRInsertionManipulator()
+      : base() {
+    }
+
+    protected override void Manipulate(IRandom random, GVREncoding individual) {
+      int customer = random.Next(1, individual.Cities + 1);
+      Tour tour;
+      int position;
+      individual.FindCustomer(customer, out tour, out position);
+
+      tour.Stops.RemoveAt(position);
+
+      //with a probability of 1/(2*V) create a new tour, else insert at another position
+      if (individual.GetTours().Count > 0 &&        
+        individual.GetTours().Count < ProblemInstance.Vehicles.Value && 
+        random.Next(individual.GetTours().Count * 2) == 0) {
+        Tour newTour = new Tour();
+        newTour.Stops.Add(customer);
+       
+        individual.Tours.Add(newTour);
+      } else {
+        Tour newTour = individual.Tours[random.Next(individual.Tours.Count)];
+        int newPosition = random.Next(newTour.Stops.Count + 1);
+
+        newTour.Stops.Insert(newPosition, customer);
+      }
+
+      if (tour.Stops.Count == 0)
+        individual.Tours.Remove(tour);
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRInversionManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRInversionManipulator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRInversionManipulator.cs	(revision 4379)
@@ -0,0 +1,47 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.GVR {
+  [Item("GVRInversionManipulator", "An operator which manipulates a GVR representation by inverting a subroute. It is implemented as described in Pereira, F.B. et al (2002). GVR: a New Genetic Representation for the Vehicle Routing Problem. AICS 2002, LNAI 2464, pp. 95-102.")]
+  [StorableClass]
+  public sealed class GVRInversionManipulator : GVRManipulator {
+    [StorableConstructor]
+    private GVRInversionManipulator(bool deserializing) : base(deserializing) { }
+
+    public GVRInversionManipulator()
+      : base() {
+    }
+
+    protected override void Manipulate(IRandom random, GVREncoding individual) {
+      Tour tour = individual.Tours[random.Next(individual.Tours.Count)];
+      int breakPoint1 = random.Next(tour.Stops.Count);
+      int length = random.Next(1, tour.Stops.Count - breakPoint1 + 1);
+
+      tour.Stops.Reverse(breakPoint1, length);
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRManipulator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRManipulator.cs	(revision 4379)
@@ -0,0 +1,59 @@
+﻿#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.Optimization;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.GVR {
+  [Item("GVRManipulator", "A VRP manipulation operation.")]
+  [StorableClass]
+  public abstract class GVRManipulator : VRPManipulator, IStochasticOperator, IGVROperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    [StorableConstructor]
+    protected GVRManipulator(bool deserializing) : base(deserializing) { }
+
+    public GVRManipulator() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+    }
+
+    protected abstract void Manipulate(IRandom random, GVREncoding individual);
+   
+    public override IOperation Apply() {
+      IVRPEncoding solution = VRPToursParameter.ActualValue;
+      if (!(solution is GVREncoding)) {
+        VRPToursParameter.ActualValue = GVREncoding.ConvertFrom(solution, ProblemInstance);
+      }
+
+      Manipulate(RandomParameter.ActualValue, VRPToursParameter.ActualValue as GVREncoding);
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRSwapManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRSwapManipulator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/GVR/Manipulators/GVRSwapManipulator.cs	(revision 4379)
@@ -0,0 +1,56 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.GVR {
+  [Item("GVRSwapManipulator", "An operator which manipulates a GVR representation by swapping two customers. It is implemented as described in Pereira, F.B. et al (2002). GVR: a New Genetic Representation for the Vehicle Routing Problem. AICS 2002, LNAI 2464, pp. 95-102.")]
+  [StorableClass]
+  public sealed class GVRSwapManipulator : GVRManipulator {
+    [StorableConstructor]
+    private GVRSwapManipulator(bool deserializing) : base(deserializing) { }
+
+    public GVRSwapManipulator()
+      : base() {
+    }
+
+    protected override void Manipulate(IRandom random, GVREncoding individual) {
+      int customer1 = random.Next(1, individual.Cities + 1);
+      int customer2 = random.Next(1, individual.Cities + 1);
+
+      Tour tour1;
+      int pos1;
+      individual.FindCustomer(customer1, out tour1, out pos1);
+
+      Tour tour2;
+      int pos2;
+      individual.FindCustomer(customer2, out tour2, out pos2);
+
+      int temp = tour1.Stops[pos1];
+      tour1.Stops[pos1] = tour2.Stops[pos2];
+      tour2.Stops[pos2] = temp;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Crossovers/PrinsCrossover.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Crossovers/PrinsCrossover.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Crossovers/PrinsCrossover.cs	(revision 4379)
@@ -0,0 +1,69 @@
+﻿#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.Optimization;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  [Item("PrinsCrossover", "An operator which crosses two VRP representations.")]
+  [StorableClass]
+  public abstract class PrinsCrossover : VRPCrossover, IStochasticOperator, IPrinsOperator {
+   
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    
+    [StorableConstructor]
+    protected PrinsCrossover(bool deserializing) : base(deserializing) { }
+
+    public PrinsCrossover()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+    }
+
+    protected abstract PrinsEncoding Crossover(IRandom random, PrinsEncoding parent1, PrinsEncoding parent2);
+
+    public override IOperation Apply() {
+      ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
+      for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
+        IVRPEncoding solution = ParentsParameter.ActualValue[i];
+
+        if (!(solution is PrinsEncoding)) {
+          parents[i] = PrinsEncoding.ConvertFrom(solution, ProblemInstance);
+        } else {
+          parents[i] = solution;
+        }
+      }
+      ParentsParameter.ActualValue = parents;
+
+      ChildParameter.ActualValue =
+        Crossover(RandomParameter.ActualValue, parents[0] as PrinsEncoding, parents[1] as PrinsEncoding);
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Crossovers/PrinsPermutationCrossover.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Crossovers/PrinsPermutationCrossover.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Crossovers/PrinsPermutationCrossover.cs	(revision 4379)
@@ -0,0 +1,63 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  [Item("PrinsPermutationCrossover", "An operator which crosses two VRP representations using a standard permutation operator.  It is implemented as described in Prins, C. (2004). A simple and effective evolutionary algorithm for the vehicle routing problem. Computers & Operations Research, 12:1985-2002.")]
+  [StorableClass]
+  public sealed class PrinsPermutationCrossover : PrinsCrossover, IPrinsOperator {    
+    public IValueLookupParameter<IPermutationCrossover> InnerCrossoverParameter {
+      get { return (IValueLookupParameter<IPermutationCrossover>)Parameters["InnerCrossover"]; }
+    }
+
+    [StorableConstructor]
+    private PrinsPermutationCrossover(bool deserializing) : base(deserializing) { }
+
+    public PrinsPermutationCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IPermutationCrossover>("InnerCrossover", "The permutation crossover.", new OrderCrossover()));
+    }
+
+    protected override PrinsEncoding Crossover(IRandom random, PrinsEncoding parent1, PrinsEncoding parent2) {
+      //note - the inner crossover is called here and the result is converted to a prins representation
+      //some refactoring should be done here in the future - the crossover operation should be called directly
+
+      InnerCrossoverParameter.ActualValue.ParentsParameter.ActualName = ParentsParameter.ActualName;
+      IAtomicOperation op = this.ExecutionContext.CreateOperation(
+        InnerCrossoverParameter.ActualValue, this.ExecutionContext.Scope);
+      op.Operator.Execute((IExecutionContext)op);
+
+      string childName = InnerCrossoverParameter.ActualValue.ChildParameter.ActualName;
+      if (ExecutionContext.Scope.Variables.ContainsKey(childName)) {
+        Permutation permutation = ExecutionContext.Scope.Variables[childName].Value as Permutation;
+        ExecutionContext.Scope.Variables.Remove(childName);
+
+        return new PrinsEncoding(permutation, ProblemInstance);
+      } else
+        return null;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/IPrinsOperator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/IPrinsOperator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/IPrinsOperator.cs	(revision 4379)
@@ -0,0 +1,37 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Operators;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  public interface IPrinsOperator : 
+    ISingleDepotOperator, IHomogenousCapacitatedOperator, ITimeWindowedOperator {    
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsExhaustiveLSManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsExhaustiveLSManipulator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsExhaustiveLSManipulator.cs	(revision 4379)
@@ -0,0 +1,76 @@
+﻿#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 System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  [Item("PrinsExhaustiveLSManipulator", "An operator which manipulates a VRP representation by using the exhaustive Prins local search.  It is implemented as described in Prins, C. (2004). A simple and effective evolutionary algorithm for the vehicle routing problem. Computers & Operations Research, 12:1985-2002.")]
+  [StorableClass]
+  public sealed class PrinsExhaustiveLSManipulator : PrinsLSManipulator {   
+    [StorableConstructor]
+    private PrinsExhaustiveLSManipulator(bool deserializing) : base(deserializing) { }
+
+    public PrinsExhaustiveLSManipulator()
+      : base() {
+    }
+
+    protected override void Manipulate(IRandom random, PrinsEncoding individual) {
+      List<Tour> tours = individual.GetTours();
+      bool improvement = false;
+      int iterations = 0;
+
+      do {
+        int u = depot;
+        improvement = false;
+        double originalQuality = GetQuality(individual);
+        PrinsEncoding child = null;
+
+        while (!improvement && u < ProblemInstance.Cities.Value) {
+          int v = depot;
+          while (!improvement && v < ProblemInstance.Cities.Value) {
+            if (u != v) {
+              child = Manipulate(individual,
+                originalQuality, u, v);
+
+              improvement = child != null;
+            }
+            v++;
+          }
+          u++;
+        }
+
+        if (improvement) {
+          for (int i = 0; i < child.Length; i++) {
+            individual[i] = child[i];
+          }
+        }
+
+        iterations++;
+      } while (improvement && 
+        iterations < Iterations.Value.Value);
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsLSManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsLSManipulator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsLSManipulator.cs	(revision 4379)
@@ -0,0 +1,454 @@
+﻿#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 System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  [Item("PrinsLSManipulator", "An operator which manipulates a VRP representation by using the Prins local search.  It is implemented as described in Prins, C. (2004). A simple and effective evolutionary algorithm for the vehicle routing problem. Computers & Operations Research, 12:1985-2002.")]
+  [StorableClass]
+  public abstract class PrinsLSManipulator : PrinsManipulator {
+    public IValueParameter<IntValue> Iterations {
+      get { return (IValueParameter<IntValue>)Parameters["Iterations"]; }
+    }
+        
+    [StorableConstructor]
+    protected PrinsLSManipulator(bool deserializing) : base(deserializing) { }
+
+    public PrinsLSManipulator()
+      : base() {
+      Parameters.Add(new ValueParameter<IntValue>("Iterations", "The number of max iterations.", new IntValue(5)));
+    }
+
+    protected double GetQuality(PrinsEncoding individual) {
+      return ProblemInstance.Evaluate(individual);
+    }
+
+    private int FindCity(PrinsEncoding individual, int city) {
+      int index = -1;
+
+      int i = 0;
+      while (i < individual.Length && index == -1) {
+        if (individual[i] == city)
+          index = i;
+        
+        i++;
+      }
+
+      return index;
+    }
+
+    protected const int depot = -1;
+
+    private Tour FindTour(PrinsEncoding individual, int city) {
+      Tour found = null;
+
+      List<Tour> tours = individual.GetTours();
+      int i = 0;
+
+      while (found == null && i < tours.Count) {
+        if (tours[i].Stops.Contains(city))
+          found = tours[i];
+        
+        i++;
+      }
+
+      return found;
+    }
+
+    //inserts u after v in the child
+    private void InsertAfter(int u, int v, PrinsEncoding parent, PrinsEncoding child) {
+      int pi = 0;
+      int ci = 0;
+
+      while (ci != child.Length) {
+        if (parent[pi] != u) {
+          child[ci] = parent[pi];
+          ci++;
+        }
+        if (parent[pi] == v) {
+          child[ci] = u;
+          ci++;
+        }
+
+        pi++;
+      }
+    }
+
+    //inserts (u, x) after v in the child
+    private void InsertAfter(int u, int x, int v, PrinsEncoding parent, PrinsEncoding child) {
+      int pi = 0;
+      int ci = 0;
+
+      while (ci != child.Length) {
+        if (parent[pi] != u && parent[pi] != x) {
+          child[ci] = parent[pi];
+          ci++;
+        }
+        if (parent[pi] == v) {
+          child[ci] = u;
+          ci++;
+
+          child[ci] = x;
+          ci++;
+        }
+
+        pi++;
+      }
+    }
+
+    //inserts u before v in the child
+    private void InsertBefore(int u, int v, PrinsEncoding parent, PrinsEncoding child) {
+      int pi = 0;
+      int ci = 0;
+
+      while (ci != child.Length) {
+        if (parent[pi] == v) {
+          child[ci] = u;
+          ci++;
+        }
+        if (parent[pi] != u) {
+          child[ci] = parent[pi];
+          ci++;
+        }
+
+        pi++;
+      }
+    }
+
+    //inserts (u, x) before v in the child
+    private void InsertBefore(int u, int x, int v, PrinsEncoding parent, PrinsEncoding child) {
+      int pi = 0;
+      int ci = 0;
+
+      while (ci != child.Length) {
+        if (parent[pi] == v) {
+          child[ci] = u;
+          ci++;
+
+          child[ci] = x;
+          ci++;
+        }
+        if (parent[pi] != u && parent[pi] != x) {
+          child[ci] = parent[pi];
+          ci++;
+        }
+
+        pi++;
+      }
+    }
+
+    //swaps u and v
+    private void Swap(int u, int v, PrinsEncoding parent, PrinsEncoding child) {
+      for (int i = 0; i < child.Length; i++) {
+        if (parent[i] == u)
+          child[i] = v;
+        else if (parent[i] == v)
+          child[i] = u;
+        else
+          child[i] = parent[i];
+      }
+    }
+
+    //swaps (u, x) and v
+    private void Swap(int u, int x, int v, PrinsEncoding parent, PrinsEncoding child) {
+      int childIndex = 0;
+      int parentIndex = 0;
+
+      while(childIndex < child.Length) {
+        if (parent[parentIndex] == u) {
+          child[childIndex] = v;
+          parentIndex++;
+        } else if (parent[parentIndex] == v) {
+          child[childIndex] = u;
+          childIndex++;
+          child[childIndex] = x;
+        } else {
+          child[childIndex] = parent[parentIndex];
+        }
+
+        childIndex++;
+        parentIndex++;
+      }
+    }
+
+    //swaps (u, x) and (v, y)
+    private void Swap(int u, int x, int v, int y, PrinsEncoding parent, PrinsEncoding child) {
+      int i = 0;
+
+      while (i < child.Length) {
+        if (child[i] == u) {
+          child[i] = v;
+          i++;
+          child[i] = y;
+        } else if (child[i] == v) {
+          child[i] = u;
+          i++;
+          child[i] = x;
+        } else {
+          child[i] = parent[i];
+        }
+
+        i++;
+      }
+    }
+
+    //swaps (u, x) and (v, y) by (u, y) and (x, v)
+    private void Swap2(int u, int x, int v, int y, PrinsEncoding parent, PrinsEncoding child) {
+      int i = 0;
+
+      while (i < child.Length) {
+        if(parent[i] == x) {
+          child[i] = y;
+        } else if(parent[i] == v) {
+          child[i] = x;
+        } else if(parent[i] == y) {
+          child[i] = v;
+        } else {
+          child[i] = parent[i];
+        }
+
+        i++;
+      }
+    }
+
+    private void M1(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot) {
+        if (v == depot) {
+          Tour tour = FindTour(child, u + 1);
+          v = tour.Stops[0] - 1;
+          InsertBefore(u, v, parent, child);
+        } else {
+          InsertAfter(u, v, parent, child);
+        }
+      }
+    }
+
+    private void M2(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot) {
+        Tour tour = FindTour(child, u + 1);
+        int iu = tour.Stops.IndexOf(u + 1);
+        if (iu < tour.Stops.Count - 1) {
+          int x = tour.Stops[iu + 1] - 1;
+
+          if (v == depot) {
+            tour = FindTour(child, u + 1);
+            v = tour.Stops[0] - 1;
+            InsertBefore(u, x, v, parent, child);
+          } else {
+            InsertAfter(u, x, v, parent, child);
+          }
+        }
+      }
+    }
+
+    private void M3(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot) {
+        Tour tour = FindTour(child, u + 1);
+        int iu = tour.Stops.IndexOf(u + 1);
+        if (iu < tour.Stops.Count - 1) {
+          int x = tour.Stops[iu + 1] - 1;
+
+          if (v == depot) {
+            tour = FindTour(child, u + 1);
+            v = tour.Stops[0] - 1;
+            InsertBefore(x, u, v, parent, child);
+          } else {
+            InsertAfter(x, u, v, parent, child);
+          }
+        }
+      }
+    }
+
+    private void M4(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot && v != depot) {
+        Swap(u, v, parent, child);
+      }
+    }
+
+    private void M5(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot && v != depot) {
+        Tour tour = FindTour(child, u + 1);
+        int iu = tour.Stops.IndexOf(u + 1);
+        if (iu < tour.Stops.Count - 1) {
+          int x = tour.Stops[iu + 1] - 1;
+
+          if(x != v)
+            Swap(u, x, v, parent, child);
+        }
+      }
+    }
+
+    private void M6(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot && v != depot) {
+        Tour tour = FindTour(child, u + 1);
+        int iu = tour.Stops.IndexOf(u + 1);
+        if (iu < tour.Stops.Count - 1) {
+          int x = tour.Stops[iu + 1] - 1;
+
+          tour = FindTour(child, v + 1);
+          int iv = tour.Stops.IndexOf(v + 1);
+          if (iv < tour.Stops.Count - 1) {
+            int y = tour.Stops[iv + 1] - 1;
+
+            if (x != v && y != u)
+              Swap(u, x, v, y, parent, child);
+          }
+        }
+      }
+    }
+
+    private void M7(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot && v != depot) {
+        Tour tu = FindTour(child, u + 1);
+        Tour tv = FindTour(child, v + 1);
+
+        if (tu.Stops[0] == tv.Stops[0]) {
+          int iu = tu.Stops.IndexOf(u + 1);
+          if (iu < tu.Stops.Count - 1) {
+            int x = tu.Stops[iu + 1] - 1;
+
+            int iv = tv.Stops.IndexOf(v + 1);
+            if (iv < tv.Stops.Count - 1) {
+              int y = tv.Stops[iv + 1] - 1;
+
+              if (x != v && y != u)
+                Swap(x, v, parent, child);
+             }
+           }
+        }
+      }
+    }
+
+    private void M8(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot && v != depot) {
+        Tour tu = FindTour(child, u + 1);
+        Tour tv = FindTour(child, v + 1);
+
+        if (tu.Stops[0] != tv.Stops[0]) {
+          int iu = tu.Stops.IndexOf(u + 1);
+          if (iu < tu.Stops.Count - 1) {
+            int x = tu.Stops[iu + 1] - 1;
+
+            int iv = tv.Stops.IndexOf(v + 1);
+            if (iv < tv.Stops.Count - 1) {
+              int y = tv.Stops[iv + 1] - 1;
+
+              if (x != v && y != u)
+                Swap(x, v, parent, child);
+            }
+          }
+        }
+      }
+    }
+
+    private void M9(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot && v != depot) {
+        Tour tu = FindTour(child, u + 1);
+        Tour tv = FindTour(child, v + 1);
+
+        if (tu.Stops[0] != tv.Stops[0]) {
+          int iu = tu.Stops.IndexOf(u + 1);
+          if (iu < tu.Stops.Count - 1) {
+            int x = tu.Stops[iu + 1] - 1;
+
+            int iv = tv.Stops.IndexOf(v + 1);
+            if (iv < tv.Stops.Count - 1) {
+              int y = tv.Stops[iv + 1] - 1;
+
+              if (x != v && y != u)
+                Swap2(u, x, v, y, parent, child);
+            }
+          }
+        }
+      }
+    }
+
+    protected PrinsEncoding Manipulate(PrinsEncoding individual, 
+      double originalQuality, int u, int v) {
+      PrinsEncoding child = null;
+      bool improvement = false;
+
+      if (u != v) {
+        child = individual.Clone() as PrinsEncoding;
+        M1(individual, child, u, v);
+        improvement = GetQuality(child) < originalQuality;
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M2(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M3(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M4(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M5(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M6(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M7(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M8(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M9(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+      }
+
+      if (improvement)
+        return child;
+      else
+        return null;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsManipulator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsManipulator.cs	(revision 4379)
@@ -0,0 +1,60 @@
+﻿#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.Optimization;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  [Item("PrinsManipulator", "An operator which manipulates a VRP representation.")]
+  [StorableClass]
+  public abstract class PrinsManipulator : VRPManipulator, IStochasticOperator, IPrinsOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    [StorableConstructor]
+    protected PrinsManipulator(bool deserializing) : base(deserializing) { }
+
+    public PrinsManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+    }
+
+    protected abstract void Manipulate(IRandom random, PrinsEncoding individual);
+
+    public override IOperation Apply() {
+      IVRPEncoding solution = VRPToursParameter.ActualValue;
+      if (!(solution is PrinsEncoding)) {
+        VRPToursParameter.ActualValue = PrinsEncoding.ConvertFrom(solution, ProblemInstance);
+      }
+
+      Manipulate(RandomParameter.ActualValue, VRPToursParameter.ActualValue as PrinsEncoding);
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsPermutationManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsPermutationManipulator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsPermutationManipulator.cs	(revision 4379)
@@ -0,0 +1,52 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  [Item("PrinsPermutationManipulator", "An operator which manipulates a VRP representation by using a standard permutation manipulator. It is implemented as described in Prins, C. (2004). A simple and effective evolutionary algorithm for the vehicle routing problem. Computers & Operations Research, 12:1985-2002.")]
+  [StorableClass]
+  public sealed class PrinsPermutationManipulator : PrinsManipulator {
+    public IValueLookupParameter<IPermutationManipulator> InnerManipulatorParameter {
+      get { return (IValueLookupParameter<IPermutationManipulator>)Parameters["InnerManipulator"]; }
+    }
+
+    [StorableConstructor]
+    private PrinsPermutationManipulator(bool deserializing) : base(deserializing) { }
+
+    public PrinsPermutationManipulator()
+      : base() {
+        Parameters.Add(new ValueLookupParameter<IPermutationManipulator>("InnerManipulator", "The permutation manipulator.", new TranslocationManipulator()));
+    }
+
+    protected override void Manipulate(IRandom random, PrinsEncoding individual) {
+      InnerManipulatorParameter.ActualValue.PermutationParameter.ActualName = VRPToursParameter.ActualName;
+
+      IAtomicOperation op = this.ExecutionContext.CreateOperation(
+        InnerManipulatorParameter.ActualValue, this.ExecutionContext.Scope);
+      op.Operator.Execute((IExecutionContext)op);
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsStochasticLSManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsStochasticLSManipulator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/Manipulators/PrinsStochasticLSManipulator.cs	(revision 4379)
@@ -0,0 +1,80 @@
+﻿#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 System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  [Item("PrinsStochasticLSManipulator", "An operator which manipulates a VRP representation by using the stochastic version of the Prins local search.  It is implemented as described in Prins, C. (2004). A simple and effective evolutionary algorithm for the vehicle routing problem. Computers & Operations Research, 12:1985-2002.")]
+  [StorableClass]
+  public sealed class PrinsStochasticLSManipulator : PrinsLSManipulator {
+    public IValueParameter<IntValue> SampleSize {
+      get { return (IValueParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+    
+    [StorableConstructor]
+    private PrinsStochasticLSManipulator(bool deserializing) : base(deserializing) { }
+
+    public PrinsStochasticLSManipulator()
+      : base() {
+        Parameters.Add(new ValueParameter<IntValue>("SampleSize", "The sample size.", new IntValue(200)));
+    }
+
+    protected override void Manipulate(IRandom random, PrinsEncoding individual) {
+      List<Tour> tours = individual.GetTours();
+      bool improvement = false;
+      int iterations = 0;
+
+      do {
+        improvement = false;
+        double originalQuality = GetQuality(individual);
+        PrinsEncoding child = null;
+
+        int samples = 0;
+        while (!improvement &&
+          samples < SampleSize.Value.Value) {
+            int u = random.Next(ProblemInstance.Cities.Value);
+            int v = random.Next(ProblemInstance.Cities.Value);
+
+            child = Manipulate(individual,
+                  originalQuality, u, v);
+
+            improvement = child != null;
+
+            samples++;
+        }
+
+        if (improvement) {
+          for (int i = 0; i < child.Length; i++) {
+            individual[i] = child[i];
+          }
+        }
+
+        iterations++;
+      } while (improvement && 
+        iterations < Iterations.Value.Value);
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/PrinsEncoding.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/PrinsEncoding.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Prins/PrinsEncoding.cs	(revision 4379)
@@ -0,0 +1,179 @@
+﻿#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.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using System;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  [Item("PrinsEncoding", "Represents an Prins encoding of VRP solutions. It is implemented as described in Prins, C. (2004). A simple and effective evolutionary algorithm for the vehicle routing problem. Computers & Operations Research, 12:1985-2002.")]
+  [StorableClass]
+  public class PrinsEncoding : PermutationEncoding {
+    #region IVRPEncoding Members
+    public override List<Tour> GetTours() {
+      List<Tour> result = new List<Tour>();
+
+      int cities = ProblemInstance.Cities.Value;
+
+      //Split permutation into vector P
+      int[] P = new int[cities + 1];
+      for (int i = 0; i <= cities; i++)
+        P[i] = -1;
+
+      double[] V = new double[cities + 1];
+      V[0] = 0;
+      for (int i = 1; i <= cities; i++) {
+        V[i] = int.MaxValue;
+      }
+
+      for (int i = 1; i <= cities; i++) {
+        int j = i;
+        Tour tour = new Tour();
+        bool feasible = true;
+
+        do {
+          tour.Stops.Add(this[j-1] + 1);
+
+          VRPEvaluation eval =
+            ProblemInstance.EvaluatorParameter.Value.Evaluate(ProblemInstance,
+             tour);
+
+          double cost = eval.Quality;
+          feasible = ProblemInstance.EvaluatorParameter.Value.Feasible(eval);
+
+          if (feasible) {
+            if (V[i - 1] + cost < V[j]) {
+              V[j] = V[i - 1] + cost;
+              P[j] = i - 1;
+            }
+            j++;
+          }
+
+        } while (j <= cities && feasible);
+      }
+
+      //extract VRP solution from vector P
+      int index = 0;
+      int index2 = cities;
+      Tour trip = null;
+      do {
+        index = P[index2];
+        trip = new Tour();
+
+        for (int k = index + 1; k <= index2; k++) {
+          trip.Stops.Add(this[k - 1] + 1);
+        }
+
+        if (trip.Stops.Count > 0)
+          result.Add(trip);
+
+        index2 = index;
+      } while (index != 0);
+
+      //if there are too many vehicles - repair
+      while (result.Count > ProblemInstance.Vehicles.Value) {
+        Tour tour = result[result.Count - 1];
+
+        //find predecessor / successor in permutation
+        int predecessorIndex = Array.IndexOf(this.array, tour.Stops[0] - 1) - 1;
+        if (predecessorIndex >= 0) {
+          int predecessor = this[predecessorIndex] + 1;
+
+          foreach (Tour t in result) {
+            int insertPosition = t.Stops.IndexOf(predecessor) + 1;
+            if (insertPosition != -1) {
+              t.Stops.InsertRange(insertPosition, tour.Stops);
+              break;
+            }
+          }
+        } else {
+          int successorIndex = Array.IndexOf(this.array,
+            tour.Stops[tour.Stops.Count - 1] - 1) + 1;
+          int successor = this[successorIndex] + 1;
+
+          foreach (Tour t in result) {
+            int insertPosition = t.Stops.IndexOf(successor);
+            if (insertPosition != -1) {
+              t.Stops.InsertRange(insertPosition, tour.Stops);
+              break;
+            }
+          }
+        }
+
+        result.Remove(tour);
+      }
+
+      return result;
+    }
+    #endregion
+
+    public override IDeepCloneable Clone(HeuristicLab.Common.Cloner cloner) {
+      PrinsEncoding clone = new PrinsEncoding(
+        new Permutation(this.PermutationType, this.array), ProblemInstance);
+
+      cloner.RegisterClonedObject(this, clone);
+      clone.readOnly = readOnly;
+      return clone;
+    }
+
+    public PrinsEncoding(Permutation permutation, IVRPProblemInstance problemInstance)
+      : base(permutation, problemInstance) {
+    }
+
+    [StorableConstructor]
+    private PrinsEncoding(bool serializing)
+      : base(serializing) {
+    }
+
+    public static PrinsEncoding ConvertFrom(IVRPEncoding encoding, IVRPProblemInstance problemInstance) {
+      List<Tour> tours = encoding.GetTours();
+      List<int> route = new List<int>();
+
+      foreach (Tour tour in tours) {
+        foreach (int city in tour.Stops)
+          route.Add(city - 1);
+      }
+
+      return new PrinsEncoding(
+        new Permutation(PermutationTypes.RelativeUndirected, route.ToArray()), problemInstance);
+    }
+
+    public static PrinsEncoding ConvertFrom(List<int> routeParam, IVRPProblemInstance problemInstance) {
+      List<int> route = new List<int>(routeParam);
+
+      while (route.Remove(0)) { //remove all delimiters (0)
+      }
+
+      for (int i = 0; i < route.Count; i++)
+        route[i]--;
+
+      return new PrinsEncoding(
+        new Permutation(PermutationTypes.RelativeUndirected, route.ToArray()), problemInstance);
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuCrossover.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuCrossover.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuCrossover.cs	(revision 4379)
@@ -0,0 +1,68 @@
+﻿#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.Optimization;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Zhu {
+  [Item("ZhuCrossover", "An operator which crosses two VRP representations.")]
+  [StorableClass]
+  public abstract class ZhuCrossover : VRPCrossover, IStochasticOperator, IZhuOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    
+    [StorableConstructor]
+    protected ZhuCrossover(bool deserializing) : base(deserializing) { }
+
+    public ZhuCrossover()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+    }
+
+    protected abstract ZhuEncoding Crossover(IRandom random, ZhuEncoding parent1, ZhuEncoding parent2);
+
+    public override IOperation Apply() {
+      ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
+      for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
+        IVRPEncoding solution = ParentsParameter.ActualValue[i];
+
+        if (!(solution is ZhuEncoding)) {
+          parents[i] = ZhuEncoding.ConvertFrom(solution, ProblemInstance);
+        } else {
+          parents[i] = solution;
+        }
+      }
+      ParentsParameter.ActualValue = parents;
+
+      ChildParameter.ActualValue =
+        Crossover(RandomParameter.ActualValue, parents[0] as ZhuEncoding, parents[1] as ZhuEncoding);
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuHeuristicCrossover1.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuHeuristicCrossover1.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuHeuristicCrossover1.cs	(revision 4379)
@@ -0,0 +1,84 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Zhu {
+  [Item("ZhuHeuristicCrossover1", "The Zhu Heuristic Crossover (Version 1). It is implemented as described in Zhu, K.Q. (2000). A New Genetic Algorithm For VRPTW. Proceedings of the International Conference on Artificial Intelligence.")]
+  [StorableClass]
+  public sealed class ZhuHeuristicCrossover1 : ZhuCrossover {    
+    [StorableConstructor]
+    private ZhuHeuristicCrossover1(bool deserializing) : base(deserializing) { }
+
+    public ZhuHeuristicCrossover1()
+      : base() {
+    }
+
+    private void Swap(ZhuEncoding individual, int city1, int city2) {
+      int index1 = individual.IndexOf(city1);
+      int index2 = individual.IndexOf(city2);
+
+      int temp = individual[index1];
+      individual[index1] = individual[index2];
+      individual[index2] = temp;
+    }
+
+    protected override ZhuEncoding Crossover(IRandom random, ZhuEncoding parent1, ZhuEncoding parent2) {
+      parent1 = parent1.Clone() as ZhuEncoding;
+      parent2 = parent2.Clone() as ZhuEncoding;
+
+      ZhuEncoding child = parent2.Clone() as ZhuEncoding;
+
+      int breakPoint = random.Next(child.Length);
+      int i = breakPoint;
+      int predecessor = breakPoint - 1;
+      if (predecessor < 0)
+        predecessor = predecessor + child.Length;
+
+      while (i != predecessor) {
+        if (i == breakPoint) {
+          child[i] = parent1[i];
+          Swap(parent2, parent2[i], parent1[i]);
+        }
+
+        if (ProblemInstance.GetDistance(
+          child[i] + 1, parent1[(i + 1) % child.Length] + 1)
+          <
+          ProblemInstance.GetDistance(
+          child[i] + 1, parent2[(i + 1) % child.Length] + 1)) {
+          child[(i + 1) % child.Length] = parent1[(i + 1) % child.Length];
+          Swap(parent2, parent2[(i + 1) % child.Length], parent1[(i + 1) % child.Length]);
+        } else {
+          child[(i + 1) % child.Length] = parent2[(i + 1) % child.Length];
+          Swap(parent1, parent1[(i + 1) % child.Length], parent2[(i + 1) % child.Length]);
+        }
+
+        i = (i + 1) % child.Length;
+      }
+
+      return child;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuHeuristicCrossover2.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuHeuristicCrossover2.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuHeuristicCrossover2.cs	(revision 4379)
@@ -0,0 +1,92 @@
+﻿#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 System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Zhu {
+  [Item("ZhuHeuristicCrossover2", "The Zhu Heuristic Crossover (Version 2). It is implemented as described in Zhu, K.Q. (2000). A New Genetic Algorithm For VRPTW. Proceedings of the International Conference on Artificial Intelligence.")]
+  [StorableClass]
+  public sealed class ZhuHeuristicCrossover2 : ZhuCrossover {    
+    [StorableConstructor]
+    private ZhuHeuristicCrossover2(bool deserializing) : base(deserializing) { }
+
+    public ZhuHeuristicCrossover2()
+      : base() {
+    }
+
+    protected override ZhuEncoding Crossover(IRandom random, ZhuEncoding parent1, ZhuEncoding parent2) {
+      List<int> p1 = new List<int>(parent1);
+      List<int> p2 = new List<int>(parent2);
+
+      ZhuEncoding child = parent2.Clone() as ZhuEncoding;
+
+      int breakPoint = random.Next(child.Length);
+      int i = breakPoint;
+      int predecessor = breakPoint - 1;
+      if (predecessor < 0)
+        predecessor = predecessor + child.Length;
+      
+      int parent1Index = i;
+      int parent2Index = i;
+
+      while (i != predecessor) {
+        if (i == breakPoint) {
+          child[i] = p1[parent1Index];
+          
+          p1.Remove(child[i]);
+          if (parent1Index >= p1.Count)
+            parent1Index = 0;
+
+          p2.Remove(child[i]);
+          if (parent2Index >= p2.Count)
+            parent2Index = 0;
+        }
+
+        if (ProblemInstance.GetDistance(
+         child[i] + 1, p1[parent1Index] + 1)
+         <
+         ProblemInstance.GetDistance(
+         child[i] + 1, p2[parent2Index] + 1)) {
+          child[(i + 1) % child.Length] = p1[parent1Index];
+        } else {
+          child[(i + 1) % child.Length] = p2[parent2Index];
+        }
+
+        p1.Remove(child[(i + 1) % child.Length]);
+        if (parent1Index >= p1.Count)
+          parent1Index = 0;
+
+        p2.Remove(child[(i + 1) % child.Length]);
+        if (parent2Index >= p2.Count)
+          parent2Index = 0;
+
+        i = (i + 1) % child.Length;
+      }
+
+      return child;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuMergeCrossover1.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuMergeCrossover1.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuMergeCrossover1.cs	(revision 4379)
@@ -0,0 +1,86 @@
+﻿#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.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Zhu {
+  [Item("ZhuMergeCrossover1", "The Zhu Merge Crossover (Version 1). It is implemented as described in Zhu, K.Q. (2000). A New Genetic Algorithm For VRPTW. Proceedings of the International Conference on Artificial Intelligence.")]
+  [StorableClass]
+  public sealed class ZhuMergeCrossover1 : ZhuCrossover {    
+    [StorableConstructor]
+    private ZhuMergeCrossover1(bool deserializing) : base(deserializing) { }
+
+    public ZhuMergeCrossover1()
+      : base() {
+    }
+
+    private void Swap(ZhuEncoding individual, int city1, int city2) {
+      int index1 = individual.IndexOf(city1);
+      int index2 = individual.IndexOf(city2);
+
+      int temp = individual[index1];
+      individual[index1] = individual[index2];
+      individual[index2] = temp;
+    }
+
+    protected override ZhuEncoding Crossover(IRandom random, ZhuEncoding parent1, ZhuEncoding parent2) {
+      parent1 = parent1.Clone() as ZhuEncoding;
+      parent2 = parent2.Clone() as ZhuEncoding;
+
+      ZhuEncoding child = parent2.Clone() as ZhuEncoding;
+
+      int breakPoint = random.Next(child.Length);
+      int i = breakPoint;
+
+      DoubleArray dueTime = null;
+      if (ProblemInstance is ITimeWindowedProblemInstance) {
+        dueTime = (ProblemInstance as ITimeWindowedProblemInstance).DueTime;
+      } 
+
+      do {
+        if (i == breakPoint) {
+          child[i] = parent1[i];
+          Swap(parent2, parent2[i], parent1[i]);
+        } else {
+          if (
+            (dueTime != null) &&
+            (dueTime[parent1[i] + 1] <
+             dueTime[parent2[i] + 1])) {
+            child[i] = parent1[i];
+            Swap(parent2, parent2[i], parent1[i]);
+          } else {
+            child[i] = parent2[i];
+            Swap(parent1, parent1[i], parent2[i]);
+          }
+        }
+
+        i = (i + 1) % child.Length;
+      } while (i != breakPoint);
+
+      return child;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuMergeCrossover2.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuMergeCrossover2.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuMergeCrossover2.cs	(revision 4379)
@@ -0,0 +1,85 @@
+﻿#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 System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Zhu {
+  [Item("ZhuMergeCrossover2", "The Zhu Merge Crossover (Version 2).  It is implemented as described in Zhu, K.Q. (2000). A New Genetic Algorithm For VRPTW. Proceedings of the International Conference on Artificial Intelligence.")]
+  [StorableClass]
+  public sealed class ZhuMergeCrossover2 : ZhuCrossover {    
+    [StorableConstructor]
+    private ZhuMergeCrossover2(bool deserializing) : base(deserializing) { }
+
+    public ZhuMergeCrossover2()
+      : base() {
+    }
+
+    protected override ZhuEncoding Crossover(IRandom random, ZhuEncoding parent1, ZhuEncoding parent2) {
+      List<int> p1 = new List<int>(parent1);
+      List<int> p2 = new List<int>(parent2);
+
+      ZhuEncoding child = parent2.Clone() as ZhuEncoding;
+
+      int breakPoint = random.Next(child.Length);
+      int i = breakPoint;
+
+      int parent1Index = i;
+      int parent2Index = i;
+
+      DoubleArray dueTime = null;
+      if (ProblemInstance is ITimeWindowedProblemInstance) {
+        dueTime = (ProblemInstance as ITimeWindowedProblemInstance).DueTime;
+      }
+
+      do {
+        if (i == breakPoint) {
+          child[i] = p1[parent1Index];
+        } else {
+          if (dueTime != null && 
+            (dueTime[p1[parent1Index] + 1] <
+            dueTime[p2[parent2Index] + 1])) {
+            child[i] = p1[parent1Index];
+          } else {
+            child[i] = p2[parent2Index];
+          }
+        }
+
+        p1.Remove(child[i]);
+        if (parent1Index >= p1.Count)
+          parent1Index = 0;
+
+        p2.Remove(child[i]);
+        if (parent2Index >= p2.Count)
+          parent2Index = 0;
+
+        i = (i + 1) % child.Length;
+      } while (i != breakPoint);
+
+      return child;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuPermutationCrossover.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuPermutationCrossover.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Crossovers/ZhuPermutationCrossover.cs	(revision 4379)
@@ -0,0 +1,63 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Zhu {
+  [Item("ZhuPermutationCrossover", "An operator which crosses two VRP representations using a standard permutation operator. It is implemented as described in Zhu, K.Q. (2000). A New Genetic Algorithm For VRPTW. Proceedings of the International Conference on Artificial Intelligence.")]
+  [StorableClass]
+  public sealed class PrinsPermutationCrossover : ZhuCrossover {    
+    public IValueLookupParameter<IPermutationCrossover> InnerCrossoverParameter {
+      get { return (IValueLookupParameter<IPermutationCrossover>)Parameters["InnerCrossover"]; }
+    }
+
+    [StorableConstructor]
+    private PrinsPermutationCrossover(bool deserializing) : base(deserializing) { }
+
+    public PrinsPermutationCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IPermutationCrossover>("InnerCrossover", "The permutation crossover.", new PartiallyMatchedCrossover()));
+    }
+
+    protected override ZhuEncoding Crossover(IRandom random, ZhuEncoding parent1, ZhuEncoding parent2) {
+      //note - the inner crossover is called here and the result is converted to a prins representation
+      //some refactoring should be done here in the future - the crossover operation should be called directly
+
+      InnerCrossoverParameter.ActualValue.ParentsParameter.ActualName = ParentsParameter.ActualName;
+      IAtomicOperation op = this.ExecutionContext.CreateOperation(
+        InnerCrossoverParameter.ActualValue, this.ExecutionContext.Scope);
+      op.Operator.Execute((IExecutionContext)op);
+
+      string childName = InnerCrossoverParameter.ActualValue.ChildParameter.ActualName;
+      if (ExecutionContext.Scope.Variables.ContainsKey(childName)) {
+        Permutation permutation = ExecutionContext.Scope.Variables[childName].Value as Permutation;
+        ExecutionContext.Scope.Variables.Remove(childName);
+
+        return new ZhuEncoding(permutation, ProblemInstance);
+      } else
+        return null;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/IZhuOperator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/IZhuOperator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/IZhuOperator.cs	(revision 4379)
@@ -0,0 +1,37 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Operators;
+using HeuristicLab.Problems.VehicleRouting.Variants;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Zhu {
+  public interface IZhuOperator : 
+    ISingleDepotOperator, IHomogenousCapacitatedOperator, ITimeWindowedOperator {    
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Manipulators/ZhuManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Manipulators/ZhuManipulator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Manipulators/ZhuManipulator.cs	(revision 4379)
@@ -0,0 +1,60 @@
+﻿#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.Optimization;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Zhu {
+  [Item("ZhuManipulator", "An operator which manipulates a VRP representation.")]
+  [StorableClass]
+  public abstract class ZhuManipulator : VRPManipulator, IStochasticOperator, IZhuOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    [StorableConstructor]
+    protected ZhuManipulator(bool deserializing) : base(deserializing) { }
+
+    public ZhuManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+    }
+
+    protected abstract void Manipulate(IRandom random, ZhuEncoding individual);
+
+    public override IOperation Apply() {
+      IVRPEncoding solution = VRPToursParameter.ActualValue;
+      if (!(solution is ZhuEncoding)) {
+        VRPToursParameter.ActualValue = ZhuEncoding.ConvertFrom(solution, ProblemInstance);
+      }
+
+      Manipulate(RandomParameter.ActualValue, VRPToursParameter.ActualValue as ZhuEncoding);
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Manipulators/ZhuPermutationManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Manipulators/ZhuPermutationManipulator.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/Manipulators/ZhuPermutationManipulator.cs	(revision 4379)
@@ -0,0 +1,52 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Zhu {
+  [Item("ZhuPermutationManipulator", "An operator which manipulates a VRP representation by using a standard permutation manipulator. It is implemented as described in Zhu, K.Q. (2000). A New Genetic Algorithm For VRPTW. Proceedings of the International Conference on Artificial Intelligence.")]
+  [StorableClass]
+  public sealed class ZhuPermutationManipulator : ZhuManipulator {
+    public IValueLookupParameter<IPermutationManipulator> InnerManipulatorParameter {
+      get { return (IValueLookupParameter<IPermutationManipulator>)Parameters["InnerManipulator"]; }
+    }
+
+    [StorableConstructor]
+    private ZhuPermutationManipulator(bool deserializing) : base(deserializing) { }
+
+    public ZhuPermutationManipulator()
+      : base() {
+        Parameters.Add(new ValueLookupParameter<IPermutationManipulator>("InnerManipulator", "The permutation manipulator.", new TranslocationManipulator()));
+    }
+
+    protected override void Manipulate(IRandom random, ZhuEncoding individual) {
+      InnerManipulatorParameter.ActualValue.PermutationParameter.ActualName = VRPToursParameter.ActualName;
+
+      IAtomicOperation op = this.ExecutionContext.CreateOperation(
+        InnerManipulatorParameter.ActualValue, this.ExecutionContext.Scope);
+      op.Operator.Execute((IExecutionContext)op);
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/ZhuEncoding.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/ZhuEncoding.cs	(revision 4379)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/Encodings/Zhu/ZhuEncoding.cs	(revision 4379)
@@ -0,0 +1,139 @@
+﻿#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.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using System;
+using HeuristicLab.Problems.VehicleRouting.Interfaces;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Zhu {
+  [Item("ZhuEncoding", "Represents a Zhu encoding of VRP solutions. It is implemented as described in Zhu, K.Q. (2000). A New Genetic Algorithm For VRPTW. Proceedings of the International Conference on Artificial Intelligence.")]
+  [StorableClass]
+  public class ZhuEncoding : PermutationEncoding {
+    #region IVRPEncoding Members
+    public override List<Tour> GetTours() {
+      List<Tour> result = new List<Tour>();
+
+      Tour newTour = new Tour();
+
+      for (int i = 0; i < this.Length; i++) {
+        int city = this[i] + 1;
+        newTour.Stops.Add(city);
+        if (!ProblemInstance.Feasible(newTour)) {
+          newTour.Stops.Remove(city);
+          if (newTour.Stops.Count > 0)
+              result.Add(newTour);
+
+            newTour = new Tour();
+            newTour.Stops.Add(city);
+        }
+      }
+
+      if (newTour.Stops.Count > 0)
+        result.Add(newTour);
+
+      //if there are too many vehicles - repair
+      while (result.Count > ProblemInstance.Vehicles.Value) {
+        Tour tour = result[result.Count - 1];
+
+        //find predecessor / successor in permutation
+        int predecessorIndex = Array.IndexOf(this.array, tour.Stops[0] - 1) - 1;
+        if (predecessorIndex >= 0) {
+          int predecessor = this[predecessorIndex] + 1;
+
+          foreach (Tour t in result) {
+            int insertPosition = t.Stops.IndexOf(predecessor) + 1;
+            if (insertPosition != -1) {
+              t.Stops.InsertRange(insertPosition, tour.Stops);
+              break;
+            }
+          }
+        } else {
+          int successorIndex = Array.IndexOf(this.array,
+            tour.Stops[tour.Stops.Count - 1] - 1) + 1;
+          int successor = this[successorIndex] + 1;
+
+          foreach (Tour t in result) {
+            int insertPosition = t.Stops.IndexOf(successor);
+            if (insertPosition != -1) {
+              t.Stops.InsertRange(insertPosition, tour.Stops);
+              break;
+            }
+          }
+        }
+
+        result.Remove(tour);
+      }
+
+      return result;
+    }
+    #endregion
+
+    public override IDeepCloneable Clone(HeuristicLab.Common.Cloner cloner) {
+      ZhuEncoding clone = new ZhuEncoding(
+        new Permutation(this.PermutationType, this.array), ProblemInstance);
+
+      cloner.RegisterClonedObject(this, clone);
+      clone.readOnly = readOnly;
+      return clone;
+    }
+
+    public ZhuEncoding(Permutation permutation, IVRPProblemInstance problemInstance)
+      : base(permutation, problemInstance) {
+    }
+
+    [StorableConstructor]
+    private ZhuEncoding(bool serializing)
+      : base(serializing) {
+    }
+
+    public static ZhuEncoding ConvertFrom(IVRPEncoding encoding, IVRPProblemInstance problemInstance) {
+      List<Tour> tours = encoding.GetTours();
+      List<int> route = new List<int>();
+
+      foreach (Tour tour in tours) {
+        foreach (int city in tour.Stops)
+          route.Add(city - 1);
+      }
+
+      return new ZhuEncoding(
+        new Permutation(PermutationTypes.RelativeUndirected, route.ToArray()), problemInstance);
+    }
+
+    public static ZhuEncoding ConvertFrom(List<int> routeParam, IVRPProblemInstance problemInstance) {
+      List<int> route = new List<int>(routeParam);
+
+      while (route.Remove(0)) { //remove all delimiters (0)
+      }
+
+      for (int i = 0; i < route.Count; i++)
+        route[i]--;
+
+      return new ZhuEncoding(
+        new Permutation(PermutationTypes.RelativeUndirected, route.ToArray()), problemInstance);
+    }
+  }
+}
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 4378)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.4/HeuristicLab.Problems.VehicleRouting-3.4.csproj	(revision 4379)
@@ -179,4 +179,12 @@
     <Compile Include="Encodings\General\PermutationEncoding.cs" />
     <Compile Include="Encodings\General\TourEncoding.cs" />
+    <Compile Include="Encodings\GVR\Crossovers\GVRCrossover.cs" />
+    <Compile Include="Encodings\GVR\GVREncoding.cs" />
+    <Compile Include="Encodings\GVR\IGVROperator.cs" />
+    <Compile Include="Encodings\GVR\Manipulators\GVRDisplacementManipulator.cs" />
+    <Compile Include="Encodings\GVR\Manipulators\GVRInsertionManipulator.cs" />
+    <Compile Include="Encodings\GVR\Manipulators\GVRInversionManipulator.cs" />
+    <Compile Include="Encodings\GVR\Manipulators\GVRManipulator.cs" />
+    <Compile Include="Encodings\GVR\Manipulators\GVRSwapManipulator.cs" />
     <Compile Include="Encodings\Potvin\Crossovers\PotvinCrossover.cs" />
     <Compile Include="Encodings\Potvin\Crossovers\PotvinRouteBasedCrossover.cs" />
@@ -188,5 +196,24 @@
     <Compile Include="Encodings\Potvin\Manipulators\PotvinTwoLevelExchangeManipulator.cs" />
     <Compile Include="Encodings\Potvin\PotvinEncoding.cs" />
+    <Compile Include="Encodings\Prins\Crossovers\PrinsCrossover.cs" />
+    <Compile Include="Encodings\Prins\Crossovers\PrinsPermutationCrossover.cs" />
+    <Compile Include="Encodings\Prins\IPrinsOperator.cs" />
+    <Compile Include="Encodings\Prins\Manipulators\PrinsExhaustiveLSManipulator.cs" />
+    <Compile Include="Encodings\Prins\Manipulators\PrinsLSManipulator.cs" />
+    <Compile Include="Encodings\Prins\Manipulators\PrinsManipulator.cs" />
+    <Compile Include="Encodings\Prins\Manipulators\PrinsPermutationManipulator.cs" />
+    <Compile Include="Encodings\Prins\Manipulators\PrinsStochasticLSManipulator.cs" />
+    <Compile Include="Encodings\Prins\PrinsEncoding.cs" />
     <Compile Include="Encodings\VRPOperator.cs" />
+    <Compile Include="Encodings\Zhu\Crossovers\ZhuCrossover.cs" />
+    <Compile Include="Encodings\Zhu\Crossovers\ZhuHeuristicCrossover1.cs" />
+    <Compile Include="Encodings\Zhu\Crossovers\ZhuHeuristicCrossover2.cs" />
+    <Compile Include="Encodings\Zhu\Crossovers\ZhuMergeCrossover1.cs" />
+    <Compile Include="Encodings\Zhu\Crossovers\ZhuMergeCrossover2.cs" />
+    <Compile Include="Encodings\Zhu\Crossovers\ZhuPermutationCrossover.cs" />
+    <Compile Include="Encodings\Zhu\IZhuOperator.cs" />
+    <Compile Include="Encodings\Zhu\Manipulators\ZhuManipulator.cs" />
+    <Compile Include="Encodings\Zhu\Manipulators\ZhuPermutationManipulator.cs" />
+    <Compile Include="Encodings\Zhu\ZhuEncoding.cs" />
     <Compile Include="Interfaces\IMultiVRPOperator.cs" />
     <Compile Include="Interfaces\IVRPManipulator.cs" />
