Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.3/VRPSolutionView.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.3/VRPSolutionView.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting.Views/3.3/VRPSolutionView.cs	(revision 4268)
@@ -27,4 +27,5 @@
 using HeuristicLab.MainForm;
 using HeuristicLab.Problems.VehicleRouting.Encodings;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Problems.VehicleRouting.Views {
@@ -119,5 +120,5 @@
               if (Content.Solution != null) {
                 int currentTour = 0;
-                foreach (Tour tour in Content.Solution.GetTours()) {
+                foreach (Tour tour in Content.Solution.GetTours(new ValueLookupParameter<DoubleMatrix>("DistanceMatrix", distanceMatrix))) {
                   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 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/AlbaEncoding.cs	(revision 4268)
@@ -31,10 +31,10 @@
   [Item("AlbaEncoding", "Represents an Alba encoding of VRP solutions. It is implemented as described in Alba, E. and Dorronsoro, B. (2004). Solving the Vehicle Routing Problem by Using Cellular Genetic Algorithms.")]
   [StorableClass]
-  public class AlbaEncoding : Permutation, IVRPEncoding {
+  public class AlbaEncoding : PermutationEncoding {
     [Storable]
     private int cities;
     
     #region IVRPEncoding Members
-    public List<Tour> GetTours() {
+    public override List<Tour> GetTours(ILookupParameter<DoubleMatrix> distanceMatrix = null, int maxVehicles = int.MaxValue) {
       List<Tour> result = new List<Tour>();
 
@@ -78,9 +78,5 @@
 
     public AlbaEncoding(Permutation permutation, int cities)
-      : base(PermutationTypes.RelativeUndirected) {
-      this.array = new int[permutation.Length];
-      for (int i = 0; i < array.Length; i++)
-        this.array[i] = permutation[i];
-
+      : base(permutation) {
       this.cities = cities;
     }
@@ -88,9 +84,9 @@
     [StorableConstructor]
     private AlbaEncoding(bool serializing)
-      : base() {
+      : base(serializing) {
     }
 
-    public static AlbaEncoding ConvertFrom(IVRPEncoding encoding, int vehicles) {
-      List<Tour> tours = encoding.GetTours();
+    public static AlbaEncoding ConvertFrom(IVRPEncoding encoding, int vehicles, ILookupParameter<DoubleMatrix> distanceMatrix) {
+      List<Tour> tours = encoding.GetTours(distanceMatrix, vehicles);
 
       int cities = 0;
@@ -155,5 +151,4 @@
 
     internal static void RemoveUnusedParameters(ParameterCollection parameters) {
-      parameters.Remove("DistanceMatrix");
       parameters.Remove("UseDistanceMatrix");
       parameters.Remove("Capacity");
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaCrossover.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaCrossover.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaCrossover.cs	(revision 4268)
@@ -53,5 +53,6 @@
 
         if (!(solution is AlbaEncoding)) {
-          parents[i] = AlbaEncoding.ConvertFrom(solution, VehiclesParameter.ActualValue.Value);
+          parents[i] = AlbaEncoding.ConvertFrom(solution, VehiclesParameter.ActualValue.Value,
+            DistanceMatrixParameter);
         } else {
           parents[i] = solution;
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaManipulator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaManipulator.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaManipulator.cs	(revision 4268)
@@ -62,5 +62,5 @@
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is AlbaEncoding)) {
-        VRPToursParameter.ActualValue = AlbaEncoding.ConvertFrom(solution, VehiclesParameter.ActualValue.Value);
+        VRPToursParameter.ActualValue = AlbaEncoding.ConvertFrom(solution, VehiclesParameter.ActualValue.Value, DistanceMatrixParameter);
       }
 
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/AlbaMoveOperator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/AlbaMoveOperator.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/AlbaMoveOperator.cs	(revision 4268)
@@ -41,5 +41,6 @@
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is AlbaEncoding)) {
-        VRPToursParameter.ActualValue = AlbaEncoding.ConvertFrom(solution, VehiclesParameter.ActualValue.Value);
+        VRPToursParameter.ActualValue = AlbaEncoding.ConvertFrom(solution, VehiclesParameter.ActualValue.Value, 
+          DistanceMatrixParameter);
       }
 
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/IntraRouteInversion/IntraRouteInversionEvaluator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/IntraRouteInversion/IntraRouteInversionEvaluator.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/IntraRouteInversion/IntraRouteInversionEvaluator.cs	(revision 4268)
@@ -44,4 +44,5 @@
 
     public static TourEvaluation GetMoveQuality(AlbaEncoding individual, IntraRouteInversionMove move,
+      IntValue vehicles,
       DoubleArray dueTimeArray, DoubleArray serviceTimeArray, DoubleArray readyTimeArray,
       DoubleArray demandArray, DoubleValue capacity, DoubleMatrix coordinates,
@@ -53,5 +54,5 @@
 
       return VRPEvaluator.Evaluate(
-        newSolution, dueTimeArray, serviceTimeArray, readyTimeArray,
+        newSolution, vehicles, dueTimeArray, serviceTimeArray, readyTimeArray,
         demandArray, capacity, fleetUsageFactor, timeFactor, distanceFactor,
         overloadPenalty, tardinessPenalty, coordinates, distanceMatrix, useDistanceMatrix);
@@ -61,4 +62,5 @@
       return GetMoveQuality(
         VRPToursParameter.ActualValue as AlbaEncoding, IntraRouteInversionMoveParameter.ActualValue,
+        VehiclesParameter.ActualValue,
         DueTimeParameter.ActualValue, ServiceTimeParameter.ActualValue, ReadyTimeParameter.ActualValue,
         DemandParameter.ActualValue, CapacityParameter.ActualValue, CoordinatesParameter.ActualValue,
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/IntraRouteInversion/IntraRouteInversionMove.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/IntraRouteInversion/IntraRouteInversionMove.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/IntraRouteInversion/IntraRouteInversionMove.cs	(revision 4268)
@@ -57,5 +57,5 @@
 
     public TourEvaluation GetMoveQuality(
-      IVRPEncoding individual, 
+      IVRPEncoding individual, IntValue vehicles,
       DoubleArray dueTimeArray, DoubleArray serviceTimeArray, DoubleArray readyTimeArray, 
       DoubleArray demandArray, DoubleValue capacity, DoubleMatrix coordinates,
@@ -63,5 +63,5 @@
       DoubleValue overloadPenalty, DoubleValue tardinessPenalty,
       ILookupParameter<DoubleMatrix> distanceMatrix, Data.BoolValue useDistanceMatrix) {
-        return IntraRouteInversionMoveEvaluator.GetMoveQuality(individual as AlbaEncoding, this,
+        return IntraRouteInversionMoveEvaluator.GetMoveQuality(individual as AlbaEncoding, this, vehicles,
           dueTimeArray, serviceTimeArray, readyTimeArray, demandArray, capacity,
           coordinates, fleetUsageFactor, timeFactor, distanceFactor,
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMove.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMove.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMove.cs	(revision 4268)
@@ -89,5 +89,5 @@
 
     public TourEvaluation GetMoveQuality(
-      IVRPEncoding individual, 
+      IVRPEncoding individual, IntValue vehicles,
       DoubleArray dueTimeArray, DoubleArray serviceTimeArray, DoubleArray readyTimeArray, 
       DoubleArray demandArray, DoubleValue capacity, DoubleMatrix coordinates,
@@ -95,5 +95,5 @@
       DoubleValue overloadPenalty, DoubleValue tardinessPenalty,
       ILookupParameter<DoubleMatrix> distanceMatrix, Data.BoolValue useDistanceMatrix) {
-        return LambdaInterchangeMoveEvaluator.GetMoveQuality(individual as AlbaEncoding, this,
+        return LambdaInterchangeMoveEvaluator.GetMoveQuality(individual as AlbaEncoding, this,  vehicles,
           dueTimeArray, serviceTimeArray, readyTimeArray, demandArray, capacity,
           coordinates, fleetUsageFactor, timeFactor, distanceFactor,
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMoveEvaluator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMoveEvaluator.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMoveEvaluator.cs	(revision 4268)
@@ -44,4 +44,5 @@
 
     public static TourEvaluation GetMoveQuality(AlbaEncoding individual, LambdaInterchangeMove move, 
+      IntValue vehicles, 
       DoubleArray dueTimeArray, DoubleArray serviceTimeArray, DoubleArray readyTimeArray, 
       DoubleArray demandArray, DoubleValue capacity, DoubleMatrix coordinates, 
@@ -53,5 +54,5 @@
 
       return VRPEvaluator.Evaluate(
-        newSolution, dueTimeArray, serviceTimeArray, readyTimeArray, 
+        newSolution, vehicles, dueTimeArray, serviceTimeArray, readyTimeArray, 
         demandArray, capacity, fleetUsageFactor, timeFactor, distanceFactor, 
         overloadPenalty, tardinessPenalty, coordinates, distanceMatrix, useDistanceMatrix);
@@ -61,4 +62,5 @@
       return GetMoveQuality(
         VRPToursParameter.ActualValue as AlbaEncoding, LambdaInterchangeMoveParameter.ActualValue, 
+        VehiclesParameter.ActualValue,
         DueTimeParameter.ActualValue, ServiceTimeParameter.ActualValue, ReadyTimeParameter.ActualValue,
         DemandParameter.ActualValue, CapacityParameter.ActualValue, CoordinatesParameter.ActualValue, 
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/PermutationTranslocationMoveEvaluator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/PermutationTranslocationMoveEvaluator.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/PermutationTranslocationMoveEvaluator.cs	(revision 4268)
@@ -51,4 +51,5 @@
       return VRPEvaluator.Evaluate(
         newSolution,
+        VehiclesParameter.ActualValue,
         DueTimeParameter.ActualValue, ServiceTimeParameter.ActualValue, ReadyTimeParameter.ActualValue,
         DemandParameter.ActualValue, CapacityParameter.ActualValue,
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 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Crossovers/GVRCrossover.cs	(revision 4268)
@@ -104,8 +104,7 @@
       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);
+          parents[i] = GVREncoding.ConvertFrom(solution, CapacityParameter.ActualValue, DemandParameter.ActualValue,
+            DistanceMatrixParameter);
         } else {
           parents[i] = solution;
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/GVREncoding.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/GVREncoding.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/GVREncoding.cs	(revision 4268)
@@ -37,21 +37,22 @@
 
     [Storable]
-    private IntValue vehicles { get; set; }
-
-    [Storable]
     private DoubleArray demand { get; set; }
 
-    public override List<Tour> GetTours() {
+    public override List<Tour> GetTours(ILookupParameter<DoubleMatrix> distanceMatrix = null, int maxVehicles = int.MaxValue) {
       List<Tour> tours = new List<Tour>();
+      Tour newTour = new Tour();
+      double currentDemand = 0;
 
       int toursProcessed = 0;
       foreach (Tour tour in base.Tours) {
-        Tour newTour = new Tour();
-        double currentDemand = 0;
+        if (maxVehicles > tours.Count) {
+          newTour = new Tour();
+          currentDemand = 0;
+        }
 
         foreach (int city in tour.Cities) {
           currentDemand += demand[city];
 
-          if (vehicles.Value > tours.Count + base.Tours.Count - toursProcessed && 
+          if (maxVehicles > tours.Count && 
             currentDemand > capacity.Value) {
             if(newTour.Cities.Count > 0)
@@ -66,6 +67,8 @@
         }
 
-        if (newTour.Cities.Count > 0)
+        if (newTour.Cities.Count > 0 &&
+          maxVehicles > tours.Count)
           tours.Add(newTour);
+
         toursProcessed++;
       }
@@ -75,5 +78,5 @@
     
     public override IDeepCloneable Clone(HeuristicLab.Common.Cloner cloner) {
-      GVREncoding clone = new GVREncoding(capacity, demand, vehicles);
+      GVREncoding clone = new GVREncoding(capacity, demand);
       cloner.RegisterClonedObject(this, clone);
       clone.Tours = (ItemList<Tour>)cloner.Clone(this.Tours);
@@ -82,9 +85,8 @@
     }
 
-    public GVREncoding(DoubleValue capacity, DoubleArray demand, IntValue vehicles)
+    public GVREncoding(DoubleValue capacity, DoubleArray demand)
       : base() {
         this.capacity = capacity;
         this.demand = demand;
-        this.vehicles = vehicles;
     }
 
@@ -94,14 +96,15 @@
     }
 
-    public static GVREncoding ConvertFrom(IVRPEncoding encoding, DoubleValue capacity, DoubleArray demand, IntValue vehicles) {
-      GVREncoding solution = new GVREncoding(capacity, demand, vehicles);
+    public static GVREncoding ConvertFrom(IVRPEncoding encoding, DoubleValue capacity, DoubleArray demand, 
+      ILookupParameter<DoubleMatrix> distanceMatrix) {
+      GVREncoding solution = new GVREncoding(capacity, demand);
 
-      TourEncoding.ConvertFrom(encoding, solution);
+      TourEncoding.ConvertFrom(encoding, solution, distanceMatrix);
 
       return solution;
     }
 
-    public static GVREncoding ConvertFrom(List<int> route, DoubleValue capacity, DoubleArray demand, IntValue vehicles) {
-      GVREncoding solution = new GVREncoding(capacity, demand, vehicles);
+    public static GVREncoding ConvertFrom(List<int> route, DoubleValue capacity, DoubleArray demand) {
+      GVREncoding solution = new GVREncoding(capacity, demand);
 
       TourEncoding.ConvertFrom(route, solution);
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 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/GVR/Manipulators/GVRManipulator.cs	(revision 4268)
@@ -43,5 +43,4 @@
       //remove unused parameters
       Parameters.Remove("Coordinates");
-      Parameters.Remove("DistanceMatrix");
       Parameters.Remove("UseDistanceMatrix");
       Parameters.Remove("ReadyTime");
@@ -56,5 +55,5 @@
       if (!(solution is GVREncoding)) {
         VRPToursParameter.ActualValue = GVREncoding.ConvertFrom(solution, CapacityParameter.ActualValue, DemandParameter.ActualValue, 
-          VehiclesParameter.ActualValue);
+          DistanceMatrixParameter);
       }
 
Index: anches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/Crossovers/MultiVRPManipulator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/Crossovers/MultiVRPManipulator.cs	(revision 4267)
+++ 	(revision )
@@ -1,136 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Linq;
-using HeuristicLab.Collections;
-using HeuristicLab.Core;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.PluginInfrastructure;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Problems.VehicleRouting.Encodings.General {
-  [Item("MultiVRPManipulator", "Randomly selects and applies one of its manipulators every time it is called.")]
-  [StorableClass]
-  public class MultiVRPManipulator : StochasticMultiBranch<IVRPManipulator>, IVRPManipulator, IStochasticOperator {
-    public override bool CanChangeName {
-      get { return false; }
-    }
-    protected override bool CreateChildOperation {
-      get { return true; }
-    }
-
-    public ILookupParameter<IVRPEncoding> VRPToursParameter {
-      get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPTours"]; }
-    }
-
-    public int Cities {
-      get { return CoordinatesParameter.ActualValue.Rows - 1; }
-    }
-    public ILookupParameter<DoubleMatrix> CoordinatesParameter {
-      get { return (ILookupParameter<DoubleMatrix>)Parameters["Coordinates"]; }
-    }
-    public ILookupParameter<DoubleMatrix> DistanceMatrixParameter {
-      get { return (ILookupParameter<DoubleMatrix>)Parameters["DistanceMatrix"]; }
-    }
-    public ILookupParameter<BoolValue> UseDistanceMatrixParameter {
-      get { return (ILookupParameter<BoolValue>)Parameters["UseDistanceMatrix"]; }
-    }
-    public ILookupParameter<IntValue> VehiclesParameter {
-      get { return (ILookupParameter<IntValue>)Parameters["Vehicles"]; }
-    }
-    public ILookupParameter<DoubleValue> CapacityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["Capacity"]; }
-    }
-    public ILookupParameter<DoubleArray> DemandParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters["Demand"]; }
-    }
-    public ILookupParameter<DoubleArray> ReadyTimeParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters["ReadyTime"]; }
-    }
-    public ILookupParameter<DoubleArray> DueTimeParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters["DueTime"]; }
-    }
-    public ILookupParameter<DoubleArray> ServiceTimeParameter {
-      get { return (ILookupParameter<DoubleArray>)Parameters["ServiceTime"]; }
-    }
-
-    [StorableConstructor]
-    private MultiVRPManipulator(bool deserializing) : base(deserializing) { }
-    public MultiVRPManipulator()
-      : base() {
-      Parameters.Add(new LookupParameter<IVRPEncoding>("VRPTours", "The VRP tours to be manipulated."));
-
-      Parameters.Add(new ValueLookupParameter<IntValue>("Cities", "The city count."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("Coordinates", "The coordinates of the cities."));
-      Parameters.Add(new LookupParameter<DoubleMatrix>("DistanceMatrix", "The matrix which contains the distances between the cities."));
-      Parameters.Add(new LookupParameter<BoolValue>("UseDistanceMatrix", "True if a distance matrix should be calculated and used for evaluation, otherwise false."));
-      Parameters.Add(new LookupParameter<IntValue>("Vehicles", "The number of vehicles."));
-      Parameters.Add(new LookupParameter<DoubleValue>("Capacity", "The capacity of each vehicle."));
-      Parameters.Add(new LookupParameter<DoubleArray>("Demand", "The demand of each customer."));
-      Parameters.Add(new LookupParameter<DoubleArray>("ReadyTime", "The ready time of each customer."));
-      Parameters.Add(new LookupParameter<DoubleArray>("DueTime", "The due time of each customer."));
-      Parameters.Add(new LookupParameter<DoubleArray>("ServiceTime", "The service time of each customer."));
-
-      foreach (Type type in ApplicationManager.Manager.GetTypes(typeof(IVRPManipulator))) {
-        if (!typeof(MultiOperator<IVRPManipulator>).IsAssignableFrom(type))
-          Operators.Add((IVRPManipulator)Activator.CreateInstance(type), true);
-      }
-    }
-
-    protected override void Operators_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<IVRPManipulator>> e) {
-      base.Operators_ItemsReplaced(sender, e);
-      ParameterizeManipulators();
-    }
-
-    protected override void Operators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IVRPManipulator>> e) {
-      base.Operators_ItemsAdded(sender, e);
-      ParameterizeManipulators();
-    }
-
-    private void ParameterizeManipulators() {
-      foreach (IVRPManipulator manipulator in Operators.OfType<IVRPManipulator>()) {
-        manipulator.VRPToursParameter.ActualName = VRPToursParameter.Name;
-
-        if (manipulator.CoordinatesParameter != null) manipulator.CoordinatesParameter.ActualName = CoordinatesParameter.Name;
-        if (manipulator.DistanceMatrixParameter != null) manipulator.DistanceMatrixParameter.ActualName = DistanceMatrixParameter.Name;
-        if (manipulator.UseDistanceMatrixParameter != null) manipulator.UseDistanceMatrixParameter.ActualName = UseDistanceMatrixParameter.Name;
-        if (manipulator.VehiclesParameter != null) manipulator.VehiclesParameter.ActualName = VehiclesParameter.Name;
-        if (manipulator.CapacityParameter != null) manipulator.CapacityParameter.ActualName = CapacityParameter.Name;
-        if (manipulator.DemandParameter != null) manipulator.DemandParameter.ActualName = DemandParameter.Name;
-        if (manipulator.ReadyTimeParameter != null) manipulator.ReadyTimeParameter.ActualName = ReadyTimeParameter.Name;
-        if (manipulator.DueTimeParameter != null) manipulator.DueTimeParameter.ActualName = DueTimeParameter.Name;
-        if (manipulator.ServiceTimeParameter != null) manipulator.ServiceTimeParameter.ActualName = ServiceTimeParameter.Name;
-      }
-      foreach (IStochasticOperator manipulator in Operators.OfType<IStochasticOperator>()) {
-        manipulator.RandomParameter.ActualName = RandomParameter.Name;
-      }
-    }
-
-    public override IOperation Apply() {
-      if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one permutation manipulator to choose from.");
-      return base.Apply();
-    }
-  }
-}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/Manipulators/MultiVRPManipulator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/Manipulators/MultiVRPManipulator.cs	(revision 4268)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/Manipulators/MultiVRPManipulator.cs	(revision 4268)
@@ -0,0 +1,136 @@
+﻿#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.Linq;
+using HeuristicLab.Collections;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.General {
+  [Item("MultiVRPManipulator", "Randomly selects and applies one of its manipulators every time it is called.")]
+  [StorableClass]
+  public class MultiVRPManipulator : StochasticMultiBranch<IVRPManipulator>, IVRPManipulator, IStochasticOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    protected override bool CreateChildOperation {
+      get { return true; }
+    }
+
+    public ILookupParameter<IVRPEncoding> VRPToursParameter {
+      get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPTours"]; }
+    }
+
+    public int Cities {
+      get { return CoordinatesParameter.ActualValue.Rows - 1; }
+    }
+    public ILookupParameter<DoubleMatrix> CoordinatesParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["Coordinates"]; }
+    }
+    public ILookupParameter<DoubleMatrix> DistanceMatrixParameter {
+      get { return (ILookupParameter<DoubleMatrix>)Parameters["DistanceMatrix"]; }
+    }
+    public ILookupParameter<BoolValue> UseDistanceMatrixParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["UseDistanceMatrix"]; }
+    }
+    public ILookupParameter<IntValue> VehiclesParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["Vehicles"]; }
+    }
+    public ILookupParameter<DoubleValue> CapacityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Capacity"]; }
+    }
+    public ILookupParameter<DoubleArray> DemandParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["Demand"]; }
+    }
+    public ILookupParameter<DoubleArray> ReadyTimeParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["ReadyTime"]; }
+    }
+    public ILookupParameter<DoubleArray> DueTimeParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["DueTime"]; }
+    }
+    public ILookupParameter<DoubleArray> ServiceTimeParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["ServiceTime"]; }
+    }
+
+    [StorableConstructor]
+    private MultiVRPManipulator(bool deserializing) : base(deserializing) { }
+    public MultiVRPManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<IVRPEncoding>("VRPTours", "The VRP tours to be manipulated."));
+
+      Parameters.Add(new ValueLookupParameter<IntValue>("Cities", "The city count."));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("Coordinates", "The coordinates of the cities."));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("DistanceMatrix", "The matrix which contains the distances between the cities."));
+      Parameters.Add(new LookupParameter<BoolValue>("UseDistanceMatrix", "True if a distance matrix should be calculated and used for evaluation, otherwise false."));
+      Parameters.Add(new LookupParameter<IntValue>("Vehicles", "The number of vehicles."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Capacity", "The capacity of each vehicle."));
+      Parameters.Add(new LookupParameter<DoubleArray>("Demand", "The demand of each customer."));
+      Parameters.Add(new LookupParameter<DoubleArray>("ReadyTime", "The ready time of each customer."));
+      Parameters.Add(new LookupParameter<DoubleArray>("DueTime", "The due time of each customer."));
+      Parameters.Add(new LookupParameter<DoubleArray>("ServiceTime", "The service time of each customer."));
+
+      foreach (Type type in ApplicationManager.Manager.GetTypes(typeof(IVRPManipulator))) {
+        if (!typeof(MultiOperator<IVRPManipulator>).IsAssignableFrom(type))
+          Operators.Add((IVRPManipulator)Activator.CreateInstance(type), true);
+      }
+    }
+
+    protected override void Operators_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<IVRPManipulator>> e) {
+      base.Operators_ItemsReplaced(sender, e);
+      ParameterizeManipulators();
+    }
+
+    protected override void Operators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IVRPManipulator>> e) {
+      base.Operators_ItemsAdded(sender, e);
+      ParameterizeManipulators();
+    }
+
+    private void ParameterizeManipulators() {
+      foreach (IVRPManipulator manipulator in Operators.OfType<IVRPManipulator>()) {
+        manipulator.VRPToursParameter.ActualName = VRPToursParameter.Name;
+
+        if (manipulator.CoordinatesParameter != null) manipulator.CoordinatesParameter.ActualName = CoordinatesParameter.Name;
+        if (manipulator.DistanceMatrixParameter != null) manipulator.DistanceMatrixParameter.ActualName = DistanceMatrixParameter.Name;
+        if (manipulator.UseDistanceMatrixParameter != null) manipulator.UseDistanceMatrixParameter.ActualName = UseDistanceMatrixParameter.Name;
+        if (manipulator.VehiclesParameter != null) manipulator.VehiclesParameter.ActualName = VehiclesParameter.Name;
+        if (manipulator.CapacityParameter != null) manipulator.CapacityParameter.ActualName = CapacityParameter.Name;
+        if (manipulator.DemandParameter != null) manipulator.DemandParameter.ActualName = DemandParameter.Name;
+        if (manipulator.ReadyTimeParameter != null) manipulator.ReadyTimeParameter.ActualName = ReadyTimeParameter.Name;
+        if (manipulator.DueTimeParameter != null) manipulator.DueTimeParameter.ActualName = DueTimeParameter.Name;
+        if (manipulator.ServiceTimeParameter != null) manipulator.ServiceTimeParameter.ActualName = ServiceTimeParameter.Name;
+      }
+      foreach (IStochasticOperator manipulator in Operators.OfType<IStochasticOperator>()) {
+        manipulator.RandomParameter.ActualName = RandomParameter.Name;
+      }
+    }
+
+    public override IOperation Apply() {
+      if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one permutation manipulator to choose from.");
+      return base.Apply();
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/Moves/Interfaces/IVRPMove.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/Moves/Interfaces/IVRPMove.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/Moves/Interfaces/IVRPMove.cs	(revision 4268)
@@ -27,5 +27,5 @@
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.General {
   public interface IVRPMove : IItem {
-    TourEvaluation GetMoveQuality(IVRPEncoding individual, 
+    TourEvaluation GetMoveQuality(IVRPEncoding individual,  IntValue vehicles,
         DoubleArray dueTimeArray, DoubleArray serviceTimeArray, DoubleArray readyTimeArray, DoubleArray demandArray, 
         DoubleValue capacity,DoubleMatrix coordinates,
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveEvaluator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveEvaluator.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/Moves/MultiVRPMoveOperator/MultiVRPMoveEvaluator.cs	(revision 4268)
@@ -47,4 +47,5 @@
       return move.GetMoveQuality(
         VRPToursParameter.ActualValue,
+        VehiclesParameter.ActualValue,
         DueTimeParameter.ActualValue,
         ServiceTimeParameter.ActualValue,
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/PermutationEncoding.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/PermutationEncoding.cs	(revision 4268)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/PermutationEncoding.cs	(revision 4268)
@@ -0,0 +1,50 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.General {
+  [Item("PermutationEncoding", "Represents a base class for permutation encodings of VRP solutions.")]
+  [StorableClass]
+  public abstract class PermutationEncoding : Permutation, IVRPEncoding {
+    #region IVRPEncoding Members
+    public abstract List<Tour> GetTours(ILookupParameter<DoubleMatrix> distanceMatrix = null, int maxVehicles = int.MaxValue);
+    #endregion
+
+    public PermutationEncoding(Permutation permutation)
+      : base(PermutationTypes.RelativeUndirected) {
+      this.array = new int[permutation.Length];
+      for (int i = 0; i < array.Length; i++)
+        this.array[i] = permutation[i];
+    }
+
+    [StorableConstructor]
+    protected PermutationEncoding(bool serializing)
+      : base() {
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/TourEncoding.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/TourEncoding.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/General/TourEncoding.cs	(revision 4268)
@@ -37,6 +37,15 @@
     
     #region IVRPEncoding Members
-    public virtual List<Tour> GetTours() {
-      return new List<Tour>(Tours);
+    public virtual List<Tour> GetTours(ILookupParameter<DoubleMatrix> distanceMatrix = null, int maxVehicles = int.MaxValue) {
+      List<Tour> result = new List<Tour>(Tours);
+
+      while (result.Count > maxVehicles) {
+        Tour tour = result[result.Count - 1];
+        result[result.Count - 2].Cities.AddRange(tour.Cities);
+
+        result.Remove(tour);
+      }
+
+      return result;
     }
 
@@ -66,7 +75,7 @@
       : base() {
     }
-    
-    public static void ConvertFrom(IVRPEncoding encoding, TourEncoding solution) {
-      solution.Tours = new ItemList<Tour>(encoding.GetTours());
+
+    public static void ConvertFrom(IVRPEncoding encoding, TourEncoding solution, ILookupParameter<DoubleMatrix> distanceMatrix) {
+      solution.Tours = new ItemList<Tour>(encoding.GetTours(distanceMatrix));
     }
 
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/Crossovers/PotvinCrossover.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/Crossovers/PotvinCrossover.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/Crossovers/PotvinCrossover.cs	(revision 4268)
@@ -129,5 +129,5 @@
 
         if (!(solution is PotvinEncoding)) {
-          parents[i] = PotvinEncoding.ConvertFrom(solution);
+          parents[i] = PotvinEncoding.ConvertFrom(solution, DistanceMatrixParameter);
         } else {
           parents[i] = solution;
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/Manipulators/PotvinManipulator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/Manipulators/PotvinManipulator.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/Manipulators/PotvinManipulator.cs	(revision 4268)
@@ -82,5 +82,5 @@
       IVRPEncoding solution = VRPToursParameter.ActualValue;
       if (!(solution is PotvinEncoding)) {
-        VRPToursParameter.ActualValue = PotvinEncoding.ConvertFrom(solution);
+        VRPToursParameter.ActualValue = PotvinEncoding.ConvertFrom(solution, DistanceMatrixParameter);
       }
       
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/PotvinEncoding.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/PotvinEncoding.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Potvin/PotvinEncoding.cs	(revision 4268)
@@ -53,8 +53,8 @@
     }
     
-    public static PotvinEncoding ConvertFrom(IVRPEncoding encoding) {
+    public static PotvinEncoding ConvertFrom(IVRPEncoding encoding, ILookupParameter<DoubleMatrix> distanceMatrix) {
       PotvinEncoding solution = new PotvinEncoding();
 
-      TourEncoding.ConvertFrom(encoding, solution);
+      TourEncoding.ConvertFrom(encoding, solution, distanceMatrix);
 
       return solution;
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Crossovers/PrinsCrossover.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Crossovers/PrinsCrossover.cs	(revision 4268)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Crossovers/PrinsCrossover.cs	(revision 4268)
@@ -0,0 +1,102 @@
+﻿#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.Prins {
+  [Item("PrinsCrossover", "An operator which crosses two VRP representations.")]
+  [StorableClass]
+  public abstract class PrinsCrossover : VRPCrossover, IStochasticOperator {
+    public ILookupParameter<DoubleValue> FleetUsageFactor {
+      get { return (ILookupParameter<DoubleValue>)Parameters["EvalFleetUsageFactor"]; }
+    }
+    public ILookupParameter<DoubleValue> TimeFactor {
+      get { return (ILookupParameter<DoubleValue>)Parameters["EvalTimeFactor"]; }
+    }
+    public ILookupParameter<DoubleValue> DistanceFactor {
+      get { return (ILookupParameter<DoubleValue>)Parameters["EvalDistanceFactor"]; }
+    }
+    public ILookupParameter<DoubleValue> OverloadPenalty {
+      get { return (ILookupParameter<DoubleValue>)Parameters["EvalOverloadPenalty"]; }
+    }
+    public ILookupParameter<DoubleValue> TardinessPenalty {
+      get { return (ILookupParameter<DoubleValue>)Parameters["EvalTardinessPenalty"]; }
+    }
+    
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    
+    [StorableConstructor]
+    protected PrinsCrossover(bool deserializing) : base(deserializing) { }
+
+    public PrinsCrossover()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("EvalFleetUsageFactor", "The fleet usage factor considered in the evaluation."));
+      Parameters.Add(new LookupParameter<DoubleValue>("EvalTimeFactor", "The time factor considered in the evaluation."));
+      Parameters.Add(new LookupParameter<DoubleValue>("EvalDistanceFactor", "The distance factor considered in the evaluation."));
+      Parameters.Add(new LookupParameter<DoubleValue>("EvalOverloadPenalty", "The overload penalty considered in the evaluation."));
+      Parameters.Add(new LookupParameter<DoubleValue>("EvalTardinessPenalty", "The tardiness penalty considered in the evaluation."));
+
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+    }
+
+    protected abstract PrinsEncoding Crossover(IRandom random, PrinsEncoding parent1, PrinsEncoding parent2);
+
+    public override IOperation Apply() {
+      ItemArray<IVRPEncoding> parents = new ItemArray<IVRPEncoding>(ParentsParameter.ActualValue.Length);
+      for (int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
+        IVRPEncoding solution = ParentsParameter.ActualValue[i];
+
+        if (!(solution is PrinsEncoding)) {
+          parents[i] = PrinsEncoding.ConvertFrom(solution,
+            Cities, 
+            DueTimeParameter.ActualValue,
+            ServiceTimeParameter.ActualValue,
+            ReadyTimeParameter.ActualValue,
+            DemandParameter.ActualValue,
+            CapacityParameter.ActualValue,
+            FleetUsageFactor.ActualValue,
+            TimeFactor.ActualValue,
+            DistanceFactor.ActualValue,
+            OverloadPenalty.ActualValue,
+            TardinessPenalty.ActualValue,
+            CoordinatesParameter.ActualValue,
+            DistanceMatrixParameter,
+            UseDistanceMatrixParameter.ActualValue);
+        } else {
+          parents[i] = solution;
+        }
+      }
+      ParentsParameter.ActualValue = parents;
+
+      ChildParameter.ActualValue =
+        Crossover(RandomParameter.ActualValue, parents[0] as PrinsEncoding, parents[1] as PrinsEncoding);
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Crossovers/PrinsPermutationCrossover.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Crossovers/PrinsPermutationCrossover.cs	(revision 4268)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Crossovers/PrinsPermutationCrossover.cs	(revision 4268)
@@ -0,0 +1,75 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  [Item("PrinsPermutationCrossover", "An operator which crosses two VRP representations using a standard permutation operator.")]
+  [StorableClass]
+  public sealed class PrinsPermutationCrossover : PrinsCrossover, IPrinsOperator {    
+    public IValueLookupParameter<IPermutationCrossover> InnerCrossoverParameter {
+      get { return (IValueLookupParameter<IPermutationCrossover>)Parameters["InnerCrossover"]; }
+    }
+
+    [StorableConstructor]
+    private PrinsPermutationCrossover(bool deserializing) : base(deserializing) { }
+
+    public PrinsPermutationCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IPermutationCrossover>("InnerCrossover", "The permutation crossover.", new OrderCrossover()));
+    }
+
+    protected override PrinsEncoding Crossover(IRandom random, PrinsEncoding parent1, PrinsEncoding parent2) {
+      //note - the inner crossover is called here and the result is converted to a prins representation
+      //some refactoring should be done here in the future - the crossover operation should be called directly
+
+      InnerCrossoverParameter.ActualValue.ParentsParameter.ActualName = ParentsParameter.ActualName;
+      IAtomicOperation op = this.ExecutionContext.CreateOperation(
+        InnerCrossoverParameter.ActualValue, this.ExecutionContext.Scope);
+      op.Operator.Execute((IExecutionContext)op);
+
+      string childName = InnerCrossoverParameter.ActualValue.ChildParameter.ActualName;
+      if (ExecutionContext.Scope.Variables.ContainsKey(childName)) {
+        Permutation permutation = ExecutionContext.Scope.Variables[childName].Value as Permutation;
+        ExecutionContext.Scope.Variables.Remove(childName);
+
+        return new PrinsEncoding(permutation, Cities,
+          DueTimeParameter.ActualValue,
+            ServiceTimeParameter.ActualValue,
+            ReadyTimeParameter.ActualValue,
+            DemandParameter.ActualValue,
+            CapacityParameter.ActualValue,
+            FleetUsageFactor.ActualValue,
+            TimeFactor.ActualValue,
+            DistanceFactor.ActualValue,
+            OverloadPenalty.ActualValue,
+            TardinessPenalty.ActualValue,
+            CoordinatesParameter.ActualValue,
+            UseDistanceMatrixParameter.ActualValue);
+      } else
+        return null;
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Interfaces/IPrinsOperator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Interfaces/IPrinsOperator.cs	(revision 4268)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Interfaces/IPrinsOperator.cs	(revision 4268)
@@ -0,0 +1,37 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  interface IPrinsOperator: IVRPOperator {
+    ILookupParameter<DoubleValue> FleetUsageFactor { get; }
+    ILookupParameter<DoubleValue> TimeFactor { get; }
+    ILookupParameter<DoubleValue> DistanceFactor { get; }
+    ILookupParameter<DoubleValue> OverloadPenalty { get; }
+    ILookupParameter<DoubleValue> TardinessPenalty { get; }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsExhaustiveLSManipulator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsExhaustiveLSManipulator.cs	(revision 4268)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsExhaustiveLSManipulator.cs	(revision 4268)
@@ -0,0 +1,76 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  [Item("PrinsExhaustiveLSManipulator", "An operator which manipulates a VRP representation by using the exhaustive Prins local search.  It is implemented as described in Prins, C. (2004). A simple and effective evolutionary algorithm for the vehicle routing problem. Computers & Operations Research, 12:1985-2002.")]
+  [StorableClass]
+  public sealed class PrinsExhaustiveLSManipulator : PrinsLSManipulator {   
+    [StorableConstructor]
+    private PrinsExhaustiveLSManipulator(bool deserializing) : base(deserializing) { }
+
+    public PrinsExhaustiveLSManipulator()
+      : base() {
+    }
+
+    protected override void Manipulate(IRandom random, PrinsEncoding individual) {
+      List<Tour> tours = individual.GetTours(DistanceMatrixParameter);
+      bool improvement = false;
+      int iterations = 0;
+
+      do {
+        int u = depot;
+        improvement = false;
+        double originalQuality = GetQuality(individual);
+        PrinsEncoding child = null;
+
+        while (!improvement && u < Cities) {
+          int v = depot;
+          while (!improvement && v < Cities) {
+            if (u != v) {
+              child = Manipulate(individual,
+                originalQuality, u, v);
+
+              improvement = child != null;
+            }
+            v++;
+          }
+          u++;
+        }
+
+        if (improvement) {
+          for (int i = 0; i < child.Length; i++) {
+            individual[i] = child[i];
+          }
+        }
+
+        iterations++;
+      } while (improvement && 
+        iterations < Iterations.Value.Value);
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsLSManipulator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsLSManipulator.cs	(revision 4268)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsLSManipulator.cs	(revision 4268)
@@ -0,0 +1,531 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  [Item("PrinsLSManipulator", "An operator which manipulates a VRP representation by using the Prins local search.  It is implemented as described in Prins, C. (2004). A simple and effective evolutionary algorithm for the vehicle routing problem. Computers & Operations Research, 12:1985-2002.")]
+  [StorableClass]
+  public abstract class PrinsLSManipulator : PrinsManipulator {
+    public IValueParameter<IntValue> Iterations {
+      get { return (IValueParameter<IntValue>)Parameters["Iterations"]; }
+    }
+        
+    [StorableConstructor]
+    protected PrinsLSManipulator(bool deserializing) : base(deserializing) { }
+
+    public PrinsLSManipulator()
+      : base() {
+      Parameters.Add(new ValueParameter<IntValue>("Iterations", "The number of max iterations.", new IntValue(5)));
+    }
+
+    protected double GetQuality(PrinsEncoding individual) {
+      return VRPEvaluator.Evaluate(individual,
+        VehiclesParameter.ActualValue,
+        DueTimeParameter.ActualValue,
+        ServiceTimeParameter.ActualValue,
+        ReadyTimeParameter.ActualValue,
+        DemandParameter.ActualValue,
+        CapacityParameter.ActualValue,
+        FleetUsageFactor.ActualValue,
+        TimeFactor.ActualValue,
+        DistanceFactor.ActualValue,
+        OverloadPenalty.ActualValue,
+        TardinessPenalty.ActualValue,
+        CoordinatesParameter.ActualValue,
+        DistanceMatrixParameter,
+        UseDistanceMatrixParameter.ActualValue).Quality;
+    }
+
+    private int FindCity(PrinsEncoding individual, int city) {
+      int index = -1;
+
+      int i = 0;
+      while (i < individual.Length && index == -1) {
+        if (individual[i] == city)
+          index = i;
+        
+        i++;
+      }
+
+      return index;
+    }
+
+    protected const int depot = -1;
+
+    private Tour FindTour(PrinsEncoding individual, int citiy) {
+      Tour found = null;
+
+      List<Tour> tours = individual.GetTours(DistanceMatrixParameter);
+      int i = 0;
+
+      while (found == null && i < tours.Count) {
+        if (tours[i].Cities.Contains(citiy + 1))
+          found = tours[i];
+        
+        i++;
+      }
+
+      return found;
+    }
+
+    //inserts u after v in the child
+    private void InsertAfter(int u, int v, PrinsEncoding parent, PrinsEncoding child) {
+      int pi = 0;
+      int ci = 0;
+
+      while (ci != child.Length) {
+        if (parent[pi] != u) {
+          child[ci] = parent[pi];
+          ci++;
+        }
+        if (parent[pi] == v) {
+          child[ci] = u;
+          ci++;
+        }
+
+        pi++;
+      }
+    }
+
+    //inserts (u, x) after v in the child
+    private void InsertAfter(int u, int x, int v, PrinsEncoding parent, PrinsEncoding child) {
+      int pi = 0;
+      int ci = 0;
+
+      while (ci != child.Length) {
+        if (parent[pi] != u && parent[pi] != x) {
+          child[ci] = parent[pi];
+          ci++;
+        }
+        if (parent[pi] == v) {
+          child[ci] = u;
+          ci++;
+
+          child[ci] = x;
+          ci++;
+        }
+
+        pi++;
+      }
+    }
+
+    //inserts u before v in the child
+    private void InsertBefore(int u, int v, PrinsEncoding parent, PrinsEncoding child) {
+      int pi = 0;
+      int ci = 0;
+
+      while (ci != child.Length) {
+        if (parent[pi] == v) {
+          child[ci] = u;
+          ci++;
+        }
+        if (parent[pi] != u) {
+          child[ci] = parent[pi];
+          ci++;
+        }
+
+        pi++;
+      }
+    }
+
+    //inserts (u, x) before v in the child
+    private void InsertBefore(int u, int x, int v, PrinsEncoding parent, PrinsEncoding child) {
+      int pi = 0;
+      int ci = 0;
+
+      while (ci != child.Length) {
+        if (parent[pi] == v) {
+          child[ci] = u;
+          ci++;
+
+          child[ci] = x;
+          ci++;
+        }
+        if (parent[pi] != u && parent[pi] != x) {
+          child[ci] = parent[pi];
+          ci++;
+        }
+
+        pi++;
+      }
+    }
+
+    //swaps u and v
+    private void Swap(int u, int v, PrinsEncoding parent, PrinsEncoding child) {
+      for (int i = 0; i < child.Length; i++) {
+        if (parent[i] == u)
+          child[i] = v;
+        else if (parent[i] == v)
+          child[i] = u;
+        else
+          child[i] = parent[i];
+      }
+    }
+
+    //swaps (u, x) and v
+    private void Swap(int u, int x, int v, PrinsEncoding parent, PrinsEncoding child) {
+      int childIndex = 0;
+      int parentIndex = 0;
+
+      while(childIndex < child.Length) {
+        if (parent[parentIndex] == u) {
+          child[childIndex] = v;
+          parentIndex++;
+        } else if (parent[parentIndex] == v) {
+          child[childIndex] = u;
+          childIndex++;
+          child[childIndex] = x;
+        } else {
+          child[childIndex] = parent[parentIndex];
+        }
+
+        childIndex++;
+        parentIndex++;
+      }
+    }
+
+    //swaps (u, x) and (v, y)
+    private void Swap(int u, int x, int v, int y, PrinsEncoding parent, PrinsEncoding child) {
+      int i = 0;
+
+      while (i < child.Length) {
+        if (child[i] == u) {
+          child[i] = v;
+          i++;
+          child[i] = y;
+        } else if (child[i] == v) {
+          child[i] = u;
+          i++;
+          child[i] = x;
+        } else {
+          child[i] = parent[i];
+        }
+
+        i++;
+      }
+    }
+
+    //swaps (u, x) and (v, y) by (u, y) and (x, v)
+    private void Swap2(int u, int x, int v, int y, PrinsEncoding parent, PrinsEncoding child) {
+      int i = 0;
+
+      while (i < child.Length) {
+        if(parent[i] == x) {
+          child[i] = y;
+        } else if(parent[i] == v) {
+          child[i] = x;
+        } else if(parent[i] == y) {
+          child[i] = v;
+        } else {
+          child[i] = parent[i];
+        }
+
+        i++;
+      }
+    }
+
+    private void M1(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot) {
+        if (v == depot) {
+          Tour tour = FindTour(child, u);
+          v = tour.Cities[0] - 1;
+          InsertBefore(u, v, parent, child);
+        } else {
+          InsertAfter(u, v, parent, child);
+        }
+      }
+
+      if(!child.Validate()) {
+      }
+    }
+
+    private void M2(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot) {
+        Tour tour = FindTour(child, u);
+        int iu = tour.Cities.IndexOf(u + 1);
+        if (iu < tour.Cities.Count - 1) {
+          int x = tour.Cities[iu + 1] - 1;
+
+          if (v == depot) {
+            tour = FindTour(child, u);
+            v = tour.Cities[0] - 1;
+            InsertBefore(u, x, v, parent, child);
+          } else {
+            InsertAfter(u, x, v, parent, child);
+          }
+        }
+      }
+
+      if (!child.Validate()) {
+      }
+    }
+
+    private void M3(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot) {
+        Tour tour = FindTour(child, u);
+        int iu = tour.Cities.IndexOf(u + 1);
+        if (iu < tour.Cities.Count - 1) {
+          int x = tour.Cities[iu + 1] - 1;
+
+          if (v == depot) {
+            tour = FindTour(child, u);
+            v = tour.Cities[0] - 1;
+            InsertBefore(x, u, v, parent, child);
+          } else {
+            InsertAfter(x, u, v, parent, child);
+          }
+        }
+      }
+
+      if (!child.Validate()) {
+      }
+    }
+
+    private void M4(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot && v != depot) {
+        Swap(u, v, parent, child);
+      }
+
+      if (!child.Validate()) {
+      }
+    }
+
+    private void M5(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot && v != depot) {
+        Tour tour = FindTour(child, u);
+        int iu = tour.Cities.IndexOf(u + 1);
+        if (iu < tour.Cities.Count - 1) {
+          int x = tour.Cities[iu + 1] - 1;
+
+          if(x != v)
+            Swap(u, x, v, parent, child);
+        }
+      }
+
+      if (!child.Validate()) {
+      }
+    }
+
+    private void M6(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot && v != depot) {
+        Tour tour = FindTour(child, u);
+        int iu = tour.Cities.IndexOf(u + 1);
+        if (iu < tour.Cities.Count - 1) {
+          int x = tour.Cities[iu + 1] - 1;
+
+          tour = FindTour(child, v);
+          int iv = tour.Cities.IndexOf(v + 1);
+          if (iv < tour.Cities.Count - 1) {
+            int y = tour.Cities[iv + 1] - 1;
+
+            if (x != v && y != u)
+              Swap(u, x, v, y, parent, child);
+          }
+        }
+      }
+
+      if (!child.Validate()) {
+      }
+    }
+
+    private void M7(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot && v != depot) {
+        Tour tu = FindTour(child, u);
+        Tour tv = FindTour(child, v);
+
+        if (tu.Cities[0] == tv.Cities[0]) {
+          int iu = tu.Cities.IndexOf(u + 1);
+          if (iu < tu.Cities.Count - 1) {
+            int x = tu.Cities[iu + 1] - 1;
+
+            int iv = tv.Cities.IndexOf(v + 1);
+            if (iv < tv.Cities.Count - 1) {
+              int y = tv.Cities[iv + 1] - 1;
+
+              if (x != v && y != u)
+                Swap(x, v, parent, child);
+             }
+           }
+        }
+      }
+
+      if (!child.Validate()) {
+      }
+    }
+
+    private void M8(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot && v != depot) {
+        Tour tu = FindTour(child, u);
+        Tour tv = FindTour(child, v);
+
+        if (tu.Cities[0] != tv.Cities[0]) {
+          int iu = tu.Cities.IndexOf(u + 1);
+          if (iu < tu.Cities.Count - 1) {
+            int x = tu.Cities[iu + 1] - 1;
+
+            int iv = tv.Cities.IndexOf(v + 1);
+            if (iv < tv.Cities.Count - 1) {
+              int y = tv.Cities[iv + 1] - 1;
+
+              if (x != v && y != u)
+                Swap(x, v, parent, child);
+            }
+          }
+        }
+      }
+
+      if (!child.Validate()) {
+      }
+    }
+
+    private void M9(PrinsEncoding parent, PrinsEncoding child, int u, int v) {
+      if (u != depot && v != depot) {
+        Tour tu = FindTour(child, u);
+        Tour tv = FindTour(child, v);
+
+        if (tu.Cities[0] != tv.Cities[0]) {
+          int iu = tu.Cities.IndexOf(u + 1);
+          if (iu < tu.Cities.Count - 1) {
+            int x = tu.Cities[iu + 1] - 1;
+
+            int iv = tv.Cities.IndexOf(v + 1);
+            if (iv < tv.Cities.Count - 1) {
+              int y = tv.Cities[iv + 1] - 1;
+
+              if (x != v && y != u)
+                Swap2(u, x, v, y, parent, child);
+            }
+          }
+        }
+      }
+
+      if (!child.Validate()) {
+      }
+    }
+
+    protected PrinsEncoding Manipulate(PrinsEncoding individual, 
+      double originalQuality, int u, int v) {
+      PrinsEncoding child = null;
+      bool improvement = false;
+
+      if (u != v) {
+        child = individual.Clone() as PrinsEncoding;
+        M1(individual, child, u, v);
+        improvement = GetQuality(child) < originalQuality;
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M2(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M3(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M4(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M5(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M6(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M7(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M8(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+
+        if (!improvement) {
+          child = individual.Clone() as PrinsEncoding;
+          M9(individual, child, u, v);
+          improvement = GetQuality(child) < originalQuality;
+        }
+      }
+
+      if (improvement)
+        return child;
+      else
+        return null;
+    }
+
+    protected override void Manipulate(IRandom random, PrinsEncoding individual) {
+      List<Tour> tours = individual.GetTours(DistanceMatrixParameter);
+      bool improvement = false;
+      int iterations = 0;
+
+      do {
+        int u = depot;
+        improvement = false;
+        double originalQuality = GetQuality(individual);
+        PrinsEncoding child = null;
+
+        while (!improvement && u < Cities) {
+          int v = depot;
+          while (!improvement && v < Cities) {
+            if (u != v) {
+              child = Manipulate(individual,
+                originalQuality, u, v);
+
+              improvement = child != null;
+            }
+            v++;
+          }
+          u++;
+        }
+
+        if (improvement) {
+          for (int i = 0; i < child.Length; i++) {
+            individual[i] = child[i];
+          }
+        }
+
+        iterations++;
+      } while (improvement && 
+        iterations < Iterations.Value.Value);
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsManipulator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsManipulator.cs	(revision 4268)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsManipulator.cs	(revision 4268)
@@ -0,0 +1,94 @@
+﻿#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.Prins {
+  [Item("PrinsManipulator", "An operator which manipulates a VRP representation.")]
+  [StorableClass]
+  public abstract class PrinsManipulator : VRPManipulator, IStochasticOperator, IPrinsOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public ILookupParameter<DoubleValue> FleetUsageFactor {
+      get { return (ILookupParameter<DoubleValue>)Parameters["EvalFleetUsageFactor"]; }
+    }
+    public ILookupParameter<DoubleValue> TimeFactor {
+      get { return (ILookupParameter<DoubleValue>)Parameters["EvalTimeFactor"]; }
+    }
+    public ILookupParameter<DoubleValue> DistanceFactor {
+      get { return (ILookupParameter<DoubleValue>)Parameters["EvalDistanceFactor"]; }
+    }
+    public ILookupParameter<DoubleValue> OverloadPenalty {
+      get { return (ILookupParameter<DoubleValue>)Parameters["EvalOverloadPenalty"]; }
+    }
+    public ILookupParameter<DoubleValue> TardinessPenalty {
+      get { return (ILookupParameter<DoubleValue>)Parameters["EvalTardinessPenalty"]; }
+    }
+
+    [StorableConstructor]
+    protected PrinsManipulator(bool deserializing) : base(deserializing) { }
+
+    public PrinsManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("EvalFleetUsageFactor", "The fleet usage factor considered in the evaluation."));
+      Parameters.Add(new LookupParameter<DoubleValue>("EvalTimeFactor", "The time factor considered in the evaluation."));
+      Parameters.Add(new LookupParameter<DoubleValue>("EvalDistanceFactor", "The distance factor considered in the evaluation."));
+      Parameters.Add(new LookupParameter<DoubleValue>("EvalOverloadPenalty", "The overload penalty considered in the evaluation."));
+      Parameters.Add(new LookupParameter<DoubleValue>("EvalTardinessPenalty", "The tardiness penalty considered in the evaluation."));
+
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+    }
+
+    protected abstract void Manipulate(IRandom random, PrinsEncoding individual);
+
+    public override IOperation Apply() {
+      IVRPEncoding solution = VRPToursParameter.ActualValue;
+      if (!(solution is PrinsEncoding)) {
+        VRPToursParameter.ActualValue = PrinsEncoding.ConvertFrom(solution,
+            Cities, 
+            DueTimeParameter.ActualValue,
+            ServiceTimeParameter.ActualValue,
+            ReadyTimeParameter.ActualValue,
+            DemandParameter.ActualValue,
+            CapacityParameter.ActualValue,
+            FleetUsageFactor.ActualValue, 
+            TimeFactor.ActualValue, 
+            DistanceFactor.ActualValue, 
+            OverloadPenalty.ActualValue, 
+            TardinessPenalty.ActualValue,
+            CoordinatesParameter.ActualValue,
+            DistanceMatrixParameter,
+            UseDistanceMatrixParameter.ActualValue);
+      }
+
+      Manipulate(RandomParameter.ActualValue, VRPToursParameter.ActualValue as PrinsEncoding);
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsPermutationManipulator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsPermutationManipulator.cs	(revision 4268)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsPermutationManipulator.cs	(revision 4268)
@@ -0,0 +1,52 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  [Item("PrinsPermutationManipulator", "An operator which manipulates a VRP representation by using a standard permutation manipulator.")]
+  [StorableClass]
+  public sealed class PrinsPermutationManipulator : PrinsManipulator {
+    public IValueLookupParameter<IPermutationManipulator> InnerManipulatorParameter {
+      get { return (IValueLookupParameter<IPermutationManipulator>)Parameters["InnerManipulator"]; }
+    }
+
+    [StorableConstructor]
+    private PrinsPermutationManipulator(bool deserializing) : base(deserializing) { }
+
+    public PrinsPermutationManipulator()
+      : base() {
+        Parameters.Add(new ValueLookupParameter<IPermutationManipulator>("InnerManipulator", "The permutation manipulator.", new TranslocationManipulator()));
+    }
+
+    protected override void Manipulate(IRandom random, PrinsEncoding individual) {
+      InnerManipulatorParameter.ActualValue.PermutationParameter.ActualName = VRPToursParameter.ActualName;
+
+      IAtomicOperation op = this.ExecutionContext.CreateOperation(
+        InnerManipulatorParameter.ActualValue, this.ExecutionContext.Scope);
+      op.Operator.Execute((IExecutionContext)op);
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsStochasticLSManipulator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsStochasticLSManipulator.cs	(revision 4268)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/Manipulators/PrinsStochasticLSManipulator.cs	(revision 4268)
@@ -0,0 +1,80 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  [Item("PrinsStochasticLSManipulator", "An operator which manipulates a VRP representation by using the stochastic version of the Prins local search.  It is implemented as described in Prins, C. (2004). A simple and effective evolutionary algorithm for the vehicle routing problem. Computers & Operations Research, 12:1985-2002.")]
+  [StorableClass]
+  public sealed class PrinsStochasticLSManipulator : PrinsLSManipulator {
+    public IValueParameter<IntValue> SampleSize {
+      get { return (IValueParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+    
+    [StorableConstructor]
+    private PrinsStochasticLSManipulator(bool deserializing) : base(deserializing) { }
+
+    public PrinsStochasticLSManipulator()
+      : base() {
+        Parameters.Add(new ValueParameter<IntValue>("SampleSize", "The sample size.", new IntValue(200)));
+    }
+
+    protected override void Manipulate(IRandom random, PrinsEncoding individual) {
+      List<Tour> tours = individual.GetTours(DistanceMatrixParameter);
+      bool improvement = false;
+      int iterations = 0;
+
+      do {
+        improvement = false;
+        double originalQuality = GetQuality(individual);
+        PrinsEncoding child = null;
+
+        int samples = 0;
+        while (!improvement &&
+          samples < SampleSize.Value.Value) {
+            int u = random.Next(Cities);
+            int v = random.Next(Cities);
+
+            child = Manipulate(individual,
+                  originalQuality, u, v);
+
+            improvement = child != null;
+
+            samples++;
+        }
+
+        if (improvement) {
+          for (int i = 0; i < child.Length; i++) {
+            individual[i] = child[i];
+          }
+        }
+
+        iterations++;
+      } while (improvement && 
+        iterations < Iterations.Value.Value);
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/PrinsEncoding.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/PrinsEncoding.cs	(revision 4268)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Prins/PrinsEncoding.cs	(revision 4268)
@@ -0,0 +1,256 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Collections.Generic;
+using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using System;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Prins {
+  [Item("PrinsEncoding", "Represents an Prins encoding of VRP solutions. It is implemented as described in Prins, C. (2004). A simple and effective evolutionary algorithm for the vehicle routing problem. Computers & Operations Research, 12:1985-2002.")]
+  [StorableClass]
+  public class PrinsEncoding : PermutationEncoding {
+    [Storable]
+    private int cities;
+
+    [Storable]
+    private DoubleMatrix coordinates;
+
+    [Storable]
+    private BoolValue useDistanceMatrix;
+
+    [Storable]
+    DoubleArray dueTimeArray;
+    
+    [Storable]
+    DoubleArray serviceTimeArray;
+
+    [Storable]
+    DoubleArray readyTimeArray;
+    
+    [Storable]
+    DoubleArray demandArray;
+
+    [Storable]
+    DoubleValue capacity;
+
+    [Storable]
+    DoubleValue fleetUsageFactor;
+
+    [Storable]
+    DoubleValue timeFactor;
+
+    [Storable]
+    DoubleValue distanceFactor;
+
+    [Storable]
+    DoubleValue overloadPenalty;
+
+    [Storable]
+    DoubleValue tardinessPenalty;
+
+    #region IVRPEncoding Members
+    public override List<Tour> GetTours(ILookupParameter<DoubleMatrix> distanceMatrix, int maxVehicles = int.MaxValue) {
+      List<Tour> result = new List<Tour>();
+
+      //Split permutation into vector P
+      int[] P = new int[cities + 1];
+      for (int i = 0; i <= cities; i++)
+        P[i] = -1;
+
+      double[] V = new double[cities + 1];
+      V[0] = 0;
+      for (int i = 1; i <= cities; i++) {
+        V[i] = int.MaxValue;
+      }
+
+      for (int i = 1; i <= cities; i++) {
+        int j = i;
+        Tour tour = new Tour();
+        bool feasible = true;
+
+        do {
+          tour.Cities.Add(this[j-1] + 1);
+
+          TourEvaluation eval = VRPEvaluator.EvaluateTour(tour,
+            dueTimeArray,
+            serviceTimeArray,
+            readyTimeArray,
+            demandArray,
+            capacity,
+            fleetUsageFactor,
+            timeFactor,
+            distanceFactor,
+            overloadPenalty,
+            tardinessPenalty,
+            coordinates,
+            distanceMatrix,
+            useDistanceMatrix);
+
+          double cost = eval.Quality;
+          feasible = eval.Overload < double.Epsilon && eval.Tardiness < double.Epsilon;
+
+          if (feasible) {
+            if (V[i - 1] + cost < V[j]) {
+              V[j] = V[i - 1] + cost;
+              P[j] = i - 1;
+            }
+            j++;
+          }
+
+        } while (j <= cities && feasible);
+      }
+
+      //extract VRP solution from vector P
+      int index = 0;
+      int index2 = cities;
+      Tour trip = null;
+      do {
+        index = P[index2];
+        trip = new Tour();
+
+        for (int k = index + 1; k <= index2; k++) {
+          trip.Cities.Add(this[k - 1] + 1);
+        }
+
+        if (trip.Cities.Count > 0)
+          result.Add(trip);
+
+        index2 = index;
+      } while (index != 0);
+
+      //if there are too many vehicles - repair
+      while (result.Count > maxVehicles) {
+        Tour tour = result[result.Count - 1];
+
+        //find predecessor / successor in permutation
+        int predecessorIndex = Array.IndexOf(this.array, tour.Cities[0] - 1) - 1;
+        if (predecessorIndex >= 0) {
+          int predecessor = this[predecessorIndex] + 1;
+
+          foreach (Tour t in result) {
+            int insertPosition = t.Cities.IndexOf(predecessor) + 1;
+            if (insertPosition != -1) {
+              t.Cities.InsertRange(insertPosition, tour.Cities);
+              break;
+            }
+          }
+        } else {
+          int successorIndex = Array.IndexOf(this.array,
+            tour.Cities[tour.Cities.Count - 1] - 1) + 1;
+          int successor = this[successorIndex] + 1;
+
+          foreach (Tour t in result) {
+            int insertPosition = t.Cities.IndexOf(successor);
+            if (insertPosition != -1) {
+              t.Cities.InsertRange(insertPosition, tour.Cities);
+              break;
+            }
+          }
+        }
+
+        result.Remove(tour);
+      }
+
+      return result;
+    }
+    #endregion
+
+    public override IDeepCloneable Clone(HeuristicLab.Common.Cloner cloner) {
+      PrinsEncoding clone = new PrinsEncoding(
+        new Permutation(this.PermutationType, this.array), cities, 
+        dueTimeArray, serviceTimeArray, readyTimeArray, demandArray, capacity,
+        fleetUsageFactor, timeFactor, distanceFactor, overloadPenalty, tardinessPenalty,
+        coordinates, useDistanceMatrix);
+
+      cloner.RegisterClonedObject(this, clone);
+      clone.readOnly = readOnly;
+      return clone;
+    }
+
+    public PrinsEncoding(Permutation permutation, int cities,
+      DoubleArray dueTimeArray, DoubleArray serviceTimeArray, DoubleArray readyTimeArray, DoubleArray demandArray, DoubleValue capacity,
+      DoubleValue fleetUsageFactor, DoubleValue timeFactor, DoubleValue distanceFactor, DoubleValue overloadPenalty, DoubleValue tardinessPenalty,
+      DoubleMatrix coordinates, BoolValue useDistanceMatrix)
+      : base(permutation) {
+        this.cities = cities;
+        this.dueTimeArray = dueTimeArray;
+        this.serviceTimeArray = serviceTimeArray;
+        this.readyTimeArray = readyTimeArray;
+        this.demandArray = demandArray;
+        this.capacity = capacity;
+        this.coordinates = coordinates;
+        this.useDistanceMatrix = useDistanceMatrix;
+        this.fleetUsageFactor = fleetUsageFactor;
+        this.timeFactor = timeFactor;
+        this.distanceFactor = distanceFactor;
+        this.overloadPenalty = overloadPenalty;
+        this.tardinessPenalty = tardinessPenalty;
+    }
+
+    [StorableConstructor]
+    private PrinsEncoding(bool serializing)
+      : base(serializing) {
+    }
+
+    public static PrinsEncoding ConvertFrom(IVRPEncoding encoding, int cities,
+      DoubleArray dueTimeArray, DoubleArray serviceTimeArray, DoubleArray readyTimeArray, DoubleArray demandArray, DoubleValue capacity,
+      DoubleValue fleetUsageFactor, DoubleValue timeFactor, DoubleValue distanceFactor, DoubleValue overloadPenalty, DoubleValue tardinessPenalty,
+      DoubleMatrix coordinates, ILookupParameter<DoubleMatrix> distanceMatrix, BoolValue useDistanceMatrix) {
+      List<Tour> tours = encoding.GetTours(distanceMatrix);
+      List<int> route = new List<int>();
+
+      foreach (Tour tour in tours) {
+        foreach (int city in tour.Cities)
+          route.Add(city - 1);
+      }
+
+      return new PrinsEncoding(
+        new Permutation(PermutationTypes.RelativeUndirected, route.ToArray()), cities,
+        dueTimeArray, serviceTimeArray, readyTimeArray, demandArray, capacity,
+        fleetUsageFactor, timeFactor, distanceFactor, overloadPenalty, tardinessPenalty,
+        coordinates, useDistanceMatrix);
+    }
+
+    public static PrinsEncoding ConvertFrom(List<int> routeParam, int cities, 
+      DoubleArray dueTimeArray, DoubleArray serviceTimeArray, DoubleArray readyTimeArray, DoubleArray demandArray, DoubleValue capacity,
+      DoubleValue fleetUsageFactor, DoubleValue timeFactor, DoubleValue distanceFactor, DoubleValue overloadPenalty, DoubleValue tardinessPenalty,
+      DoubleMatrix coordinates, BoolValue useDistanceMatrix) {
+      List<int> route = new List<int>(routeParam);
+
+      while (route.Remove(0)) { //remove all delimiters (0)
+      }
+
+      for (int i = 0; i < route.Count; i++)
+        route[i]--;
+
+      return new PrinsEncoding(
+        new Permutation(PermutationTypes.RelativeUndirected, route.ToArray()), cities, 
+        dueTimeArray, serviceTimeArray, readyTimeArray, demandArray, capacity,
+        fleetUsageFactor, timeFactor, distanceFactor, overloadPenalty, tardinessPenalty,
+        coordinates, useDistanceMatrix);
+    }
+  }
+}
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Evaluators/VRPEvaluator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Evaluators/VRPEvaluator.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Evaluators/VRPEvaluator.cs	(revision 4268)
@@ -101,5 +101,5 @@
       IVRPEncoding vrpSolution = VRPToursParameter.ActualValue;
 
-      return vrpSolution.GetTours().Count;
+      return vrpSolution.GetTours(DistanceMatrixParameter, VehiclesParameter.ActualValue.Value).Count;
     }
 
@@ -178,5 +178,5 @@
     }
 
-    public static TourEvaluation Evaluate(IVRPEncoding solution, DoubleArray dueTimeArray,
+    public static TourEvaluation Evaluate(IVRPEncoding solution, IntValue vehicles, DoubleArray dueTimeArray, 
       DoubleArray serviceTimeArray, DoubleArray readyTimeArray, DoubleArray demandArray, DoubleValue capacity,
       DoubleValue fleetUsageFactor, DoubleValue timeFactor, DoubleValue distanceFactor, DoubleValue overloadPenalty, DoubleValue tardinessPenalty,
@@ -190,5 +190,5 @@
       sumEval.Tardiness = 0;
 
-      foreach (Tour tour in solution.GetTours()) {
+      foreach (Tour tour in solution.GetTours(distanceMatrix)) {
         TourEvaluation eval = EvaluateTour(tour, dueTimeArray, serviceTimeArray, readyTimeArray, demandArray, capacity,
           fleetUsageFactor, timeFactor, distanceFactor, overloadPenalty, tardinessPenalty,
@@ -208,5 +208,5 @@
       IVRPEncoding solution = VRPToursParameter.ActualValue;
 
-      TourEvaluation sumEval = Evaluate(solution, DueTimeParameter.ActualValue, ServiceTimeParameter.ActualValue, ReadyTimeParameter.ActualValue,
+      TourEvaluation sumEval = Evaluate(solution, VehiclesParameter.ActualValue, DueTimeParameter.ActualValue, ServiceTimeParameter.ActualValue, ReadyTimeParameter.ActualValue,
         DemandParameter.ActualValue, CapacityParameter.ActualValue,
         FleetUsageFactor.ActualValue, TimeFactor.ActualValue, DistanceFactor.ActualValue, OverloadPenalty.ActualValue, TardinessPenalty.ActualValue,
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 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLab.Problems.VehicleRouting-3.3.csproj	(revision 4268)
@@ -131,6 +131,7 @@
     <Compile Include="Encodings\Alba\Moves\IntraRouteInversion\IntraRouteInversionMoveMaker.cs" />
     <Compile Include="Encodings\Alba\Moves\IntraRouteInversion\IntraRouteInversionMove.cs" />
+    <Compile Include="Encodings\General\PermutationEncoding.cs" />
     <Compile Include="Encodings\General\Creators\MultiVRPCreator.cs" />
-    <Compile Include="Encodings\General\Crossovers\MultiVRPManipulator.cs" />
+    <Compile Include="Encodings\General\Manipulators\MultiVRPManipulator.cs" />
     <Compile Include="Encodings\General\Crossovers\MultiVRPCrossover.cs" />
     <Compile Include="Encodings\General\Creators\RandomCreator.cs" />
@@ -156,4 +157,13 @@
     <Compile Include="Encodings\Potvin\Manipulators\OneLevelExchangeManipulator.cs" />
     <Compile Include="Encodings\Potvin\Manipulators\PotvinManipulator.cs" />
+    <Compile Include="Encodings\Prins\Crossovers\PrinsCrossover.cs" />
+    <Compile Include="Encodings\Prins\Crossovers\PrinsPermutationCrossover.cs" />
+    <Compile Include="Encodings\Prins\Interfaces\IPrinsOperator.cs" />
+    <Compile Include="Encodings\Prins\Manipulators\PrinsStochasticLSManipulator.cs" />
+    <Compile Include="Encodings\Prins\Manipulators\PrinsExhaustiveLSManipulator.cs" />
+    <Compile Include="Encodings\Prins\Manipulators\PrinsLSManipulator.cs" />
+    <Compile Include="Encodings\Prins\Manipulators\PrinsManipulator.cs" />
+    <Compile Include="Encodings\Prins\Manipulators\PrinsPermutationManipulator.cs" />
+    <Compile Include="Encodings\Prins\PrinsEncoding.cs" />
     <Compile Include="Interfaces\IVRPMoveMaker.cs" />
     <Compile Include="TSPLIBParser.cs" />
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPEncoding.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPEncoding.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPEncoding.cs	(revision 4268)
@@ -23,8 +23,9 @@
 using HeuristicLab.Problems.VehicleRouting.Encodings;
 using System.Collections.Generic;
+using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.VehicleRouting {
   public interface IVRPEncoding : IItem {
-    List<Tour> GetTours();
+    List<Tour> GetTours(ILookupParameter<DoubleMatrix> distanceMatrix, int maxVehicles = int.MaxValue);
   }
 }
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VRPOperator.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VRPOperator.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VRPOperator.cs	(revision 4268)
@@ -139,5 +139,5 @@
       bool feasible = true;
 
-      foreach (Tour tour in solution.GetTours()) {
+      foreach (Tour tour in solution.GetTours(DistanceMatrixParameter)) {
         if (!Feasible(tour)) {
           feasible = false;
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VRPUtilities.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VRPUtilities.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VRPUtilities.cs	(revision 4268)
@@ -60,9 +60,14 @@
 
       if (useDistanceMatrix.Value) {
-        if (distanceMatrix.ActualValue == null) {
-          distanceMatrix.ActualValue = CreateDistanceMatrix(coordinates);
-        }
+        if (distanceMatrix is IValueLookupParameter<DoubleMatrix> &&
+          (distanceMatrix as IValueLookupParameter<DoubleMatrix>).Value != null) {
+            distance = (distanceMatrix as IValueLookupParameter<DoubleMatrix>).Value[start, end];
+        } else {
+          if (distanceMatrix.ActualValue == null) {
+            distanceMatrix.ActualValue = CreateDistanceMatrix(coordinates);
+          }
 
-        distance = distanceMatrix.ActualValue[start, end];
+          distance = distanceMatrix.ActualValue[start, end];
+        }       
       } else {
         distance = CalculateDistance(start, end, coordinates);
Index: /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs
===================================================================
--- /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs	(revision 4267)
+++ /branches/VRP/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs	(revision 4268)
@@ -34,4 +34,5 @@
 using HeuristicLab.Problems.VehicleRouting.Encodings.Alba;
 using HeuristicLab.Problems.VehicleRouting.Encodings.General;
+using HeuristicLab.Problems.VehicleRouting.Encodings.Prins;
 
 namespace HeuristicLab.Problems.VehicleRouting {
@@ -386,4 +387,12 @@
       }
 
+      foreach (IPrinsOperator op in Operators.OfType<IPrinsOperator>()) {
+        op.FleetUsageFactor.ActualName = FleetUsageFactor.Name;
+        op.TimeFactor.ActualName = TimeFactor.Name;
+        op.DistanceFactor.ActualName = DistanceFactor.Name;
+        op.OverloadPenalty.ActualName = OverloadPenalty.Name;
+        op.TardinessPenalty.ActualName = TardinessPenalty.Name;
+      }
+
       foreach (IVRPMoveEvaluator op in Operators.OfType<IVRPMoveEvaluator>()) {
         op.FleetUsageFactor.ActualName = FleetUsageFactor.Name;
