Index: branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.3/VRPSolutionView.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.3/VRPSolutionView.cs	(revision 4229)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.3/VRPSolutionView.cs	(revision 4230)
@@ -119,5 +119,5 @@
               if (Content.Solution != null) {
                 int currentTour = 0;
-                foreach (Tour tour in Content.Solution.Tours) {
+                foreach (Tour tour in Content.Solution.GetTours()) {
                   double t = 0.0;
                   Point[] tourPoints = new Point[tour.Cities.Count + 2];
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/AlbaEncoding.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/AlbaEncoding.cs	(revision 4229)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/AlbaEncoding.cs	(revision 4230)
@@ -26,4 +26,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
@@ -35,27 +36,25 @@
     
     #region IVRPEncoding Members
-    public ItemList<Tour> Tours {
-      get {
-        ItemList<Tour> result = new ItemList<Tour>();
-        
-        Tour tour = new Tour();
-        for (int i = 0; i < this.array.Length; i++) {
-          if (this.array[i] >= cities) {
-            if (tour.Cities.Count > 0) {
-              result.Add(tour);
+    public List<Tour> GetTours() {
+      List<Tour> result = new List<Tour>();
 
-              tour = new Tour();
-            }
-          } else {
-            tour.Cities.Add(this.array[i] + 1);
+      Tour tour = new Tour();
+      for (int i = 0; i < this.array.Length; i++) {
+        if (this.array[i] >= cities) {
+          if (tour.Cities.Count > 0) {
+            result.Add(tour);
+
+            tour = new Tour();
           }
+        } else {
+          tour.Cities.Add(this.array[i] + 1);
         }
+      }
 
-        if (tour.Cities.Count > 0) {
-          result.Add(tour);
-        }
+      if (tour.Cities.Count > 0) {
+        result.Add(tour);
+      }
 
-        return result;
-      }
+      return result;
     }
 
@@ -93,5 +92,5 @@
 
     public static AlbaEncoding ConvertFrom(IVRPEncoding encoding, int vehicles) {
-      ItemList<Tour> tours = encoding.Tours;
+      List<Tour> tours = encoding.GetTours();
 
       int cities = 0;
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/IntraRouteInversionManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/IntraRouteInversionManipulator.cs	(revision 4229)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/IntraRouteInversionManipulator.cs	(revision 4230)
@@ -56,5 +56,5 @@
 
       List<Tour> validTours = new List<Tour>();
-      foreach (Tour tour in individual.Tours) {
+      foreach (Tour tour in individual.GetTours()) {
         if (tour.Cities.Count >= 4)
           validTours.Add(tour);
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/LambdaInterchangeManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/LambdaInterchangeManipulator.cs	(revision 4229)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/LambdaInterchangeManipulator.cs	(revision 4230)
@@ -26,4 +26,5 @@
 using HeuristicLab.Data;
 using System;
+using System.Collections.Generic;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
@@ -45,5 +46,7 @@
     public static void Apply(AlbaEncoding individual, int tour1Index, int position1, int length1, 
       int tour2Index, int position2, int length2) {
-      Tour tour1 = individual.Tours[tour1Index];
+      List<Tour> tours = individual.GetTours();
+
+      Tour tour1 = tours[tour1Index];
       int tour1Start = -1;
       for (int i = 0; i < individual.Length; i++) {
@@ -54,5 +57,5 @@
       }
 
-      Tour tour2 = individual.Tours[tour2Index];
+      Tour tour2 = tours[tour2Index];
       int tour2Start = -1;
       for (int i = 0; i < individual.Length; i++) {
@@ -96,13 +99,14 @@
 
     protected override void Manipulate(IRandom rand, AlbaEncoding individual) {
+      List<Tour> tours = individual.GetTours();
       int lambda = LambdaParameter.Value.Value;
-      
-      int route1Index = rand.Next(individual.Tours.Count);
-      Tour route1 = individual.Tours[route1Index];
 
-      int route2Index = rand.Next(individual.Tours.Count - 1);
+      int route1Index = rand.Next(tours.Count);
+      Tour route1 = tours[route1Index];
+
+      int route2Index = rand.Next(tours.Count - 1);
       if (route2Index >= route1Index)
         route2Index += 1;
-      Tour route2 = individual.Tours[route2Index];
+      Tour route2 = tours[route2Index];
 
       int length1 = rand.Next(Math.Min(lambda + 1, route1.Cities.Count + 1));
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/IntraRouteInversion/StochasticIntraRouteInversionSingleMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/IntraRouteInversion/StochasticIntraRouteInversionSingleMoveGenerator.cs	(revision 4229)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/IntraRouteInversion/StochasticIntraRouteInversionSingleMoveGenerator.cs	(revision 4230)
@@ -59,5 +59,5 @@
 
       List<Tour> validTours = new List<Tour>();
-      foreach (Tour tour in individual.Tours) {
+      foreach (Tour tour in individual.GetTours()) {
         if (tour.Cities.Count >= 4)
           validTours.Add(tour);
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/ExhaustiveLambdaInterchangeMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/ExhaustiveLambdaInterchangeMoveGenerator.cs	(revision 4229)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/ExhaustiveLambdaInterchangeMoveGenerator.cs	(revision 4230)
@@ -42,8 +42,10 @@
       List<LambdaInterchangeMove> moves = new List<LambdaInterchangeMove>();
 
-      for (int tour1Index = 0; tour1Index < individual.Tours.Count; tour1Index++) {
-        Tour tour1 = individual.Tours[tour1Index];
-        for (int tour2Index = tour1Index + 1; tour2Index < individual.Tours.Count; tour2Index++) {
-          Tour tour2 = individual.Tours[tour2Index];
+      List<Tour> tours = individual.GetTours();
+
+      for (int tour1Index = 0; tour1Index < tours.Count; tour1Index++) {
+        Tour tour1 = tours[tour1Index];
+        for (int tour2Index = tour1Index + 1; tour2Index < tours.Count; tour2Index++) {
+          Tour tour2 = tours[tour2Index];
 
           for (int length1 = 0; length1 <= Math.Min(lambda, tour1.Cities.Count); length1++) {
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/StochasticLambdaInterchangeSingleMoveGenerator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/StochasticLambdaInterchangeSingleMoveGenerator.cs	(revision 4229)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/StochasticLambdaInterchangeSingleMoveGenerator.cs	(revision 4230)
@@ -55,11 +55,13 @@
 
     public static LambdaInterchangeMove Apply(AlbaEncoding individual, int cities, int lambda, IRandom rand) {
-      int route1Index = rand.Next(individual.Tours.Count);
-      Tour route1 = individual.Tours[route1Index];
+      List<Tour> tours = individual.GetTours();
 
-      int route2Index = rand.Next(individual.Tours.Count - 1);
+      int route1Index = rand.Next(tours.Count);
+      Tour route1 = tours[route1Index];
+
+      int route2Index = rand.Next(tours.Count - 1);
       if (route2Index >= route1Index)
         route2Index += 1;
-      Tour route2 = individual.Tours[route2Index];
+      Tour route2 = tours[route2Index];
 
       int length1 = rand.Next(Math.Min(lambda + 1, route1.Cities.Count + 1));
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Crossovers/GVRCrossover.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Crossovers/GVRCrossover.cs	(revision 4230)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Crossovers/GVRCrossover.cs	(revision 4230)
@@ -0,0 +1,121 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.GVR {
+  [Item("GVRCrossover", "The GVR crossover operation.")]
+  [StorableClass]
+  public sealed class GVRCrossover : VRPCrossover, IStochasticOperator {
+    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."));
+
+      //remove unused parameters
+      Parameters.Remove("ReadyTime");
+      Parameters.Remove("DueTime");
+      Parameters.Remove("ServiceTime");
+    }
+
+    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.Cities.Count);
+      int length = random.Next(1, tour.Cities.Count - breakPoint1 + 1);
+      List<int> subroute = tour.Cities.GetRange(breakPoint1, length);
+      
+      //remove duplicates
+      List<Tour> toBeRemoved = new List<Tour>();
+
+      foreach (Tour route in child.Tours) {
+        foreach (int city in subroute) {
+          route.Cities.Remove(city);
+        }
+
+        if (route.Cities.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 <= Cities; i++) {
+        if (!subroute.Contains(i)) {
+          double distance = VRPUtilities.GetDistance(subroute[0], i, CoordinatesParameter.ActualValue,
+            DistanceMatrixParameter, UseDistanceMatrixParameter.ActualValue);
+
+          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.Cities.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, CapacityParameter.ActualValue, DemandParameter.ActualValue, 
+            VehiclesParameter.ActualValue);
+        } 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.3/Encodings/GVR/GVREncoding.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/GVREncoding.cs	(revision 4230)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/GVREncoding.cs	(revision 4230)
@@ -0,0 +1,132 @@
+﻿#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;
+
+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 {
+    [Storable]
+    private DoubleValue capacity { get; set; }
+
+    [Storable]
+    private IntValue vehicles { get; set; }
+
+    [Storable]
+    private DoubleArray demand { get; set; }
+
+    public override List<Tour> GetTours() {
+      List<Tour> tours = new List<Tour>();
+
+      int toursProcessed = 0;
+      foreach (Tour tour in base.Tours) {
+        Tour newTour = new Tour();
+        double currentDemand = 0;
+
+        foreach (int city in tour.Cities) {
+          currentDemand += demand[city];
+
+          if (vehicles.Value > tours.Count + base.Tours.Count - toursProcessed && 
+            currentDemand > capacity.Value) {
+            if(newTour.Cities.Count > 0)
+              tours.Add(newTour);
+
+            newTour = new Tour();
+            newTour.Cities.Add(city);
+            currentDemand = demand[city];
+          } else {
+            newTour.Cities.Add(city);
+          }
+        }
+
+        if (newTour.Cities.Count > 0)
+          tours.Add(newTour);
+        toursProcessed++;
+      }
+
+      return tours;
+    }
+    
+    public override IDeepCloneable Clone(HeuristicLab.Common.Cloner cloner) {
+      GVREncoding clone = new GVREncoding(capacity, demand, vehicles);
+      cloner.RegisterClonedObject(this, clone);
+      clone.Tours = (ItemList<Tour>)cloner.Clone(this.Tours);
+     
+      return clone;
+    }
+
+    public GVREncoding(DoubleValue capacity, DoubleArray demand, IntValue vehicles)
+      : base() {
+        this.capacity = capacity;
+        this.demand = demand;
+        this.vehicles = vehicles;
+    }
+
+    [StorableConstructor]
+    private GVREncoding(bool serializing)
+      : base() {
+    }
+
+    public static GVREncoding ConvertFrom(IVRPEncoding encoding, DoubleValue capacity, DoubleArray demand, IntValue vehicles) {
+      GVREncoding solution = new GVREncoding(capacity, demand, vehicles);
+
+      TourEncoding.ConvertFrom(encoding, solution);
+
+      return solution;
+    }
+
+    public static GVREncoding ConvertFrom(List<int> route, DoubleValue capacity, DoubleArray demand, IntValue vehicles) {
+      GVREncoding solution = new GVREncoding(capacity, demand, vehicles);
+
+      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].Cities.Count) {
+          if (Tours[currentTour].Cities[currentCity] == customer) {
+            tour = Tours[currentTour];
+            index = currentCity;
+          }
+
+          currentCity++;
+        }
+
+        currentTour++;
+      }
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRDisplacementManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRDisplacementManipulator.cs	(revision 4230)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRDisplacementManipulator.cs	(revision 4230)
@@ -0,0 +1,65 @@
+﻿#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. ")]
+  [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.Cities.Count);
+      int length = random.Next(1, tour.Cities.Count - breakPoint1 + 1);
+
+      List<int> displaced = tour.Cities.GetRange(breakPoint1, length);
+      tour.Cities.RemoveRange(breakPoint1, length);
+      //with a probability of 1/(2*V) create a new tour, else insert at another position
+      if (individual.GetTours().Count < VehiclesParameter.ActualValue.Value && 
+        random.Next(individual.GetTours().Count * 2) == 0) {
+        Tour newTour = new Tour();
+        newTour.Cities.InsertRange(0, displaced);
+
+        individual.Tours.Add(newTour);
+      } else {
+        Tour newTour = individual.Tours[random.Next(individual.Tours.Count)];
+        int newPosition = newTour.Cities.Count;
+
+        newTour.Cities.InsertRange(newPosition, displaced);
+      }
+
+      if (tour.Cities.Count == 0)
+        individual.Tours.Remove(tour);
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRInsertionManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRInsertionManipulator.cs	(revision 4230)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRInsertionManipulator.cs	(revision 4230)
@@ -0,0 +1,65 @@
+﻿#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. ")]
+  [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.Cities.RemoveAt(position);
+
+      //with a probability of 1/(2*V) create a new tour, else insert at another position
+      if (individual.GetTours().Count < VehiclesParameter.ActualValue.Value && 
+        random.Next(individual.GetTours().Count * 2) == 0) {
+        Tour newTour = new Tour();
+        newTour.Cities.Add(customer);
+       
+        individual.Tours.Add(newTour);
+      } else {
+        Tour newTour = individual.Tours[random.Next(individual.Tours.Count)];
+        int newPosition = newTour.Cities.Count;
+
+        newTour.Cities.Insert(newPosition, customer);
+      }
+
+      if (tour.Cities.Count == 0)
+        individual.Tours.Remove(tour);
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRInversionManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRInversionManipulator.cs	(revision 4230)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRInversionManipulator.cs	(revision 4230)
@@ -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. ")]
+  [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.Cities.Count);
+      int length = random.Next(1, tour.Cities.Count - breakPoint1 + 1);
+
+      tour.Cities.Reverse(breakPoint1, length);
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRManipulator.cs	(revision 4230)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRManipulator.cs	(revision 4230)
@@ -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 HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.GVR {
+  [Item("GVRManipulator", "A VRP manipulation operation.")]
+  [StorableClass]
+  public abstract class GVRManipulator : VRPManipulator, IStochasticOperator {
+    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."));
+
+      //remove unused parameters
+      Parameters.Remove("Coordinates");
+      Parameters.Remove("DistanceMatrix");
+      Parameters.Remove("UseDistanceMatrix");
+      Parameters.Remove("ReadyTime");
+      Parameters.Remove("DueTime");
+      Parameters.Remove("ServiceTime");
+    }
+
+    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, CapacityParameter.ActualValue, DemandParameter.ActualValue, 
+          VehiclesParameter.ActualValue);
+      }
+
+      Manipulate(RandomParameter.ActualValue, VRPToursParameter.ActualValue as GVREncoding);
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRSwapManipulator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRSwapManipulator.cs	(revision 4230)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRSwapManipulator.cs	(revision 4230)
@@ -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. ")]
+  [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.Cities[pos1];
+      tour1.Cities[pos1] = tour2.Cities[pos2];
+      tour2.Cities[pos2] = temp;
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/TourEncoding.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/TourEncoding.cs	(revision 4230)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/TourEncoding.cs	(revision 4230)
@@ -0,0 +1,89 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.General {
+  [Item("TourEncoding", "Represents a base class for tour encodings of VRP solutions.")]
+  [StorableClass]
+  public abstract class TourEncoding : Item, IVRPEncoding {
+    public override Image ItemImage {
+      get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Class; }
+    }
+    
+    #region IVRPEncoding Members
+    public virtual List<Tour> GetTours() {
+      return new List<Tour>(Tours);
+    }
+
+    public int Cities {
+      get 
+      {
+        int cities = 0;
+
+        foreach (Tour tour in Tours) {
+          cities += tour.Cities.Count;
+        }
+
+        return cities;
+      }
+    }
+    #endregion
+
+    [Storable]
+    public ItemList<Tour> Tours { get; set; }
+
+    public TourEncoding() {
+      Tours = new ItemList<Tour>();
+    }
+
+    [StorableConstructor]
+    protected TourEncoding(bool serializing)
+      : base() {
+    }
+    
+    public static void ConvertFrom(IVRPEncoding encoding, TourEncoding solution) {
+      solution.Tours = new ItemList<Tour>(encoding.GetTours());
+    }
+
+    public static void ConvertFrom(List<int> route, TourEncoding solution) {
+      solution.Tours = new ItemList<Tour>();
+      
+      Tour tour = new Tour();
+      for (int i = 0; i < route.Count; i++) {
+        if (route[i] == 0) {
+          if (tour.Cities.Count > 0) {
+            solution.Tours.Add(tour);
+            tour = new Tour();
+          }
+        } else {
+          tour.Cities.Add(route[i]);
+        }
+      }
+    }
+  }
+}
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/PotvinEncoding.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/PotvinEncoding.cs	(revision 4229)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/PotvinEncoding.cs	(revision 4230)
@@ -27,31 +27,10 @@
 using System.Drawing;
 using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
   [Item("PotvinEncoding", "Represents a potvin encoding of VRP solutions. It is implemented as described in Potvin, J.-Y. and Bengio, S. (1996). The Vehicle Routing Problem with Time Windows - Part II: Genetic Search. INFORMS Journal of Computing, 8:165–172.")]
   [StorableClass]
-  public class PotvinEncoding : Item, IVRPEncoding {
-    public override Image ItemImage {
-      get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Class; }
-    }
-    
-    #region IVRPEncoding Members
-    [Storable]
-    public ItemList<Tour> Tours { get; set; }
-
-    public int Cities {
-      get 
-      {
-        int cities = 0;
-
-        foreach (Tour tour in Tours) {
-          cities += tour.Cities.Count;
-        }
-
-        return cities;
-      }
-    }
-    #endregion
-
+  public class PotvinEncoding : TourEncoding {   
     [Storable]
     public List<int> Unrouted { get; set; }
@@ -65,7 +44,11 @@
     }
 
-    public PotvinEncoding() {
-      Tours = new ItemList<Tour>();
+    public PotvinEncoding(): base() {
       Unrouted = new List<int>();
+    }
+
+    [StorableConstructor]
+    private PotvinEncoding(bool serializing)
+      : base() {
     }
     
@@ -73,6 +56,5 @@
       PotvinEncoding solution = new PotvinEncoding();
 
-      solution.Tours.AddRange(
-        encoding.Tours);
+      TourEncoding.ConvertFrom(encoding, solution);
 
       return solution;
@@ -82,15 +64,5 @@
       PotvinEncoding solution = new PotvinEncoding();
 
-      Tour tour = new Tour();
-      for (int i = 0; i < route.Count; i++) {
-        if (route[i] == 0) {
-          if (tour.Cities.Count > 0) {
-            solution.Tours.Add(tour);
-            tour = new Tour();
-          }
-        } else {
-          tour.Cities.Add(route[i]);
-        }
-      }
+      TourEncoding.ConvertFrom(route, solution);
 
       return solution;
@@ -115,5 +87,5 @@
             if (Tours[tour].Feasible(dueTimeArray, serviceTimeArray, readyTimeArray, demandArray, 
               capacity, coordinates, distanceMatrix, useDistanceMatrix)) {
-              double newLength = Tours[tour].GetLength(coordinates, distanceMatrix, useDistanceMatrix);
+                double newLength = Tours[tour].GetLength(coordinates, distanceMatrix, useDistanceMatrix);
 
               double detour = newLength - length;
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Evaluators/VRPEvaluator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Evaluators/VRPEvaluator.cs	(revision 4229)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Evaluators/VRPEvaluator.cs	(revision 4230)
@@ -101,5 +101,5 @@
       IVRPEncoding vrpSolution = VRPToursParameter.ActualValue;
 
-      return vrpSolution.Tours.Count;
+      return vrpSolution.GetTours().Count;
     }
 
@@ -190,5 +190,5 @@
       sumEval.Tardiness = 0;
 
-      foreach (Tour tour in solution.Tours) {
+      foreach (Tour tour in solution.GetTours()) {
         TourEvaluation eval = EvaluateTour(tour, dueTimeArray, serviceTimeArray, readyTimeArray, demandArray, capacity,
           fleetUsageFactor, timeFactor, distanceFactor, overloadPenalty, tardinessPenalty,
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLab.Problems.VehicleRouting-3.3.csproj
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLab.Problems.VehicleRouting-3.3.csproj	(revision 4229)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLab.Problems.VehicleRouting-3.3.csproj	(revision 4230)
@@ -140,4 +140,12 @@
     <Compile Include="Encodings\General\Moves\MultiVRPMoveOperator\MultiVRPMoveMaker.cs" />
     <Compile Include="Encodings\General\Moves\MultiVRPMoveOperator\MultiVRPMoveGenerator.cs" />
+    <Compile Include="Encodings\General\TourEncoding.cs" />
+    <Compile Include="Encodings\GVR\Crossovers\GVRCrossover.cs" />
+    <Compile Include="Encodings\GVR\GVREncoding.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\GVRSwapManipulator.cs" />
+    <Compile Include="Encodings\GVR\Manipulators\GVRManipulator.cs" />
     <Compile Include="Encodings\Potvin\Crossovers\RouteBasedCrossover.cs" />
     <Compile Include="Encodings\Potvin\Crossovers\SequenceBasedCrossover.cs" />
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPEncoding.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPEncoding.cs	(revision 4229)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPEncoding.cs	(revision 4230)
@@ -22,10 +22,9 @@
 using HeuristicLab.Core;
 using HeuristicLab.Problems.VehicleRouting.Encodings;
+using System.Collections.Generic;
 
 namespace HeuristicLab.Problems.VehicleRouting {
   public interface IVRPEncoding : IItem {
-    ItemList<Tour> Tours {
-      get;
-    }
+    List<Tour> GetTours();
   }
 }
Index: branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VRPOperator.cs
===================================================================
--- branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VRPOperator.cs	(revision 4229)
+++ branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VRPOperator.cs	(revision 4230)
@@ -140,5 +140,5 @@
       bool feasible = true;
 
-      foreach (Tour tour in solution.Tours) {
+      foreach (Tour tour in solution.GetTours()) {
         if (!Feasible(tour)) {
           feasible = false;
