Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/AlbaEncoding.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/AlbaEncoding.cs	(revision 4143)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/AlbaEncoding.cs	(revision 4150)
@@ -25,4 +25,5 @@
 using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Collections.Generic;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
@@ -30,7 +31,42 @@
   [StorableClass]
   class AlbaEncoding : Permutation, IVRPEncoding {
-    #region IVRPEncoding Members
     [Storable]
     private int cities;
+    
+    #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.Count > 0) {
+              result.Add(tour);
+
+              tour = new Tour();
+            }
+          } else {
+            tour.Add(new IntValue(this.array[i] + 1));
+          }
+        }
+
+        if (tour.Count > 0) {
+          result.Add(tour);
+        }
+
+        return result;
+      }
+    }
+
+    public int Cities {
+      get { return cities; }
+    }
+
+    public int MaxVehicles {
+      get { return Length - Cities;  }
+    }
+
+    #endregion
 
     public override IDeepCloneable Clone(HeuristicLab.Common.Cloner cloner) {
@@ -43,5 +79,5 @@
 
     public AlbaEncoding(Permutation permutation, int cities)
-      : base(PermutationTypes.RelativeDirected) {
+      : base(PermutationTypes.RelativeUndirected) {
       this.array = new int[permutation.Length];
       for (int i = 0; i < array.Length; i++)
@@ -56,40 +92,5 @@
     }
 
-    public ItemList<Tour> Tours {
-      get {
-        ItemList<Tour> result = new ItemList<Tour>();
-        Tour tour = new Tour();
-        tour.Add(new IntValue(0));
-
-        for (int i = 0; i < this.array.Length; i++) {
-          if (this.array[i] >= cities) {
-            if (tour.Count > 1) {
-              tour.Add(new IntValue(0));
-              result.Add(tour);
-
-              tour = new Tour();
-              tour.Add(new IntValue(0));
-            }
-          } else {
-            tour.Add(new IntValue(this.array[i] + 1));
-          }
-        }
-
-        if (tour.Count > 1) {
-          tour.Add(new IntValue(0));
-          result.Add(tour);
-        }
-
-        return result;
-      }
-    }
-
-    public int Cities {
-      get { return cities; }
-    }
-
-    #endregion
-
-    public static AlbaEncoding ConvertFrom(IVRPEncoding encoding) {
+    public static AlbaEncoding ConvertFrom(IVRPEncoding encoding, int vehicles) {
       ItemList<Tour> tours = encoding.Tours;
 
@@ -98,5 +99,8 @@
         cities += tour.Count;
       }
-      int[] array = new int[cities + tours.Count - 2];
+
+      int emptyVehicles = vehicles - tours.Count;
+
+      int[] array = new int[cities + tours.Count + emptyVehicles - 1];
       int delimiter = cities;
       int arrayIndex = 0;
@@ -104,7 +108,6 @@
       foreach (Tour tour in tours) {
         foreach (IntValue city in tour) {
-          array[arrayIndex] = city.Value;
-
-          arrayIndex++;
+            array[arrayIndex] = city.Value - 1;
+            arrayIndex++;
         }
 
@@ -116,11 +119,39 @@
       }
 
-      AlbaEncoding solution = new AlbaEncoding(new Permutation(PermutationTypes.RelativeUndirected), cities);
+      for (int i = 0; i < emptyVehicles - 1; i++) {
+        array[arrayIndex] = delimiter;
+        delimiter++;
+        arrayIndex++;
+      }
+            
+      AlbaEncoding solution = new AlbaEncoding(new Permutation(PermutationTypes.RelativeUndirected, new IntArray(array)), cities);
 
       return solution;
     }
 
+    public static AlbaEncoding ConvertFrom(List<int> routeParam) {
+      List<int> route = new List<int>(routeParam);
+      
+      int cities = 0;
+      for (int i = 0; i < route.Count; i++) {
+        if (route[i] != 0) {
+          cities++;
+        }
+      }
 
+      int vehicle = cities;
+      for (int i = 0; i < route.Count; i++) {
+        if (route[i] == 0) {
+          route[i] = vehicle;
+          vehicle++;
+        } else {
+          route[i] = route[i] - 1;
+        }
+      }
 
+      return new AlbaEncoding(
+        new Permutation(PermutationTypes.RelativeUndirected, route.ToArray()),
+        cities);
+    }
   }
 }
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Creators/AlbaPushForwardInsertionCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Creators/AlbaPushForwardInsertionCreator.cs	(revision 4143)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Creators/AlbaPushForwardInsertionCreator.cs	(revision 4150)
@@ -32,260 +32,7 @@
   [Item("AlbaPushForwardCreator", "An operator which creates a new alba VRP representation using the push forward insertion heuristic.")]
   [StorableClass]
-  public sealed class AlbaPushForwardCreator : VRPCreator, IStochasticOperator {
-    #region IStochasticOperator Members
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    #endregion
-
-    public IValueParameter<DoubleValue> Alpha {
-      get { return (IValueParameter<DoubleValue>)Parameters["Alpha"]; }
-    }
-    public IValueParameter<DoubleValue> AlphaVariance {
-      get { return (IValueParameter<DoubleValue>)Parameters["AlphaVariance"]; }
-    }
-    public IValueParameter<DoubleValue> Beta {
-      get { return (IValueParameter<DoubleValue>)Parameters["Beta"]; }
-    }
-    public IValueParameter<DoubleValue> BetaVariance {
-      get { return (IValueParameter<DoubleValue>)Parameters["BetaVariance"]; }
-    }
-    public IValueParameter<DoubleValue> Gamma {
-      get { return (IValueParameter<DoubleValue>)Parameters["Gamma"]; }
-    }
-    public IValueParameter<DoubleValue> GammaVariance {
-      get { return (IValueParameter<DoubleValue>)Parameters["GammaVariance"]; }
-    }
-
-    public AlbaPushForwardCreator()
-      : base() {
-      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
-      Parameters.Add(new ValueParameter<DoubleValue>("Alpha", "The alpha value.", new DoubleValue(0.7)));
-      Parameters.Add(new ValueParameter<DoubleValue>("AlphaVariance", "The alpha variance.", new DoubleValue(0.5)));
-      Parameters.Add(new ValueParameter<DoubleValue>("Beta", "The beta value.", new DoubleValue(0.1)));
-      Parameters.Add(new ValueParameter<DoubleValue>("BetaVariance", "The beta variance.", new DoubleValue(0.07)));
-      Parameters.Add(new ValueParameter<DoubleValue>("Gamma", "The gamma value.", new DoubleValue(0.2)));
-      Parameters.Add(new ValueParameter<DoubleValue>("GammaVariance", "The gamma variance.", new DoubleValue(0.14)));
-    }
-
-    public override IOperation Apply() {
-      VRPSolutionParameter.ActualValue = new AlbaEncoding(CreateSolution(), CitiesParameter.ActualValue.Value);
-
-      return base.Apply();
-    }
-
-    // use the Box-Mueller transform in the polar form to generate a N(0,1) random variable out of two uniformly distributed random variables
-    private double Gauss(IRandom random) {
-      double u = 0.0, v = 0.0, s = 0.0;
-      do {
-        u = (random.NextDouble() * 2) - 1;
-        v = (random.NextDouble() * 2) - 1;
-        s = Math.Sqrt(u * u + v * v);
-      } while (s < Double.Epsilon || s > 1);
-      return u * Math.Sqrt((-2.0 * Math.Log(s)) / s);
-    }
-
-    private double N(double mu, double sigma, IRandom random) {
-      return mu + (sigma * Gauss(random)); // transform the random variable sampled from N(0,1) to N(mu,sigma)
-    }
-
-    private double CalculateDistance(int start, int end) {
-      double distance = 0.0;
-      DoubleMatrix coordinates = CoordinatesParameter.ActualValue;
-
-      distance =
-          Math.Sqrt(
-            Math.Pow(coordinates[start, 0] - coordinates[end, 0], 2) +
-            Math.Pow(coordinates[start, 1] - coordinates[end, 1], 2));
-
-      return distance;
-    }
-
-    private DoubleMatrix CreateDistanceMatrix() {
-      DoubleMatrix coordinates = CoordinatesParameter.ActualValue;
-      DoubleMatrix distanceMatrix = new DoubleMatrix(coordinates.Rows, coordinates.Rows);
-
-      for (int i = 0; i < distanceMatrix.Rows; i++) {
-        for (int j = i; j < distanceMatrix.Columns; j++) {
-          double distance = CalculateDistance(i, j);
-
-          distanceMatrix[i, j] = distance;
-          distanceMatrix[j, i] = distance;
-        }
-      }
-
-      return distanceMatrix;
-    }
-
-    private double Distance(int start, int end) {
-      double distance = 0.0;
-
-      if (UseDistanceMatrixParameter.ActualValue.Value) {
-        if (DistanceMatrixParameter.ActualValue == null) {
-          DistanceMatrixParameter.ActualValue = CreateDistanceMatrix();
-        }
-
-        distance = DistanceMatrixParameter.ActualValue[start, end];
-      } else {
-        distance = CalculateDistance(start, end);
-      }
-
-      return distance;
-    }
-
-    private double TravelDistance(List<int> route, int begin) {
-      double distance = 0;
-      for (int i = begin; i < route.Count - 1 && (i == begin || route[i] != 0); i++) {
-        distance += Distance(route[i], route[i + 1]);
-      }
-      return distance;
-    }
-
-    private bool SubrouteConstraintsOK(List<int> route, int begin) {
-      double t = 0.0, o = 0.0;
-      for (int i = begin + 1; i < route.Count; i++) {
-        t += Distance(route[i - 1], route[i]);
-        if (route[i] == 0) return (t < DueTimeParameter.ActualValue[0]); // violation on capacity constraint is handled below
-        else {
-          if (t > DueTimeParameter.ActualValue[route[i]]) return false;
-          t = Math.Max(ReadyTimeParameter.ActualValue[route[i]], t);
-          t += ServiceTimeParameter.ActualValue[route[i]];
-          o += DemandParameter.ActualValue[route[i]];
-          if (o > CapacityParameter.ActualValue.Value) return false; // premature exit on capacity constraint violation
-        }
-      }
-      return true;
-    }
-
-    private bool SubrouteTardinessOK(List<int> route, int begin) {
-      double t = 0.0;
-      for (int i = begin + 1; i < route.Count; i++) {
-        t += Distance(route[i - 1], route[i]);
-        if (route[i] == 0) {
-          if (t < DueTimeParameter.ActualValue[0]) return true;
-          else return false;
-        } else {
-          if (t > DueTimeParameter.ActualValue[route[i]]) return false;
-          t = Math.Max(ReadyTimeParameter.ActualValue[route[i]], t);
-          t += ServiceTimeParameter.ActualValue[route[i]];
-        }
-      }
-      return true;
-    }
-
-    private bool SubrouteLoadOK(List<int> route, int begin) {
-      double o = 0.0;
-      for (int i = begin + 1; i < route.Count; i++) {
-        if (route[i] == 0) return (o < CapacityParameter.ActualValue.Value);
-        else {
-          o += DemandParameter.ActualValue[route[i]];
-        }
-      }
-      return (o < CapacityParameter.ActualValue.Value);
-    }
-
-    private Permutation CreateSolution() {
-      double alpha, beta, gamma;
-      alpha = N(Alpha.Value.Value, Math.Sqrt(AlphaVariance.Value.Value), RandomParameter.ActualValue);
-      beta = N(Beta.Value.Value, Math.Sqrt(BetaVariance.Value.Value), RandomParameter.ActualValue);
-      gamma = N(Gamma.Value.Value, Math.Sqrt(GammaVariance.Value.Value), RandomParameter.ActualValue);
-
-      double x0 = CoordinatesParameter.ActualValue[0, 0];
-      double y0 = CoordinatesParameter.ActualValue[0, 1];
-      double distance = 0;
-      double cost = 0;
-      double minimumCost = double.MaxValue;
-      List<int> unroutedList = new List<int>();
-      List<double> costList = new List<double>();
-      int index;
-      int indexOfMinimumCost = -1;
-      int indexOfCustomer = -1;
-
-      /*-----------------------------------------------------------------------------
-       * generate cost list
-       *-----------------------------------------------------------------------------
-       */
-      for (int i = 1; i <= CitiesParameter.ActualValue.Value; i++) {
-        distance = Distance(i, 0);
-        if (CoordinatesParameter.ActualValue[i, 0] < x0) distance = -distance;
-        cost = -alpha * distance + // distance 0 <-> City[i]
-                 beta * (DueTimeParameter.ActualValue[i]) + // latest arrival time
-                 gamma * (Math.Asin((CoordinatesParameter.ActualValue[i, 1] - y0) / distance) / 360 * distance); // polar angle
-
-        index = 0;
-        while (index < costList.Count && costList[index] < cost) index++;
-        costList.Insert(index, cost);
-        unroutedList.Insert(index, i);
-      }
-
-      /*------------------------------------------------------------------------------
-       * route customers according to cost list
-       *------------------------------------------------------------------------------
-       */
-      int routeIndex = 0;
-      int currentRoute = 0;
-      int c;
-      int customer = -1;
-      int subTourCount = 1;
-      List<int> route = new List<int>(CitiesParameter.ActualValue.Value + VehiclesParameter.ActualValue.Value - 1);
-      minimumCost = double.MaxValue;
-      indexOfMinimumCost = -1;
-      route.Add(0);
-      route.Add(0);
-      route.Insert(1, unroutedList[0]);
-      unroutedList.RemoveAt(0);
-      currentRoute = routeIndex;
-      routeIndex++;
-
-      do {
-        for (c = 0; c < unroutedList.Count; c++) {
-          for (int i = currentRoute + 1; i < route.Count; i++) {
-            route.Insert(i, (int)unroutedList[c]);
-            if (route[currentRoute] != 0) { throw new Exception("currentRoute not depot"); }
-            cost = TravelDistance(route, currentRoute);
-            if (cost < minimumCost && SubrouteConstraintsOK(route, currentRoute)) {
-              minimumCost = cost;
-              indexOfMinimumCost = i;
-              customer = (int)unroutedList[c];
-              indexOfCustomer = c;
-            }
-            route.RemoveAt(i);
-          }
-        }
-        // insert customer if found
-        if (indexOfMinimumCost != -1) {
-          route.Insert(indexOfMinimumCost, customer);
-          routeIndex++;
-          unroutedList.RemoveAt(indexOfCustomer);
-          costList.RemoveAt(indexOfCustomer);
-        } else { // no feasible customer found
-          routeIndex++;
-          route.Insert(routeIndex, 0);
-          currentRoute = routeIndex;
-          route.Insert(route.Count - 1, (int)unroutedList[0]);
-          unroutedList.RemoveAt(0);
-          routeIndex++;
-          subTourCount++;
-        }
-        // reset minimum		
-        minimumCost = double.MaxValue;
-        indexOfMinimumCost = -1;
-        indexOfCustomer = -1;
-        customer = -1;
-      } while (unroutedList.Count > 0);
-      while (route.Count < CitiesParameter.ActualValue.Value + VehiclesParameter.ActualValue.Value - 1)
-        route.Add(0);
-
-      int vehicle = CitiesParameter.ActualValue.Value;
-      for (int i = 0; i < route.Count; i++) {
-        if (route[i] == 0) {
-          route[i] = vehicle;
-          vehicle++;
-        } else {
-          route[i] = route[i] - 1;
-        }
-      }
-
-      return new Permutation(PermutationTypes.RelativeDirected, route.ToArray());
+  public sealed class AlbaPushForwardCreator : PushForwardCreator {
+    protected override IVRPEncoding CreateEncoding(List<int> route) {
+      return AlbaEncoding.ConvertFrom(route);
     }
   }
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaCrossover.cs	(revision 4150)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaCrossover.cs	(revision 4150)
@@ -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.Alba {
+  [StorableClass]
+  public abstract class AlbaCrossover : VRPCrossover {
+    public ILookupParameter<IntValue> VehiclesParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["Vehicles"]; }
+    }
+
+    public AlbaCrossover()
+      : base() {
+        Parameters.Add(new LookupParameter<IntValue>("Vehicles", "The vehicles count."));
+    }
+    
+    protected virtual void Crossover() {
+    }
+
+    public override IOperation Apply() {
+      int cities = 0;
+
+      ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
+      for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
+        IVRPEncoding solution = ParentsParameter.ActualValue[i];
+        cities = solution.Cities;
+        if (!(solution is AlbaEncoding)) {
+          parents[i] = AlbaEncoding.ConvertFrom(solution, VehiclesParameter.ActualValue.Value);
+        } else {
+          parents[i] = solution;
+        }
+      }
+      ParentsParameter.ActualValue = parents;
+
+      Crossover();
+
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaPermutationCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaPermutationCrossover.cs	(revision 4143)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaPermutationCrossover.cs	(revision 4150)
@@ -28,5 +28,5 @@
   [Item("AlbaPermutationCrossover", "An operator which crosses two alba VRP representations.")]
   [StorableClass]
-  public sealed class AlbaPermutationCrossover : VRPCrossover {
+  public sealed class AlbaPermutationCrossover : AlbaCrossover {
     public IValueLookupParameter<IPermutationCrossover> PermutationCrossoverParameter {
       get { return (IValueLookupParameter<IPermutationCrossover>)Parameters["PermutationCrossover"]; }
@@ -38,28 +38,20 @@
     }
 
-    public override IOperation Apply() {
-      int cities = 0;
-
-      for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
-        IVRPEncoding solution = ParentsParameter.ActualValue[i];
-        cities = solution.Cities;
-        if (!(solution is AlbaEncoding)) {
-          ParentsParameter.ActualValue[i] = AlbaEncoding.ConvertFrom(solution);
-        }
-      }
+    protected override void Crossover() {
+      int cities = ParentsParameter.ActualValue[0].Cities;
 
       PermutationCrossoverParameter.ActualValue.ParentsParameter.ActualName = ParentsParameter.ActualName;
-      IAtomicOperation op = this.ExecutionContext.CreateOperation(PermutationCrossoverParameter.ActualValue);
+      IAtomicOperation op = this.ExecutionContext.CreateOperation(
+        PermutationCrossoverParameter.ActualValue, this.ExecutionContext.Scope);
       op.Operator.Execute((IExecutionContext)op);
 
-      if (ExecutionContext.Scope.Variables.ContainsKey("Permutation")) {
-        Permutation permutation = ExecutionContext.Scope.Variables["Permutation"].Value as Permutation;
-        ExecutionContext.Scope.Variables.Remove("Permutation");
+      string childName = PermutationCrossoverParameter.ActualValue.ChildParameter.ActualName;
+      if (ExecutionContext.Scope.Variables.ContainsKey(childName)) {
+        Permutation permutation = ExecutionContext.Scope.Variables[childName].Value as Permutation;
+        ExecutionContext.Scope.Variables.Remove(childName);
 
         ChildParameter.ActualValue = new AlbaEncoding(permutation, cities);
       } else
         ChildParameter.ActualValue = null;
-
-      return base.Apply();
     }
   }
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaManipulator.cs	(revision 4150)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaManipulator.cs	(revision 4150)
@@ -0,0 +1,54 @@
+﻿#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.Alba {
+  [StorableClass]
+  public abstract class AlbaManipulator : VRPManipulator {
+    public ILookupParameter<IntValue> VehiclesParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["Vehicles"]; }
+    }
+
+    public AlbaManipulator()
+      : base() {
+        Parameters.Add(new LookupParameter<IntValue>("Vehicles", "The vehicles count."));
+    }
+    
+    protected virtual void Manipulate() {
+    }
+    
+    public override IOperation Apply() {
+      IVRPEncoding solution = VRPSolutionParameter.ActualValue;
+      if (!(solution is AlbaEncoding)) {
+        VRPSolutionParameter.ActualValue = AlbaEncoding.ConvertFrom(solution, VehiclesParameter.ActualValue.Value);
+      }
+      
+      Manipulate();
+
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaPermutationManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaPermutationManipulator.cs	(revision 4143)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaPermutationManipulator.cs	(revision 4150)
@@ -28,5 +28,5 @@
   [Item("AlbaPermutationManipulator", "An operator which manipulates an alba VRP representation.")]
   [StorableClass]
-  public sealed class AlbaPermutationManipulator : VRPManipulator {
+  public sealed class AlbaPermutationManipulator : AlbaManipulator {
     public IValueLookupParameter<IPermutationManipulator> PermutationManipulatorParameter {
       get { return (IValueLookupParameter<IPermutationManipulator>)Parameters["PermutationManipulator"]; }
@@ -39,9 +39,4 @@
 
     public override IOperation Apply() {
-      IVRPEncoding solution = VRPSolutionParameter.ActualValue;
-      if (!(solution is AlbaEncoding)) {
-        VRPSolutionParameter.ActualValue = AlbaEncoding.ConvertFrom(solution);
-      }
-
       OperationCollection next = new OperationCollection(base.Apply());
       IPermutationManipulator op = PermutationManipulatorParameter.ActualValue;
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/AlbaMoveOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/AlbaMoveOperator.cs	(revision 4143)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/AlbaMoveOperator.cs	(revision 4150)
@@ -23,4 +23,6 @@
 using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
@@ -28,4 +30,13 @@
   [StorableClass]
   public abstract class AlbaMoveOperator : VRPMoveOperator {
+    public ILookupParameter<IntValue> VehiclesParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["Vehicles"]; }
+    }
+
+    public AlbaMoveOperator()
+      : base() {
+      Parameters.Add(new LookupParameter<IntValue>("Vehicles", "The vehicles count."));
+    }
+    
     [Storable]
     protected abstract IPermutationMoveOperator PermutationMoveOperatorParameter { get; set; }
@@ -34,5 +45,5 @@
       IVRPEncoding solution = VRPSolutionParameter.ActualValue;
       if (!(solution is AlbaEncoding)) {
-        VRPSolutionParameter.ActualValue = AlbaEncoding.ConvertFrom(solution);
+        VRPSolutionParameter.ActualValue = AlbaEncoding.ConvertFrom(solution, VehiclesParameter.ActualValue.Value);
       }
 
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/IntListRepresentationCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/IntListRepresentationCreator.cs	(revision 4150)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/IntListRepresentationCreator.cs	(revision 4150)
@@ -0,0 +1,42 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  [StorableClass]
+  public abstract class IntListRepresentationCreator : VRPCreator {
+    protected abstract IVRPEncoding CreateEncoding(List<int> route);
+
+    protected abstract List<int> CreateSolution();
+
+    public override IOperation Apply() {
+      VRPSolutionParameter.ActualValue = CreateEncoding(CreateSolution());
+
+      return base.Apply();
+    }    
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/PushForwardInsertionCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/PushForwardInsertionCreator.cs	(revision 4150)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/PushForwardInsertionCreator.cs	(revision 4150)
@@ -0,0 +1,275 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  [StorableClass]
+  public abstract class PushForwardCreator : IntListRepresentationCreator, IStochasticOperator {
+    #region IStochasticOperator Members
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    #endregion
+
+    public IValueParameter<DoubleValue> Alpha {
+      get { return (IValueParameter<DoubleValue>)Parameters["Alpha"]; }
+    }
+    public IValueParameter<DoubleValue> AlphaVariance {
+      get { return (IValueParameter<DoubleValue>)Parameters["AlphaVariance"]; }
+    }
+    public IValueParameter<DoubleValue> Beta {
+      get { return (IValueParameter<DoubleValue>)Parameters["Beta"]; }
+    }
+    public IValueParameter<DoubleValue> BetaVariance {
+      get { return (IValueParameter<DoubleValue>)Parameters["BetaVariance"]; }
+    }
+    public IValueParameter<DoubleValue> Gamma {
+      get { return (IValueParameter<DoubleValue>)Parameters["Gamma"]; }
+    }
+    public IValueParameter<DoubleValue> GammaVariance {
+      get { return (IValueParameter<DoubleValue>)Parameters["GammaVariance"]; }
+    }
+
+    public PushForwardCreator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
+      Parameters.Add(new ValueParameter<DoubleValue>("Alpha", "The alpha value.", new DoubleValue(0.7)));
+      Parameters.Add(new ValueParameter<DoubleValue>("AlphaVariance", "The alpha variance.", new DoubleValue(0.5)));
+      Parameters.Add(new ValueParameter<DoubleValue>("Beta", "The beta value.", new DoubleValue(0.1)));
+      Parameters.Add(new ValueParameter<DoubleValue>("BetaVariance", "The beta variance.", new DoubleValue(0.07)));
+      Parameters.Add(new ValueParameter<DoubleValue>("Gamma", "The gamma value.", new DoubleValue(0.2)));
+      Parameters.Add(new ValueParameter<DoubleValue>("GammaVariance", "The gamma variance.", new DoubleValue(0.14)));
+    }
+
+    // use the Box-Mueller transform in the polar form to generate a N(0,1) random variable out of two uniformly distributed random variables
+    private double Gauss(IRandom random) {
+      double u = 0.0, v = 0.0, s = 0.0;
+      do {
+        u = (random.NextDouble() * 2) - 1;
+        v = (random.NextDouble() * 2) - 1;
+        s = Math.Sqrt(u * u + v * v);
+      } while (s < Double.Epsilon || s > 1);
+      return u * Math.Sqrt((-2.0 * Math.Log(s)) / s);
+    }
+
+    private double N(double mu, double sigma, IRandom random) {
+      return mu + (sigma * Gauss(random)); // transform the random variable sampled from N(0,1) to N(mu,sigma)
+    }
+
+    private double CalculateDistance(int start, int end) {
+      double distance = 0.0;
+      DoubleMatrix coordinates = CoordinatesParameter.ActualValue;
+
+      distance =
+          Math.Sqrt(
+            Math.Pow(coordinates[start, 0] - coordinates[end, 0], 2) +
+            Math.Pow(coordinates[start, 1] - coordinates[end, 1], 2));
+
+      return distance;
+    }
+
+    private DoubleMatrix CreateDistanceMatrix() {
+      DoubleMatrix coordinates = CoordinatesParameter.ActualValue;
+      DoubleMatrix distanceMatrix = new DoubleMatrix(coordinates.Rows, coordinates.Rows);
+
+      for (int i = 0; i < distanceMatrix.Rows; i++) {
+        for (int j = i; j < distanceMatrix.Columns; j++) {
+          double distance = CalculateDistance(i, j);
+
+          distanceMatrix[i, j] = distance;
+          distanceMatrix[j, i] = distance;
+        }
+      }
+
+      return distanceMatrix;
+    }
+
+    private double Distance(int start, int end) {
+      double distance = 0.0;
+
+      if (UseDistanceMatrixParameter.ActualValue.Value) {
+        if (DistanceMatrixParameter.ActualValue == null) {
+          DistanceMatrixParameter.ActualValue = CreateDistanceMatrix();
+        }
+
+        distance = DistanceMatrixParameter.ActualValue[start, end];
+      } else {
+        distance = CalculateDistance(start, end);
+      }
+
+      return distance;
+    }
+
+    private double TravelDistance(List<int> route, int begin) {
+      double distance = 0;
+      for (int i = begin; i < route.Count - 1 && (i == begin || route[i] != 0); i++) {
+        distance += Distance(route[i], route[i + 1]);
+      }
+      return distance;
+    }
+
+    private bool SubrouteConstraintsOK(List<int> route, int begin) {
+      double t = 0.0, o = 0.0;
+      for (int i = begin + 1; i < route.Count; i++) {
+        t += Distance(route[i - 1], route[i]);
+        if (route[i] == 0) return (t < DueTimeParameter.ActualValue[0]); // violation on capacity constraint is handled below
+        else {
+          if (t > DueTimeParameter.ActualValue[route[i]]) return false;
+          t = Math.Max(ReadyTimeParameter.ActualValue[route[i]], t);
+          t += ServiceTimeParameter.ActualValue[route[i]];
+          o += DemandParameter.ActualValue[route[i]];
+          if (o > CapacityParameter.ActualValue.Value) return false; // premature exit on capacity constraint violation
+        }
+      }
+      return true;
+    }
+
+    private bool SubrouteTardinessOK(List<int> route, int begin) {
+      double t = 0.0;
+      for (int i = begin + 1; i < route.Count; i++) {
+        t += Distance(route[i - 1], route[i]);
+        if (route[i] == 0) {
+          if (t < DueTimeParameter.ActualValue[0]) return true;
+          else return false;
+        } else {
+          if (t > DueTimeParameter.ActualValue[route[i]]) return false;
+          t = Math.Max(ReadyTimeParameter.ActualValue[route[i]], t);
+          t += ServiceTimeParameter.ActualValue[route[i]];
+        }
+      }
+      return true;
+    }
+
+    private bool SubrouteLoadOK(List<int> route, int begin) {
+      double o = 0.0;
+      for (int i = begin + 1; i < route.Count; i++) {
+        if (route[i] == 0) return (o < CapacityParameter.ActualValue.Value);
+        else {
+          o += DemandParameter.ActualValue[route[i]];
+        }
+      }
+      return (o < CapacityParameter.ActualValue.Value);
+    }
+
+    protected override List<int> CreateSolution() {
+      double alpha, beta, gamma;
+      alpha = N(Alpha.Value.Value, Math.Sqrt(AlphaVariance.Value.Value), RandomParameter.ActualValue);
+      beta = N(Beta.Value.Value, Math.Sqrt(BetaVariance.Value.Value), RandomParameter.ActualValue);
+      gamma = N(Gamma.Value.Value, Math.Sqrt(GammaVariance.Value.Value), RandomParameter.ActualValue);
+
+      double x0 = CoordinatesParameter.ActualValue[0, 0];
+      double y0 = CoordinatesParameter.ActualValue[0, 1];
+      double distance = 0;
+      double cost = 0;
+      double minimumCost = double.MaxValue;
+      List<int> unroutedList = new List<int>();
+      List<double> costList = new List<double>();
+      int index;
+      int indexOfMinimumCost = -1;
+      int indexOfCustomer = -1;
+
+      /*-----------------------------------------------------------------------------
+       * generate cost list
+       *-----------------------------------------------------------------------------
+       */
+      for (int i = 1; i <= CitiesParameter.ActualValue.Value; i++) {
+        distance = Distance(i, 0);
+        if (CoordinatesParameter.ActualValue[i, 0] < x0) distance = -distance;
+        cost = -alpha * distance + // distance 0 <-> City[i]
+                 beta * (DueTimeParameter.ActualValue[i]) + // latest arrival time
+                 gamma * (Math.Asin((CoordinatesParameter.ActualValue[i, 1] - y0) / distance) / 360 * distance); // polar angle
+
+        index = 0;
+        while (index < costList.Count && costList[index] < cost) index++;
+        costList.Insert(index, cost);
+        unroutedList.Insert(index, i);
+      }
+
+      /*------------------------------------------------------------------------------
+       * route customers according to cost list
+       *------------------------------------------------------------------------------
+       */
+      int routeIndex = 0;
+      int currentRoute = 0;
+      int c;
+      int customer = -1;
+      int subTourCount = 1;
+      List<int> route = new List<int>(CitiesParameter.ActualValue.Value + VehiclesParameter.ActualValue.Value - 1);
+      minimumCost = double.MaxValue;
+      indexOfMinimumCost = -1;
+      route.Add(0);
+      route.Add(0);
+      route.Insert(1, unroutedList[0]);
+      unroutedList.RemoveAt(0);
+      currentRoute = routeIndex;
+      routeIndex++;
+
+      do {
+        for (c = 0; c < unroutedList.Count; c++) {
+          for (int i = currentRoute + 1; i < route.Count; i++) {
+            route.Insert(i, (int)unroutedList[c]);
+            if (route[currentRoute] != 0) { throw new Exception("currentRoute not depot"); }
+            cost = TravelDistance(route, currentRoute);
+            if (cost < minimumCost && SubrouteConstraintsOK(route, currentRoute)) {
+              minimumCost = cost;
+              indexOfMinimumCost = i;
+              customer = (int)unroutedList[c];
+              indexOfCustomer = c;
+            }
+            route.RemoveAt(i);
+          }
+        }
+        // insert customer if found
+        if (indexOfMinimumCost != -1) {
+          route.Insert(indexOfMinimumCost, customer);
+          routeIndex++;
+          unroutedList.RemoveAt(indexOfCustomer);
+          costList.RemoveAt(indexOfCustomer);
+        } else { // no feasible customer found
+          routeIndex++;
+          route.Insert(routeIndex, 0);
+          currentRoute = routeIndex;
+          route.Insert(route.Count - 1, (int)unroutedList[0]);
+          unroutedList.RemoveAt(0);
+          routeIndex++;
+          subTourCount++;
+        }
+        // reset minimum		
+        minimumCost = double.MaxValue;
+        indexOfMinimumCost = -1;
+        indexOfCustomer = -1;
+        customer = -1;
+      } while (unroutedList.Count > 0);
+      while (route.Count < CitiesParameter.ActualValue.Value + VehiclesParameter.ActualValue.Value - 1)
+        route.Add(0);
+
+      return route;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/Creators/PotvinPushForwardInsertionCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/Creators/PotvinPushForwardInsertionCreator.cs	(revision 4150)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/Creators/PotvinPushForwardInsertionCreator.cs	(revision 4150)
@@ -0,0 +1,39 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Potvin {
+  [Item("PotvinPushForwardCreator", "An operator which creates a new Potvin VRP representation using the push forward insertion heuristic.")]
+  [StorableClass]
+  public sealed class PotvinPushForwardCreator : PushForwardCreator {
+    protected override IVRPEncoding CreateEncoding(List<int> route) {
+      return PotvinEncoding.ConvertFrom(route);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/PotvinEncoding.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/PotvinEncoding.cs	(revision 4150)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/PotvinEncoding.cs	(revision 4150)
@@ -0,0 +1,99 @@
+﻿#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.Potvin {
+  [Item("PotvinEncoding", "Represents a potvin encoding of VRP solutions.")]
+  [StorableClass]
+  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.Count;
+        }
+
+        return cities;
+      }
+    }
+    #endregion
+
+    [Storable]
+    public ItemList<IntValue> Unrouted { get; set; }
+
+    public override IDeepCloneable Clone(HeuristicLab.Common.Cloner cloner) {
+      PotvinEncoding clone = new PotvinEncoding();
+      cloner.RegisterClonedObject(this, clone);
+      clone.Tours = (ItemList<Tour>)cloner.Clone(this.Tours);
+      clone.Unrouted = (ItemList<IntValue>)cloner.Clone(this.Unrouted);
+      return clone;
+    }
+
+    public PotvinEncoding() {
+      Tours = new ItemList<Tour>();
+      Unrouted = new ItemList<IntValue>();
+    }
+    
+    public static PotvinEncoding ConvertFrom(IVRPEncoding encoding) {
+      PotvinEncoding solution = new PotvinEncoding();
+
+      solution.Tours.AddRange(
+        encoding.Tours);
+
+      return solution;
+    }
+
+    public static PotvinEncoding ConvertFrom(List<int> route) {
+      PotvinEncoding solution = new PotvinEncoding();
+
+      Tour tour = new Tour();
+      for (int i = 0; i < route.Count; i++) {
+        if (route[i] == 0) {
+          if (tour.Count > 0) {
+            solution.Tours.Add(tour);
+            tour = new Tour();
+          }
+        } else {
+          tour.Add(new IntValue(route[i]));
+        }
+      }
+
+      return solution;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPCrossover.cs	(revision 4143)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPCrossover.cs	(revision 4150)
@@ -45,5 +45,4 @@
       Parameters.Add(new LookupParameter<IVRPEncoding>("Child", "The child permutation resulting from the crossover."));
       ChildParameter.ActualName = "VRPSolution";
-      Parameters.Add(new ValueLookupParameter<IntValue>("Cities", "The city count."));
     }
   }
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPManipulator.cs	(revision 4143)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPManipulator.cs	(revision 4150)
@@ -23,4 +23,5 @@
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
+using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings {
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPMoveOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPMoveOperator.cs	(revision 4143)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPMoveOperator.cs	(revision 4150)
@@ -23,4 +23,5 @@
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
+using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings {
@@ -31,5 +32,5 @@
       get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPSolution"]; }
     }
-
+   
     #endregion
 
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Evaluators/VRPEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Evaluators/VRPEvaluator.cs	(revision 4143)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Evaluators/VRPEvaluator.cs	(revision 4150)
@@ -157,7 +157,11 @@
 
       //simulate a tour, start and end at depot
-      for (int i = 1; i < tour.Count; i++) {
-        int start = tour[i - 1].Value;
-        int end = tour[i].Value;
+      for (int i = 0; i <= tour.Count; i++) {
+        int start = 0;
+        if(i > 0)
+          start = tour[i - 1].Value;
+        int end = 0;
+        if(i < tour.Count)
+          end = tour[i].Value;
 
         //drive there
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLab.Problems.VehicleRouting-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLab.Problems.VehicleRouting-3.3.csproj	(revision 4143)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLab.Problems.VehicleRouting-3.3.csproj	(revision 4150)
@@ -107,8 +107,12 @@
   <ItemGroup>
     <Compile Include="Analyzers\BestVRPSolutionAnalyzer.cs" />
+    <Compile Include="Encodings\General\PushForwardInsertionCreator.cs" />
+    <Compile Include="Encodings\General\IntListRepresentationCreator.cs" />
     <Compile Include="Encodings\Alba\Crossovers\AlbaPermutationCrossover.cs" />
+    <Compile Include="Encodings\Alba\Crossovers\AlbaCrossover.cs" />
     <Compile Include="Encodings\Alba\Interfaces\IAlbaTranslocationMoveOperator.cs" />
     <Compile Include="Encodings\Alba\Manipulators\AlbaPermutationManipulator.cs" />
     <Compile Include="Encodings\Alba\Creators\AlbaPushForwardInsertionCreator.cs" />
+    <Compile Include="Encodings\Alba\Manipulators\AlbaManipulator.cs" />
     <Compile Include="Encodings\Alba\Moves\AlbaMoveOperator.cs" />
     <Compile Include="Encodings\Alba\Moves\AlbaMoveMaker.cs" />
@@ -118,4 +122,6 @@
     <Compile Include="Encodings\Alba\Moves\ThreeOpt\AlbaTranslocationMoveSoftTabuCriterion.cs" />
     <Compile Include="Encodings\Alba\Moves\ThreeOpt\AlbaTranslocationMoveHardTabuCriterion.cs" />
+    <Compile Include="Encodings\Potvin\Creators\PotvinPushForwardInsertionCreator.cs" />
+    <Compile Include="Encodings\Potvin\PotvinEncoding.cs" />
     <Compile Include="Encodings\VRPMoveOperator.cs" />
     <Compile Include="Encodings\VRPCrossover.cs" />
@@ -214,4 +220,8 @@
     </BootstrapperPackage>
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Encodings\Potvin\Crossovers\" />
+    <Folder Include="Encodings\Potvin\Manipulators\" />
+  </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPCrossover.cs	(revision 4143)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPCrossover.cs	(revision 4150)
@@ -22,4 +22,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Optimization;
+using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.VehicleRouting {
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPManipulator.cs	(revision 4143)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPManipulator.cs	(revision 4150)
@@ -22,4 +22,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Optimization;
+using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.VehicleRouting {
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPMoveOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPMoveOperator.cs	(revision 4143)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPMoveOperator.cs	(revision 4150)
@@ -22,4 +22,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Optimization;
+using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.VehicleRouting {
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs	(revision 4143)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs	(revision 4150)
@@ -378,4 +378,8 @@
         op.VRPSolutionParameter.ActualName = SolutionCreator.VRPSolutionParameter.ActualName;
       }
+      foreach (AlbaMoveOperator op in Operators.OfType<AlbaMoveOperator>()) {
+        op.VehiclesParameter.ActualName = VehiclesParameter.Name;
+      }
+
       foreach (IVRPMoveEvaluator op in Operators.OfType<IVRPMoveEvaluator>()) {
         op.CoordinatesParameter.ActualName = CoordinatesParameter.Name;
@@ -404,6 +408,13 @@
         op.ChildParameter.ActualName = SolutionCreator.VRPSolutionParameter.ActualName;
       }
+      foreach (AlbaCrossover op in Operators.OfType<AlbaCrossover>()) {
+        op.VehiclesParameter.ActualName = VehiclesParameter.Name;
+      }
+
       foreach (IVRPManipulator op in Operators.OfType<IVRPManipulator>()) {
         op.VRPSolutionParameter.ActualName = SolutionCreator.VRPSolutionParameter.ActualName;
+      }
+      foreach (AlbaManipulator op in Operators.OfType<AlbaManipulator>()) {
+        op.VehiclesParameter.ActualName = VehiclesParameter.Name;
       }
     }
