Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestVRPSolutionAnalyzer.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestVRPSolutionAnalyzer.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Analyzers/BestVRPSolutionAnalyzer.cs	(revision 3938)
@@ -0,0 +1,125 @@
+#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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  /// <summary>
+  /// An operator for analyzing the best solution of Vehicle Routing Problems.
+  /// </summary>
+  [Item("BestVRPSolutionAnalyzer", "An operator for analyzing the best solution of Vehicle Routing Problems.")]
+  [StorableClass]
+  public sealed class BestVRPSolutionAnalyzer : SingleSuccessorOperator, IAnalyzer {
+    public ScopeTreeLookupParameter<IVRPEncoding> VRPSolutionParameter {
+      get { return (ScopeTreeLookupParameter<IVRPEncoding>)Parameters["VRPSolution"]; }
+    }
+    public LookupParameter<DoubleMatrix> CoordinatesParameter {
+      get { return (LookupParameter<DoubleMatrix>)Parameters["Coordinates"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> OverloadParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Overload"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> TardinessParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Tardiness"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> DistanceParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Distance"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> TravelTimeParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["TravelTime"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> VehiclesUtilizedParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["VehiclesUtilized"]; }
+    }
+    public LookupParameter<VRPSolution> BestSolutionParameter {
+      get { return (LookupParameter<VRPSolution>)Parameters["BestSolution"]; }
+    }
+    public ValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+
+    public BestVRPSolutionAnalyzer()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<IVRPEncoding>("VRPSolution", "The VRP solutions which should be evaluated."));
+      Parameters.Add(new LookupParameter<DoubleMatrix>("Coordinates", "The x- and y-Coordinates of the cities."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The qualities of the VRP solutions which should be analyzed."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Distance", "The distances of the VRP solutions which should be analyzed."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Overload", "The overloads of the VRP solutions which should be analyzed."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Tardiness", "The tardiness of the VRP solutions which should be analyzed."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("TravelTime", "The travel times of the VRP solutions which should be analyzed."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("VehiclesUtilized", "The utilized vehicles of the VRP solutions which should be analyzed."));
+      Parameters.Add(new LookupParameter<VRPSolution>("BestSolution", "The best TSP solution."));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the best VRP solution should be stored."));
+    }
+
+    public override IOperation Apply() {
+      DoubleMatrix coordinates = CoordinatesParameter.ActualValue;
+      ItemArray<IVRPEncoding> solutions = VRPSolutionParameter.ActualValue;
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
+      ItemArray<DoubleValue> overloads = OverloadParameter.ActualValue;
+      ItemArray<DoubleValue> tardinesses = TardinessParameter.ActualValue;
+      ResultCollection results = ResultsParameter.ActualValue;
+      ItemArray<DoubleValue> distances = DistanceParameter.ActualValue;
+      ItemArray<DoubleValue> travelTimes = TravelTimeParameter.ActualValue;
+      ItemArray<DoubleValue> vehiclesUtilizations = VehiclesUtilizedParameter.ActualValue;
+
+      int i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
+
+      IVRPEncoding best = solutions[i].Clone() as IVRPEncoding;
+      VRPSolution solution = BestSolutionParameter.ActualValue;
+      if (solution == null) {
+        solution = new VRPSolution(coordinates, best.Clone() as IVRPEncoding, new DoubleValue(qualities[i].Value),
+          new DoubleValue(distances[i].Value), new DoubleValue(overloads[i].Value), new DoubleValue(tardinesses[i].Value),
+          new DoubleValue(travelTimes[i].Value), new DoubleValue(vehiclesUtilizations[i].Value));
+        BestSolutionParameter.ActualValue = solution;
+        results.Add(new Result("Best VRP Solution", solution));
+      } else {
+        if (solution.Quality.Value > qualities[i].Value) {
+          solution.Coordinates = coordinates;
+          solution.Solution = best.Clone() as IVRPEncoding;
+          solution.Quality.Value = qualities[i].Value;
+          solution.Distance.Value = distances[i].Value;
+          solution.Overload.Value = overloads[i].Value;
+          solution.Tardiness.Value = tardinesses[i].Value;
+          solution.TravelTime.Value = travelTimes[i].Value;
+          solution.VehicleUtilization.Value = vehiclesUtilizations[i].Value;
+
+          if (solution.Quality.Value < solution.Distance.Value) {
+          }
+        }
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/AlbaEncoding.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/AlbaEncoding.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/AlbaEncoding.cs	(revision 3938)
@@ -0,0 +1,129 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("AlbaEncoding", "Represents an alba encoding of VRP solutions.")]
+  [StorableClass]
+  class AlbaEncoding: Permutation, IVRPEncoding {
+    #region IVRPEncoding Members
+    [Storable]
+    private int cities;
+
+    public override IDeepCloneable Clone(HeuristicLab.Common.Cloner cloner) {
+      AlbaEncoding clone = new AlbaEncoding(
+        new Permutation(this.PermutationType, this.array), cities);
+      cloner.RegisterClonedObject(this, clone);
+      clone.readOnly = readOnly;
+      return clone;
+    }
+
+    public AlbaEncoding(Permutation permutation, int cities): base(PermutationTypes.RelativeDirected) {
+      this.array = new int[permutation.Length];
+      for (int i = 0; i < array.Length; i++)
+        this.array[i] = permutation[i];
+
+      this.cities = cities;
+    }
+
+    [StorableConstructor]
+    private AlbaEncoding(bool serializing)
+      : base() {
+    }
+
+    public ItemList<Tour> Tours {
+      get {
+        ItemList<Tour> result = new ItemList<Tour>();
+        Tour tour = new Tour();
+        tour.Add(new IntValue(0));
+
+        for (int i = 0; i < this.array.Length; i++) {
+          if (this.array[i] >= cities) {
+            if (tour.Count > 1) {
+              tour.Add(new IntValue(0));
+              result.Add(tour);
+
+              tour = new Tour();
+              tour.Add(new IntValue(0));
+            }
+          } else {
+            tour.Add(new IntValue(this.array[i] + 1));
+          }       
+        }
+
+        if (tour.Count > 1) {
+          tour.Add(new IntValue(0));
+          result.Add(tour);
+        }
+
+        return result;
+      }
+    }
+
+    public int Cities {
+      get { return cities; }
+    }
+
+    #endregion
+
+    public static AlbaEncoding ConvertFrom(IVRPEncoding encoding) {
+        ItemList<Tour> tours = encoding.Tours;
+
+        int cities = 0;
+        foreach (Tour tour in tours) {
+          cities += tour.Count;
+        }
+        int[] array = new int[cities + tours.Count - 2];
+        int delimiter = cities;
+        int arrayIndex = 0;
+
+        foreach (Tour tour in tours) {
+          foreach(IntValue city in tour) {
+            array[arrayIndex] = city.Value;
+
+            arrayIndex++;
+          }
+
+          if (arrayIndex != array.Length) {
+            array[arrayIndex] = delimiter;
+            delimiter++;
+            arrayIndex++;
+          }
+        }
+
+      AlbaEncoding solution = new AlbaEncoding(new Permutation(PermutationTypes.RelativeUndirected), cities);
+
+      return solution;
+    }
+
+    
+
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Creators/AlbaPermutationCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Creators/AlbaPermutationCreator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Creators/AlbaPermutationCreator.cs	(revision 3938)
@@ -0,0 +1,105 @@
+﻿#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.Operators;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("AlbaPermutationCreator", "An operator which creates a new alba VRP representation.")]
+  [StorableClass]
+  public sealed class AlbaPermutationCreator : VRPCreator, IStochasticOperator {
+    public IValueLookupParameter<IPermutationCreator> PermutationCreatorParameter {
+      get { return (IValueLookupParameter<IPermutationCreator>)Parameters["PermutationCreatorParameter"]; }
+    }
+
+    #region IStochasticOperator Members
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    #endregion
+    
+    public AlbaPermutationCreator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
+      Parameters.Add(new ValueLookupParameter<IPermutationCreator>("PermutationCreatorParameter", "The permutation creator.", new RandomPermutationCreator()));
+
+      ParameterizeSolutionCreator();
+
+      Initialize();
+    }
+
+    [StorableConstructor]
+    private AlbaPermutationCreator(bool deserializing) : base() { }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      CitiesParameter.ValueChanged += new EventHandler(CitiesParameter_ValueChanged);
+      if(CitiesParameter.Value != null)
+        CitiesParameter.Value.ValueChanged += new EventHandler(CitiesValue_ValueChanged); 
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      AlbaPermutationCreator clone = (AlbaPermutationCreator)base.Clone(cloner);
+      clone.Initialize();
+      return clone;
+    }
+
+    void CitiesParameter_ValueChanged(object sender, EventArgs e) {
+      CitiesParameter.Value.ValueChanged += new EventHandler(CitiesValue_ValueChanged);
+      
+      ParameterizeSolutionCreator();
+    }
+
+    void CitiesValue_ValueChanged(object sender, EventArgs e) {
+      ParameterizeSolutionCreator();
+    }
+
+    private void ParameterizeSolutionCreator() {
+      PermutationCreatorParameter.Value.LengthParameter.Value = CitiesParameter.Value;
+      PermutationCreatorParameter.Value.PermutationTypeParameter.Value = new PermutationType(PermutationTypes.RelativeUndirected);
+    }
+
+    public override IOperation Apply() {
+      PermutationCreatorParameter.Value.LengthParameter.Value = new IntValue(CitiesParameter.Value.Value + VehiclesParameter.ActualValue.Value - 1);
+
+      IPermutationCreator creator = PermutationCreatorParameter.ActualValue;
+      IAtomicOperation op = this.ExecutionContext.CreateOperation(creator);
+      op.Operator.Execute((IExecutionContext)op);
+
+      Permutation permutation = ExecutionContext.Scope.Variables["Permutation"].Value as Permutation;
+      ExecutionContext.Scope.Variables.Remove("Permutation");
+
+      VRPSolutionParameter.ActualValue = new AlbaEncoding(permutation, CitiesParameter.ActualValue.Value);
+
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Creators/AlbaPushForwardInsertionCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Creators/AlbaPushForwardInsertionCreator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Creators/AlbaPushForwardInsertionCreator.cs	(revision 3938)
@@ -0,0 +1,296 @@
+﻿#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.Operators;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("AlbaPushForwardCreator", "An operator which creates a new alba VRP representation using the push forward insertion heuristic.")]
+  [StorableClass]
+  public sealed class AlbaPushForwardCreator : VRPCreator, IStochasticOperator {
+    #region IStochasticOperator Members
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    #endregion
+
+    public IValueParameter<DoubleValue> Alpha {
+      get { return (IValueParameter<DoubleValue>)Parameters["Alpha"]; }
+    }
+    public IValueParameter<DoubleValue> AlphaVariance {
+      get { return (IValueParameter<DoubleValue>)Parameters["AlphaVariance"]; }
+    }
+    public IValueParameter<DoubleValue> Beta {
+      get { return (IValueParameter<DoubleValue>)Parameters["Beta"]; }
+    }
+    public IValueParameter<DoubleValue> BetaVariance {
+      get { return (IValueParameter<DoubleValue>)Parameters["BetaVariance"]; }
+    }
+    public IValueParameter<DoubleValue> Gamma {
+      get { return (IValueParameter<DoubleValue>)Parameters["Gamma"]; }
+    }
+    public IValueParameter<DoubleValue> GammaVariance {
+      get { return (IValueParameter<DoubleValue>)Parameters["GammaVariance"]; }
+    }
+
+    public AlbaPushForwardCreator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
+      Parameters.Add(new ValueParameter<DoubleValue>("Alpha", "The alpha value.", new DoubleValue(0.7)));
+      Parameters.Add(new ValueParameter<DoubleValue>("AlphaVariance", "The alpha variance.", new DoubleValue(0.5)));
+      Parameters.Add(new ValueParameter<DoubleValue>("Beta", "The beta value.", new DoubleValue(0.1)));
+      Parameters.Add(new ValueParameter<DoubleValue>("BetaVariance", "The beta variance.", new DoubleValue(0.07)));
+      Parameters.Add(new ValueParameter<DoubleValue>("Gamma", "The gamma value.", new DoubleValue(0.2)));
+      Parameters.Add(new ValueParameter<DoubleValue>("GammaVariance", "The gamma variance.", new DoubleValue(0.14)));
+    }
+
+    public override IOperation Apply() {
+      VRPSolutionParameter.ActualValue = new AlbaEncoding(CreateSolution(), CitiesParameter.ActualValue.Value);
+
+      return base.Apply();
+    }
+
+    // use the Box-Mueller transform in the polar form to generate a N(0,1) random variable out of two uniformly distributed random variables
+    private double Gauss(IRandom random) {
+      double u = 0.0, v = 0.0, s = 0.0;
+      do {
+        u = (random.NextDouble() * 2) - 1;
+        v = (random.NextDouble() * 2) - 1;
+        s = Math.Sqrt(u * u + v * v);
+      } while (s < Double.Epsilon || s > 1);
+      return u * Math.Sqrt((-2.0 * Math.Log(s)) / s);
+    }
+
+    private double N(double mu, double sigma, IRandom random) {
+      return mu + (sigma * Gauss(random)); // transform the random variable sampled from N(0,1) to N(mu,sigma)
+    }
+
+    private double CalculateDistance(int start, int end) {
+      double distance = 0.0;
+      DoubleMatrix coordinates = CoordinatesParameter.ActualValue;
+
+      distance =
+          Math.Sqrt(
+            Math.Pow(coordinates[start, 0] - coordinates[end, 0], 2) +
+            Math.Pow(coordinates[start, 1] - coordinates[end, 1], 2));
+
+      return distance;
+    }
+
+    private DoubleMatrix CreateDistanceMatrix() {
+      DoubleMatrix coordinates = CoordinatesParameter.ActualValue;
+      DoubleMatrix distanceMatrix = new DoubleMatrix(coordinates.Rows, coordinates.Rows);
+
+      for (int i = 0; i < distanceMatrix.Rows; i++) {
+        for (int j = i; j < distanceMatrix.Columns; j++) {
+          double distance = CalculateDistance(i, j);
+
+          distanceMatrix[i, j] = distance;
+          distanceMatrix[j, i] = distance;
+        }
+      }
+
+      return distanceMatrix;
+    }
+
+    private double Distance(int start, int end) {
+      double distance = 0.0;
+
+      if (UseDistanceMatrixParameter.ActualValue.Value) {
+        if (DistanceMatrixParameter.ActualValue == null) {
+          DistanceMatrixParameter.ActualValue = CreateDistanceMatrix();
+        }
+
+        distance = DistanceMatrixParameter.ActualValue[start, end];
+      } else {
+        distance = CalculateDistance(start, end);
+      }
+
+      return distance;
+    }
+
+    private double TravelDistance(List<int> route, int begin) {
+      double distance = 0;
+      for (int i = begin; i < route.Count - 1 && (i == begin || route[i] != 0); i++) {
+        distance += Distance(route[i], route[i + 1]);
+      }
+      return distance;
+    }
+
+    private bool SubrouteConstraintsOK(List<int> route, int begin) {
+      double t = 0.0, o = 0.0;
+      for (int i = begin + 1; i < route.Count; i++) {
+        t += Distance(route[i - 1], route[i]);
+        if (route[i] == 0) return (t < DueTimeParameter.ActualValue[0]); // violation on capacity constraint is handled below
+        else {
+          if (t > DueTimeParameter.ActualValue[route[i]]) return false;
+          t = Math.Max(ReadyTimeParameter.ActualValue[route[i]], t);
+          t += ServiceTimeParameter.ActualValue[route[i]];
+          o += DemandParameter.ActualValue[route[i]];
+          if (o > CapacityParameter.ActualValue.Value) return false; // premature exit on capacity constraint violation
+        }
+      }
+      return true;
+    }
+
+    private bool SubrouteTardinessOK(List<int> route, int begin) {
+      double t = 0.0;
+      for (int i = begin + 1; i < route.Count; i++) {
+        t += Distance(route[i - 1], route[i]);
+        if (route[i] == 0) {
+          if (t < DueTimeParameter.ActualValue[0]) return true;
+          else return false;
+        } else {
+          if (t > DueTimeParameter.ActualValue[route[i]]) return false;
+          t = Math.Max(ReadyTimeParameter.ActualValue[route[i]], t);
+          t += ServiceTimeParameter.ActualValue[route[i]];
+        }
+      }
+      return true;
+    }
+
+    private bool SubrouteLoadOK(List<int> route, int begin) {
+      double o = 0.0;
+      for (int i = begin + 1; i < route.Count; i++) {
+        if (route[i] == 0) return (o < CapacityParameter.ActualValue.Value);
+        else {
+          o += DemandParameter.ActualValue[route[i]];
+        }
+      }
+      return (o < CapacityParameter.ActualValue.Value);
+    }
+
+    private Permutation CreateSolution() {
+      double alpha, beta, gamma;
+      alpha = N(Alpha.Value.Value, Math.Sqrt(AlphaVariance.Value.Value), RandomParameter.ActualValue);
+      beta = N(Beta.Value.Value, Math.Sqrt(BetaVariance.Value.Value), RandomParameter.ActualValue);
+      gamma = N(Gamma.Value.Value, Math.Sqrt(GammaVariance.Value.Value), RandomParameter.ActualValue);
+
+      double x0 = CoordinatesParameter.ActualValue[0,0];
+      double y0 = CoordinatesParameter.ActualValue[0,1];
+      double distance = 0;
+      double cost = 0;
+      double minimumCost = double.MaxValue;
+      List<int> unroutedList = new List<int>();
+      List<double> costList = new List<double>();
+      int index;
+      int indexOfMinimumCost = -1;
+      int indexOfCustomer = -1;
+
+      /*-----------------------------------------------------------------------------
+       * generate cost list
+       *-----------------------------------------------------------------------------
+       */
+      for (int i = 1; i <= CitiesParameter.ActualValue.Value; i++) {
+        distance = Distance(i, 0);
+        if (CoordinatesParameter.ActualValue[i,0] < x0) distance = -distance;
+        cost = -alpha * distance + // distance 0 <-> City[i]
+                 beta * (DueTimeParameter.ActualValue[i]) + // latest arrival time
+                 gamma * (Math.Asin((CoordinatesParameter.ActualValue[i,1] - y0) / distance) / 360 * distance); // polar angle
+
+        index = 0;
+        while (index < costList.Count && costList[index] < cost) index++;
+        costList.Insert(index, cost);
+        unroutedList.Insert(index, i);
+      }
+
+      /*------------------------------------------------------------------------------
+       * route customers according to cost list
+       *------------------------------------------------------------------------------
+       */
+      int routeIndex = 0;
+      int currentRoute = 0;
+      int c;
+      int customer = -1;
+      int subTourCount = 1;
+      List<int> route = new List<int>(CitiesParameter.ActualValue.Value + VehiclesParameter.ActualValue.Value - 1);
+      minimumCost = double.MaxValue;
+      indexOfMinimumCost = -1;
+      route.Add(0);
+      route.Add(0);
+      route.Insert(1, unroutedList[0]);
+      unroutedList.RemoveAt(0);
+      currentRoute = routeIndex;
+      routeIndex++;
+
+      do {
+        for (c = 0; c < unroutedList.Count; c++) {
+          for (int i = currentRoute + 1; i < route.Count; i++) {
+            route.Insert(i, (int)unroutedList[c]);
+            if (route[currentRoute] != 0) { throw new Exception("currentRoute not depot"); }
+            cost = TravelDistance(route, currentRoute);
+            if (cost < minimumCost && SubrouteConstraintsOK(route, currentRoute)) {
+              minimumCost = cost;
+              indexOfMinimumCost = i;
+              customer = (int)unroutedList[c];
+              indexOfCustomer = c;
+            }
+            route.RemoveAt(i);
+          }
+        }
+        // insert customer if found
+        if (indexOfMinimumCost != -1) {
+          route.Insert(indexOfMinimumCost, customer);
+          routeIndex++;
+          unroutedList.RemoveAt(indexOfCustomer);
+          costList.RemoveAt(indexOfCustomer);
+        } else { // no feasible customer found
+          routeIndex++;
+          route.Insert(routeIndex, 0);
+          currentRoute = routeIndex;
+          route.Insert(route.Count - 1, (int)unroutedList[0]);
+          unroutedList.RemoveAt(0);
+          routeIndex++;
+          subTourCount++;
+        }
+        // reset minimum		
+        minimumCost = double.MaxValue;
+        indexOfMinimumCost = -1;
+        indexOfCustomer = -1;
+        customer = -1;
+      } while (unroutedList.Count > 0);
+      while (route.Count < CitiesParameter.ActualValue.Value + VehiclesParameter.ActualValue.Value - 1)
+        route.Add(0);
+
+      int vehicle = CitiesParameter.ActualValue.Value;
+      for (int i = 0; i < route.Count; i++) {
+        if (route[i] == 0) {
+          route[i] = vehicle;
+          vehicle++;
+        } else {
+          route[i] = route[i] - 1;
+        }
+      }
+
+      return new Permutation(PermutationTypes.RelativeDirected, route.ToArray());
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaPermutationCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaPermutationCrossover.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaPermutationCrossover.cs	(revision 3938)
@@ -0,0 +1,71 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("AlbaPermutationCrossover", "An operator which crosses two alba VRP representations.")]
+  [StorableClass]
+  public sealed class AlbaPermutationCrossover : VRPCrossover {
+    public IValueLookupParameter<IPermutationCrossover> PermutationCrossoverParameter {
+      get { return (IValueLookupParameter<IPermutationCrossover>)Parameters["PermutationCrossover"]; }
+    }
+
+    public AlbaPermutationCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IPermutationCrossover>("PermutationCrossover", "The permutation crossover.", new EdgeRecombinationCrossover()));
+    }
+
+    public override IOperation Apply() {
+      int cities = 0;
+
+      for(int i = 0; i < ParentsParameter.ActualValue.Length; i++) {
+         IVRPEncoding solution = ParentsParameter.ActualValue[i];
+         cities = solution.Cities;
+        if (!(solution is AlbaEncoding)) {
+          ParentsParameter.ActualValue[i] = AlbaEncoding.ConvertFrom(solution);
+        }
+      }
+
+      PermutationCrossoverParameter.ActualValue.ParentsParameter.ActualName = ParentsParameter.ActualName;
+      IAtomicOperation op = this.ExecutionContext.CreateOperation(PermutationCrossoverParameter.ActualValue);
+      op.Operator.Execute((IExecutionContext)op);
+
+      if (ExecutionContext.Scope.Variables.ContainsKey("Permutation")) {
+        Permutation permutation = ExecutionContext.Scope.Variables["Permutation"].Value as Permutation;
+        ExecutionContext.Scope.Variables.Remove("Permutation");
+
+        ChildParameter.ActualValue = new AlbaEncoding(permutation, cities);
+      } else
+        ChildParameter.ActualValue = null;
+
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaPermutationManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaPermutationManipulator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaPermutationManipulator.cs	(revision 3938)
@@ -0,0 +1,59 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("AlbaPermutationManipulator", "An operator which manipulates an alba VRP representation.")]
+  [StorableClass]
+  public sealed class AlbaPermutationManipulator : VRPManipulator {
+    public IValueLookupParameter<IPermutationManipulator> PermutationManipulatorParameter {
+      get { return (IValueLookupParameter<IPermutationManipulator>)Parameters["PermutationManipulator"]; }
+    }
+
+    public AlbaPermutationManipulator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IPermutationManipulator>("PermutationManipulator", "The permutation manipulator.", new TranslocationManipulator()));
+    }
+
+    public override IOperation Apply() {
+      IVRPEncoding solution = VRPSolutionParameter.ActualValue;
+      if (!(solution is AlbaEncoding)) {
+        VRPSolutionParameter.ActualValue = AlbaEncoding.ConvertFrom(solution);
+      }
+
+      OperationCollection next = new OperationCollection(base.Apply());
+      IPermutationManipulator op = PermutationManipulatorParameter.ActualValue;
+      if (op != null) {
+        op.PermutationParameter.ActualName = VRPSolutionParameter.ActualName;
+        next.Insert(0, ExecutionContext.CreateOperation(op));
+      }
+      return next;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/AlbaMoveMaker.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/AlbaMoveMaker.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/AlbaMoveMaker.cs	(revision 3938)
@@ -0,0 +1,96 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("AlbaTranslocationMoveMaker", "An operator which makes translocation moves for the alba representation.")]
+  [StorableClass]
+  public abstract class AlbaMoveMaker : AlbaMoveOperator {
+    public ILookupParameter<DoubleValue> MoveVehcilesUtilizedParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveVehiclesUtilized"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveTravelTimeParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveTravelTime"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveDistanceParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveDistance"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveOverloadParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveOverload"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveTardinessParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveTardiness"]; }
+    }
+
+    public ILookupParameter<DoubleValue> VehcilesUtilizedParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["VehiclesUtilized"]; }
+    }
+    public ILookupParameter<DoubleValue> TravelTimeParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["TravelTime"]; }
+    }
+    public ILookupParameter<DoubleValue> DistanceParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Distance"]; }
+    }
+    public ILookupParameter<DoubleValue> OverloadParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Overload"]; }
+    }
+    public ILookupParameter<DoubleValue> TardinessParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Tardiness"]; }
+    }
+
+    public AlbaMoveMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveVehiclesUtilized", "The number of vehicles utilized."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveTravelTime", "The total travel time."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveDistance", "The distance."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveOverload", "The overload."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveTardiness", "The tardiness."));
+
+      Parameters.Add(new LookupParameter<DoubleValue>("VehiclesUtilized", "The number of vehicles utilized."));
+      Parameters.Add(new LookupParameter<DoubleValue>("TravelTime", "The total travel time."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Distance", "The distance."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Overload", "The overload."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Tardiness", "The tardiness."));
+    }
+
+    public override IOperation Apply() {
+      IOperation successor = base.Apply();
+
+      VehcilesUtilizedParameter.ActualValue = MoveVehcilesUtilizedParameter.ActualValue;
+      TravelTimeParameter.ActualValue = MoveTravelTimeParameter.ActualValue;
+      DistanceParameter.ActualValue = MoveDistanceParameter.ActualValue;
+      OverloadParameter.ActualValue = MoveOverloadParameter.ActualValue;
+      TardinessParameter.ActualValue = MoveTardinessParameter.ActualValue;
+
+      return successor;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/AlbaMoveOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/AlbaMoveOperator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/AlbaMoveOperator.cs	(revision 3938)
@@ -0,0 +1,51 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("AlbaMoveOperator", "A move operator for an alba VRP representation.")]
+  [StorableClass]
+  public abstract class AlbaMoveOperator : VRPMoveOperator {
+    [Storable]
+    protected abstract IPermutationMoveOperator PermutationMoveOperatorParameter { get; set; }
+    
+    public override IOperation Apply() {
+      IVRPEncoding solution = VRPSolutionParameter.ActualValue;
+      if (!(solution is AlbaEncoding)) {
+        VRPSolutionParameter.ActualValue = AlbaEncoding.ConvertFrom(solution);
+      }
+
+      PermutationMoveOperatorParameter.PermutationParameter.ActualName = VRPSolutionParameter.ActualName;
+      IAtomicOperation op = this.ExecutionContext.CreateOperation(PermutationMoveOperatorParameter);
+      op.Operator.Execute((IExecutionContext)op);
+
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveEvaluator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveEvaluator.cs	(revision 3938)
@@ -0,0 +1,61 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Problems.VehicleRouting.Encodings.Alba;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  [Item("AlbaTranslocationMoveEvaluator", "Evaluates a translocation or insertion move (3-opt) for the VRP.")]
+  [StorableClass]
+  public sealed class AlbaTranslocationMoveEvaluator: VRPMoveEvaluator {
+    public ILookupParameter<TranslocationMove> TranslocationMoveParameter {
+      get { return (ILookupParameter<TranslocationMove>)Parameters["TranslocationMove"]; }
+      set { Parameters["TranslocationMove"].ActualValue = value.ActualValue; }
+    }
+
+    public AlbaTranslocationMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<TranslocationMove>("TranslocationMove", "The move to evaluate."));
+    }
+
+    protected override TourEvaluation GetMoveQuality() {
+      TranslocationMove move = TranslocationMoveParameter.ActualValue;
+      //perform move
+      AlbaEncoding newSolution = VRPSolutionParameter.ActualValue.Clone() as AlbaEncoding;
+      TranslocationManipulator.Apply(newSolution, move.Index1, move.Index2, move.Index3);
+
+      return VRPEvaluator.Evaluate(
+        newSolution,
+        DueTimeParameter.ActualValue, ServiceTimeParameter.ActualValue, ReadyTimeParameter.ActualValue,
+        DemandParameter.ActualValue, CapacityParameter.ActualValue, 
+        FleetUsageFactor.Value, TimeFactor.Value, DistanceFactor.Value, OverloadPenalty.Value, TardinessPenalty.Value,
+        CoordinatesParameter.ActualValue, DistanceMatrixParameter, UseDistanceMatrixParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveGenerator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveGenerator.cs	(revision 3938)
@@ -0,0 +1,108 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("AlbaTranslocationMoveGenerator", "An operator which generates translocation moves for the alba representation.")]
+  [StorableClass]
+  public sealed class AlbaTranslocationMoveGenerator : AlbaMoveOperator, IPermutationTranslocationMoveOperator, IMoveGenerator {
+    public IValueLookupParameter<TranslocationMoveGenerator> TranslocationMoveGeneratorParameter {
+      get { return (IValueLookupParameter<TranslocationMoveGenerator>)Parameters["TranslocationMoveGenerator"]; }
+    }
+
+    protected override IPermutationMoveOperator PermutationMoveOperatorParameter {
+      get { return TranslocationMoveGeneratorParameter.Value; }
+      set { TranslocationMoveGeneratorParameter.Value = value as TranslocationMoveGenerator; }
+    }
+
+    public ILookupParameter<TranslocationMove> TranslocationMoveParameter {
+      get {
+        if (TranslocationMoveGeneratorParameter.Value != null)
+          return TranslocationMoveGeneratorParameter.Value.TranslocationMoveParameter;
+        else
+          return null;
+      }
+    }
+
+    public ILookupParameter<Permutation> PermutationParameter {
+      get {
+        if (TranslocationMoveGeneratorParameter.Value != null)
+          return TranslocationMoveGeneratorParameter.Value.PermutationParameter;
+        else
+          return null;
+      }
+    }
+
+    public AlbaTranslocationMoveGenerator(): base() {
+      Parameters.Add(new ValueLookupParameter<TranslocationMoveGenerator>("TranslocationMoveGenerator", "The move generator.", 
+        new StochasticTranslocationMultiMoveGenerator()));
+    }
+
+    public override IOperation Apply() {
+      IOperation successor = base.Apply();
+
+      Permutation permutation = VRPSolutionParameter.ActualValue as Permutation;
+      string moveName = TranslocationMoveGeneratorParameter.ActualValue.TranslocationMoveParameter.Name;
+
+      List<Scope> toBeDeleted = new List<Scope>();
+      foreach (Scope scope in this.ExecutionContext.Scope.SubScopes) {
+        if (scope.Variables.ContainsKey(moveName)) {
+          TranslocationMove move = scope.Variables[moveName].Value as TranslocationMove;
+
+          if (move != null) {
+            bool criteria1 = true;
+            if(move.Index1 - 1 >= 0 && 
+              move.Index3 -1 >= 0)
+              criteria1 = (permutation[move.Index1] >= 100 &&
+                permutation[move.Index1 - 1] >= 100 &&
+                permutation[move.Index3 - 1] >= 100);
+
+            int index3 = move.Index3 + (move.Index2 - move.Index1) + 1;
+            bool criteria2 = true;
+            if (move.Index2 + 1 < permutation.Length &&
+              index3 < permutation.Length)
+              criteria2 = (permutation[move.Index2] >= 100 &&
+                permutation[move.Index2 + 1] >= 100 &&
+                permutation[index3] >= 100);
+
+            if(criteria1 && criteria2)
+              toBeDeleted.Add(scope);
+          }
+        }
+      }
+
+      foreach (Scope scope in toBeDeleted) {
+        this.ExecutionContext.Scope.SubScopes.Remove(scope);
+      }
+
+      return successor;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveHardTabuCriterion.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveHardTabuCriterion.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveHardTabuCriterion.cs	(revision 3938)
@@ -0,0 +1,68 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("AlbaTranslocationMoveHardTabuCriterion", "An operator which checks if translocation moves are tabu using a hard criterion.")]
+  [StorableClass]
+  public sealed class AlbaTranslocationMoveHardTabuCriterion : AlbaMoveOperator, IPermutationTranslocationMoveOperator, ITabuChecker {
+    private TranslocationMoveHardTabuCriterion tabuChecker;
+    protected override IPermutationMoveOperator PermutationMoveOperatorParameter {
+      get { return tabuChecker; }
+      set { tabuChecker = value as TranslocationMoveHardTabuCriterion; }
+    }
+
+    public ILookupParameter<TranslocationMove> TranslocationMoveParameter {
+      get { return tabuChecker.TranslocationMoveParameter; }
+    }
+
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return tabuChecker.PermutationParameter; }
+    }
+
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return tabuChecker.MoveTabuParameter; }
+    }
+
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return tabuChecker.MoveQualityParameter; }
+    }
+
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return tabuChecker.MaximizationParameter; }
+    }
+
+    public AlbaTranslocationMoveHardTabuCriterion()
+      : base() {
+      tabuChecker = new TranslocationMoveHardTabuCriterion();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveMaker.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveMaker.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveMaker.cs	(revision 3938)
@@ -0,0 +1,63 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("AlbaTranslocationMoveMaker", "An operator which makes translocation moves for the alba representation.")]
+  [StorableClass]
+  public sealed class AlbaTranslocationMoveMaker : AlbaMoveMaker, IPermutationTranslocationMoveOperator, IMoveMaker {
+    private TranslocationMoveMaker moveMaker;
+    protected override IPermutationMoveOperator PermutationMoveOperatorParameter {
+      get { return moveMaker; }
+      set { moveMaker = value as TranslocationMoveMaker; }
+    }
+
+    public ILookupParameter<TranslocationMove> TranslocationMoveParameter {
+      get { return moveMaker.TranslocationMoveParameter; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return moveMaker.QualityParameter; }
+    }
+
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return moveMaker.MoveQualityParameter; }
+    }
+
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return moveMaker.PermutationParameter; }
+    }
+
+    public AlbaTranslocationMoveMaker(): base() {
+      moveMaker = new TranslocationMoveMaker();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveSoftTabuCriterion.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveSoftTabuCriterion.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveSoftTabuCriterion.cs	(revision 3938)
@@ -0,0 +1,68 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("AlbaTranslocationMoveSoftTabuCriterion", "An operator which checks if translocation moves are tabu using a soft criterion.")]
+  [StorableClass]
+  public sealed class AlbaTranslocationMoveSoftTabuCriterion : AlbaMoveOperator, IPermutationTranslocationMoveOperator, ITabuChecker {
+    private TranslocationMoveSoftTabuCriterion tabuChecker;
+    protected override IPermutationMoveOperator PermutationMoveOperatorParameter {
+      get { return tabuChecker; }
+      set { tabuChecker = value as TranslocationMoveSoftTabuCriterion; }
+    }
+
+    public ILookupParameter<TranslocationMove> TranslocationMoveParameter {
+      get { return tabuChecker.TranslocationMoveParameter; }
+    }
+
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return tabuChecker.PermutationParameter; }
+    }
+
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return tabuChecker.MoveTabuParameter; }
+    }
+
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return tabuChecker.MoveQualityParameter; }
+    }
+
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return tabuChecker.MaximizationParameter; }
+    }
+
+    public AlbaTranslocationMoveSoftTabuCriterion()
+      : base() {
+      tabuChecker = new TranslocationMoveSoftTabuCriterion();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveTabuMaker.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveTabuMaker.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveTabuMaker.cs	(revision 3938)
@@ -0,0 +1,68 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("AlbaTranslocationMoveTabuMaker", "An operator which makes translocation moves tabu for the alba representation.")]
+  [StorableClass]
+  public sealed class AlbaTranslocationMoveTabuMaker : AlbaMoveOperator, IPermutationTranslocationMoveOperator, ITabuMaker {
+    private TranslocationMoveTabuMaker moveTabuMaker;
+    protected override IPermutationMoveOperator PermutationMoveOperatorParameter {
+      get { return moveTabuMaker; }
+      set { moveTabuMaker = value as TranslocationMoveTabuMaker; }
+    }
+
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return moveTabuMaker.PermutationParameter; }
+    }
+
+    public ILookupParameter<TranslocationMove> TranslocationMoveParameter {
+      get { return moveTabuMaker.TranslocationMoveParameter; }
+    }
+
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return moveTabuMaker.MoveQualityParameter; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return moveTabuMaker.QualityParameter; }
+    }
+
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return moveTabuMaker.MaximizationParameter; }
+    }
+
+    public AlbaTranslocationMoveTabuMaker()
+      : base() {
+      moveTabuMaker = new TranslocationMoveTabuMaker();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Tour.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Tour.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Tour.cs	(revision 3938)
@@ -0,0 +1,32 @@
+﻿#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.Data;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings {
+  public class Tour : ItemList<IntValue> {
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPCreator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPCreator.cs	(revision 3938)
@@ -0,0 +1,92 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Operators;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  [StorableClass]
+  public abstract class VRPCreator : SingleSuccessorOperator, IVRPCreator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    
+    #region IVRPCreator Members
+    public IValueLookupParameter<IntValue> CitiesParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Cities"]; }
+    }
+    public ILookupParameter<IVRPEncoding> VRPSolutionParameter {
+      get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPSolution"]; }
+    }
+    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"]; }
+    }
+
+    public VRPCreator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IntValue>("Cities", "The city count."));
+      Parameters.Add(new LookupParameter<IntValue>("Vehicles", "The vehicles 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<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."));
+
+      Parameters.Add(new LookupParameter<IVRPEncoding>("VRPSolution", "The new VRP solution."));
+    }
+
+    #endregion
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPCrossover.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPCrossover.cs	(revision 3938)
@@ -0,0 +1,54 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings {
+  public abstract class VRPCrossover: SingleSuccessorOperator, IVRPCrossover {
+    #region IVRPCrossover Members
+
+    public ILookupParameter<ItemArray<IVRPEncoding>> ParentsParameter {
+      get { return (ScopeTreeLookupParameter<IVRPEncoding>)Parameters["Parents"]; }
+    }
+
+    public ILookupParameter<IVRPEncoding> ChildParameter {
+      get { return (ILookupParameter<IVRPEncoding>)Parameters["Child"]; }
+    }
+
+    #endregion
+
+    public VRPCrossover()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<IVRPEncoding>("Parents", "The parent permutations which should be crossed."));
+      ParentsParameter.ActualName = "VRPSolution";
+      Parameters.Add(new LookupParameter<IVRPEncoding>("Child", "The child permutation resulting from the crossover."));
+      ChildParameter.ActualName = "VRPSolution";
+      Parameters.Add(new ValueLookupParameter<IntValue>("Cities", "The city count."));
+    } 
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPManipulator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPManipulator.cs	(revision 3938)
@@ -0,0 +1,45 @@
+﻿#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.Operators;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings {
+  public abstract class VRPManipulator: SingleSuccessorOperator, IVRPManipulator {
+    #region IVRPManipulator Members
+
+    public ILookupParameter<IVRPEncoding> VRPSolutionParameter {
+      get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPSolution"]; }
+    }
+
+    #endregion
+
+    public VRPManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<IVRPEncoding>("VRPSolution", "The new VRP solution."));
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPMoveOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPMoveOperator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/VRPMoveOperator.cs	(revision 3938)
@@ -0,0 +1,45 @@
+﻿#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.Operators;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings {
+  public abstract class VRPMoveOperator: SingleSuccessorOperator, IVRPMoveOperator {
+    #region IVRPManipulator Members
+
+    public ILookupParameter<IVRPEncoding> VRPSolutionParameter {
+      get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPSolution"]; }
+    }
+
+    #endregion
+
+    public VRPMoveOperator()
+      : base() {
+      Parameters.Add(new LookupParameter<IVRPEncoding>("VRPSolution", "The VRP solution."));
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Evaluators/VRPEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Evaluators/VRPEvaluator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Evaluators/VRPEvaluator.cs	(revision 3938)
@@ -0,0 +1,315 @@
+﻿#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.Operators;
+using HeuristicLab.Data;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Encodings;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  public struct TourEvaluation {
+    public double Quality { get; set; }
+    public double VehcilesUtilized { get; set; }
+    public double TravelTime { get; set; }
+    public double Distance { get; set; }
+    public double Overload { get; set; }
+    public double Tardiness { get; set; }
+  }
+  
+  [Item("VRPEvaluator", "Evaluates solutions for the VRP problem.")]
+  [StorableClass]
+  public sealed class VRPEvaluator : SingleSuccessorOperator, IVRPEvaluator {
+    #region ISingleObjectiveEvaluator Members
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    #endregion
+
+    public ILookupParameter<DoubleValue> VehcilesUtilizedParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["VehiclesUtilized"]; }
+    }
+    public ILookupParameter<DoubleValue> TravelTimeParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["TravelTime"]; }
+    }
+    public ILookupParameter<DoubleValue> DistanceParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Distance"]; }
+    }
+    public ILookupParameter<DoubleValue> OverloadParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Overload"]; }
+    }
+    public ILookupParameter<DoubleValue> TardinessParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Tardiness"]; }
+    }
+
+    public ILookupParameter<IVRPEncoding> VRPSolutionParameter {
+      get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPSolution"]; }
+    }
+    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<DoubleValue> MaxTravelTimeParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MaxTravelTime"]; }
+    } */
+    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"]; }
+    }
+    public IValueParameter<DoubleValue> FleetUsageFactor {
+      get { return (IValueParameter<DoubleValue>)Parameters["FleetUsageFactor"]; }
+    }
+    public IValueParameter<DoubleValue> TimeFactor {
+      get { return (IValueParameter<DoubleValue>)Parameters["TimeFactor"]; }
+    }
+    public IValueParameter<DoubleValue> DistanceFactor {
+      get { return (IValueParameter<DoubleValue>)Parameters["DistanceFactor"]; }
+    }
+    /*public IValueParameter<DoubleValue> TimePenalty {
+      get { return (IValueParameter<DoubleValue>)Parameters["TimePenalty"]; }
+    } */
+    public IValueParameter<DoubleValue> OverloadPenalty {
+      get { return (IValueParameter<DoubleValue>)Parameters["OverloadPenalty"]; }
+    }
+    public IValueParameter<DoubleValue> TardinessPenalty {
+      get { return (IValueParameter<DoubleValue>)Parameters["TardinessPenalty"]; }
+    }
+
+    public VRPEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The evaluated quality of the VRP solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>("VehiclesUtilized", "The number of vehicles utilized."));
+      Parameters.Add(new LookupParameter<DoubleValue>("TravelTime", "The total travel time."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Distance", "The distance."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Overload", "The overload."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Tardiness", "The tardiness."));
+      Parameters.Add(new LookupParameter<IVRPEncoding>("VRPSolution", "The VRP solution which should be evaluated."));
+      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<DoubleValue>("MaxTravelTime", "The maximum travel time of each route."));
+      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."));
+      Parameters.Add(new ValueParameter<DoubleValue>("FleetUsageFactor", "The fleet usage factor considered in the evaluation.", new DoubleValue(0)));
+      Parameters.Add(new ValueParameter<DoubleValue>("TimeFactor", "The time factor considered in the evaluation.", new DoubleValue(0)));
+      Parameters.Add(new ValueParameter<DoubleValue>("DistanceFactor", "The distance factor considered in the evaluation.", new DoubleValue(1)));
+      //Parameters.Add(new ValueParameter<DoubleValue>("TimePenalty", "The time penalty considered in the evaluation.", new DoubleValue(10)));
+      Parameters.Add(new ValueParameter<DoubleValue>("OverloadPenalty", "The overload penalty considered in the evaluation.", new DoubleValue(50)));
+      Parameters.Add(new ValueParameter<DoubleValue>("TardinessPenalty", "The tardiness penalty considered in the evaluation.", new DoubleValue(50)));
+    }
+
+    private double CalculateFleetUsage() {
+      IVRPEncoding vrpSolution = VRPSolutionParameter.ActualValue;
+
+      return vrpSolution.Tours.Count;
+    }
+
+    private static double CalculateDistance(int start, int end, DoubleMatrix coordinates) {
+      double distance = 0.0;
+
+      distance =
+          Math.Sqrt(
+            Math.Pow(coordinates[start, 0] - coordinates[end, 0], 2) +
+            Math.Pow(coordinates[start, 1] - coordinates[end, 1], 2));
+
+      return distance;
+    }
+
+    private static DoubleMatrix CreateDistanceMatrix(DoubleMatrix coordinates) 
+    {
+      DoubleMatrix distanceMatrix = new DoubleMatrix(coordinates.Rows, coordinates.Rows);
+
+      for (int i = 0; i < distanceMatrix.Rows; i++) {
+        for (int j = i; j < distanceMatrix.Columns; j++) {
+          double distance = CalculateDistance(i, j, coordinates);
+
+          distanceMatrix[i, j] = distance;
+          distanceMatrix[j, i] = distance;
+        }
+      }
+
+      return distanceMatrix;
+    }
+
+    private static double GetDistance(int start, int end, 
+      DoubleMatrix coordinates, ILookupParameter<DoubleMatrix> distanceMatrix, BoolValue useDistanceMatrix) {
+      double distance = 0.0;
+
+      if (useDistanceMatrix.Value) {
+        if (distanceMatrix.ActualValue == null) {
+          distanceMatrix.ActualValue = CreateDistanceMatrix(coordinates);
+        }
+
+        distance = distanceMatrix.ActualValue[start, end];
+      } else {
+        distance = CalculateDistance(start, end, coordinates);
+      }
+
+      return distance;
+    }
+
+    private static TourEvaluation EvaluateTour(Tour tour, 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) {
+      TourEvaluation eval = new TourEvaluation();
+
+      double quality = 0.0;
+      double time = 0.0;
+
+      double distance = 0.0;
+      double waitingTime = 0.0;
+      double serviceTime = 0.0;
+      double delivered = 0.0;
+
+      double overweight = 0.0;
+      double tardiness = 0.0;
+
+      //simulate a tour, start and end at depot
+      for (int i = 1; i < tour.Count; i++) {
+        int start = tour[i - 1].Value;
+        int end = tour[i].Value;
+
+        //drive there
+        double currentDistace = GetDistance(start, end, coordinates, distanceMatrix, useDistanceMatrix);
+        distance += currentDistace;
+        time += currentDistace;
+
+        //check if it was serviced on time
+        if (time > dueTimeArray[end])
+          tardiness += time - dueTimeArray[end];
+
+        //wait
+        double currentWaitingTime = 0.0;
+        if (time < readyTimeArray[end])
+          currentWaitingTime = readyTimeArray[end] - time;
+        waitingTime += currentWaitingTime;
+        time += currentWaitingTime;
+
+        //service
+        delivered += demandArray[end];
+        double currentServiceTime = serviceTimeArray[end];
+        serviceTime += currentServiceTime;
+        time += currentServiceTime;
+      }
+
+      if (delivered > capacity.Value) {
+        overweight = delivered - capacity.Value;
+      }
+
+      //Fleet usage
+      quality += fleetUsageFactor.Value;
+      //Travel time
+      quality += timeFactor.Value * time;
+      //Distance
+      quality += distanceFactor.Value * distance;
+
+      //Penalties
+      quality += overloadPenalty.Value * overweight;
+      quality += tardinessPenalty.Value * tardiness;
+
+      eval.Distance = distance;
+      eval.TravelTime = time;
+      eval.VehcilesUtilized = 1;
+      eval.Overload = overweight;
+      eval.Tardiness = tardiness;
+      eval.Quality = quality;
+
+      return eval;
+    }
+
+    public static TourEvaluation Evaluate(IVRPEncoding solution, 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) {
+      TourEvaluation sumEval = new TourEvaluation();
+      sumEval.Distance = 0;
+      sumEval.Quality = 0;
+      sumEval.TravelTime = 0;
+      sumEval.VehcilesUtilized = 0;
+      sumEval.Overload = 0;
+      sumEval.Tardiness = 0;
+
+      foreach (Tour tour in solution.Tours) {
+        TourEvaluation eval = EvaluateTour(tour, dueTimeArray, serviceTimeArray, readyTimeArray, demandArray, capacity, 
+          fleetUsageFactor, timeFactor, distanceFactor, overloadPenalty, tardinessPenalty, 
+          coordinates, distanceMatrix, useDistanceMatrix);
+        sumEval.Quality += eval.Quality;
+        sumEval.Distance += eval.Distance;
+        sumEval.TravelTime += eval.TravelTime;
+        sumEval.VehcilesUtilized += eval.VehcilesUtilized;
+        sumEval.Overload += eval.Overload;
+        sumEval.Tardiness += eval.Tardiness;
+      }
+
+      if (sumEval.Quality < sumEval.Distance) {
+      }
+
+      return sumEval;
+    }
+
+    public sealed override IOperation Apply() {
+      IVRPEncoding solution = VRPSolutionParameter.ActualValue;
+
+      TourEvaluation sumEval = Evaluate(solution, DueTimeParameter.ActualValue, ServiceTimeParameter.ActualValue, ReadyTimeParameter.ActualValue, 
+        DemandParameter.ActualValue, CapacityParameter.ActualValue, 
+        FleetUsageFactor.Value, TimeFactor.Value, DistanceFactor.Value, OverloadPenalty.Value, TardinessPenalty.Value, 
+        CoordinatesParameter.ActualValue, DistanceMatrixParameter, UseDistanceMatrixParameter.ActualValue);
+
+      QualityParameter.ActualValue = new DoubleValue(sumEval.Quality);
+      VehcilesUtilizedParameter.ActualValue = new DoubleValue(sumEval.VehcilesUtilized);
+      TravelTimeParameter.ActualValue = new DoubleValue(sumEval.TravelTime);
+      DistanceParameter.ActualValue = new DoubleValue(sumEval.Distance);
+      OverloadParameter.ActualValue = new DoubleValue(sumEval.Overload);
+      TardinessParameter.ActualValue = new DoubleValue(sumEval.Tardiness);
+
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLab.Problems.VehicleRouting-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLab.Problems.VehicleRouting-3.3.csproj	(revision 3928)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLab.Problems.VehicleRouting-3.3.csproj	(revision 3938)
@@ -84,6 +84,38 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Analyzers\BestVRPSolutionAnalyzer.cs" />
+    <Compile Include="Encodings\Alba\Crossovers\AlbaPermutationCrossover.cs" />
+    <Compile Include="Encodings\Alba\Manipulators\AlbaPermutationManipulator.cs" />
+    <Compile Include="Encodings\Alba\Creators\AlbaPushForwardInsertionCreator.cs" />
+    <Compile Include="Encodings\Alba\Moves\AlbaMoveOperator.cs" />
+    <Compile Include="Encodings\Alba\Moves\AlbaMoveMaker.cs" />
+    <Compile Include="Encodings\Alba\Moves\ThreeOpt\AlbaTranslocationMoveGenerator.cs" />
+    <Compile Include="Encodings\Alba\Moves\ThreeOpt\AlbaTranslocationMoveMaker.cs" />
+    <Compile Include="Encodings\Alba\Moves\ThreeOpt\AlbaTranslocationMoveTabuMaker.cs" />
+    <Compile Include="Encodings\Alba\Moves\ThreeOpt\AlbaTranslocationMoveSoftTabuCriterion.cs" />
+    <Compile Include="Encodings\Alba\Moves\ThreeOpt\AlbaTranslocationMoveHardTabuCriterion.cs" />
+    <Compile Include="Encodings\VRPMoveOperator.cs" />
+    <Compile Include="Encodings\VRPCrossover.cs" />
+    <Compile Include="Encodings\VRPCreator.cs" />
+    <Compile Include="Encodings\Alba\Creators\AlbaPermutationCreator.cs" />
+    <Compile Include="Encodings\Alba\AlbaEncoding.cs" />
+    <Compile Include="Encodings\Tour.cs" />
+    <Compile Include="Encodings\VRPManipulator.cs" />
+    <Compile Include="Evaluators\VRPEvaluator.cs" />
     <Compile Include="HeuristicLabProblemsVehicleRoutingPlugin.cs" />
+    <Compile Include="Interfaces\IVRPCrossover.cs" />
+    <Compile Include="Interfaces\IVRPEncoding.cs" />
+    <Compile Include="Interfaces\IVRPEvaluator.cs" />
+    <Compile Include="Interfaces\IVRPManipulator.cs" />
+    <Compile Include="Interfaces\IVRPMoveEvaluator.cs" />
+    <Compile Include="Interfaces\IVRPMoveOperator.cs" />
+    <Compile Include="Interfaces\IVRPCreator.cs" />
+    <Compile Include="Interfaces\IVRPOperator.cs" />
+    <Compile Include="Encodings\Alba\Moves\ThreeOpt\AlbaTranslocationMoveEvaluator.cs" />
+    <Compile Include="MoveEvaluators\VRPMoveEvaluator.cs" />
+    <Compile Include="VRPSolution.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SolomonParser.cs" />
+    <Compile Include="VehicleRoutingProblem.cs" />
   </ItemGroup>
   <ItemGroup>
@@ -115,4 +147,8 @@
       <Project>{23DA7FF4-D5B8-41B6-AA96-F0561D24F3EE}</Project>
       <Name>HeuristicLab.Operators-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization.Operators\3.3\HeuristicLab.Optimization.Operators-3.3.csproj">
+      <Project>{25087811-F74C-4128-BC86-8324271DA13E}</Project>
+      <Name>HeuristicLab.Optimization.Operators-3.3</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLabProblemsVehicleRoutingPlugin.cs.frame
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLabProblemsVehicleRoutingPlugin.cs.frame	(revision 3928)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLabProblemsVehicleRoutingPlugin.cs.frame	(revision 3938)
@@ -36,4 +36,5 @@
   [PluginDependency("HeuristicLab.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPCreator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPCreator.cs	(revision 3938)
@@ -0,0 +1,45 @@
+﻿#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.Optimization;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  public interface IVRPCreator : IVRPOperator, ISolutionCreator {
+    IValueLookupParameter<IntValue> CitiesParameter { get; }
+    ILookupParameter<IntValue> VehiclesParameter { get; }
+    ILookupParameter<DoubleMatrix> CoordinatesParameter { get; }
+    ILookupParameter<DoubleMatrix> DistanceMatrixParameter { get; }
+    ILookupParameter<BoolValue> UseDistanceMatrixParameter { get; }
+    ILookupParameter<DoubleValue> CapacityParameter { get; }
+    ILookupParameter<DoubleArray> DemandParameter { get; }
+    ILookupParameter<DoubleArray> ReadyTimeParameter { get; }
+    ILookupParameter<DoubleArray> DueTimeParameter { get; }
+    ILookupParameter<DoubleArray> ServiceTimeParameter { get; }
+
+    ILookupParameter<IVRPEncoding> VRPSolutionParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPCrossover.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPCrossover.cs	(revision 3938)
@@ -0,0 +1,35 @@
+﻿#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.Optimization;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  public interface IVRPCrossover : IVRPOperator, ICrossover {
+    ILookupParameter<ItemArray<IVRPEncoding>> ParentsParameter { get; }
+    ILookupParameter<IVRPEncoding> ChildParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPEncoding.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPEncoding.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPEncoding.cs	(revision 3938)
@@ -0,0 +1,39 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Problems.VehicleRouting.Encodings;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  public interface IVRPEncoding: IItem {
+    ItemList<Tour> Tours {
+      get;
+    }
+
+    int Cities {
+      get;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPEvaluator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPEvaluator.cs	(revision 3938)
@@ -0,0 +1,49 @@
+﻿#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.Optimization;
+using HeuristicLab.Data;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  public interface IVRPEvaluator : ISingleObjectiveEvaluator {
+    ILookupParameter<IVRPEncoding> VRPSolutionParameter { get; }
+    ILookupParameter<DoubleMatrix> CoordinatesParameter { get; }
+    ILookupParameter<DoubleMatrix> DistanceMatrixParameter { get; }
+    ILookupParameter<BoolValue> UseDistanceMatrixParameter { get; }
+    ILookupParameter<IntValue> VehiclesParameter { get; }
+    ILookupParameter<DoubleValue> CapacityParameter { get; }
+    ILookupParameter<DoubleArray> DemandParameter { get; }
+    ILookupParameter<DoubleArray> ReadyTimeParameter { get; }
+    ILookupParameter<DoubleArray> DueTimeParameter { get; }
+    ILookupParameter<DoubleArray> ServiceTimeParameter { get; }
+
+    ILookupParameter<DoubleValue> VehcilesUtilizedParameter { get; }
+    ILookupParameter<DoubleValue> TravelTimeParameter { get; }
+    ILookupParameter<DoubleValue> DistanceParameter { get; }
+    ILookupParameter<DoubleValue> OverloadParameter { get; }
+    ILookupParameter<DoubleValue> TardinessParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPManipulator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPManipulator.cs	(revision 3938)
@@ -0,0 +1,33 @@
+﻿#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.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  public interface IVRPManipulator : IVRPOperator, IManipulator {
+    ILookupParameter<IVRPEncoding> VRPSolutionParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPMoveEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPMoveEvaluator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPMoveEvaluator.cs	(revision 3938)
@@ -0,0 +1,48 @@
+﻿#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.Optimization;
+using HeuristicLab.Data;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  public interface IVRPMoveEvaluator : ISingleObjectiveMoveEvaluator, IVRPMoveOperator {
+    ILookupParameter<DoubleMatrix> CoordinatesParameter { get; }
+    ILookupParameter<DoubleMatrix> DistanceMatrixParameter { get; }
+    ILookupParameter<BoolValue> UseDistanceMatrixParameter { get; }
+    ILookupParameter<IntValue> VehiclesParameter { get; }
+    ILookupParameter<DoubleValue> CapacityParameter { get; }
+    ILookupParameter<DoubleArray> DemandParameter { get; }
+    ILookupParameter<DoubleArray> ReadyTimeParameter { get; }
+    ILookupParameter<DoubleArray> DueTimeParameter { get; }
+    ILookupParameter<DoubleArray> ServiceTimeParameter { get; }
+
+    ILookupParameter<DoubleValue> MoveVehcilesUtilizedParameter { get; }
+    ILookupParameter<DoubleValue> MoveTravelTimeParameter { get; }
+    ILookupParameter<DoubleValue> MoveDistanceParameter { get; }
+    ILookupParameter<DoubleValue> MoveOverloadParameter { get; }
+    ILookupParameter<DoubleValue> MoveTardinessParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPMoveOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPMoveOperator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPMoveOperator.cs	(revision 3938)
@@ -0,0 +1,33 @@
+﻿#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.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  public interface IVRPMoveOperator : IVRPOperator, IMoveOperator {
+    ILookupParameter<IVRPEncoding> VRPSolutionParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPOperator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Interfaces/IVRPOperator.cs	(revision 3938)
@@ -0,0 +1,30 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  public interface IVRPOperator {
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/MoveEvaluators/VRPMoveEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/MoveEvaluators/VRPMoveEvaluator.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/MoveEvaluators/VRPMoveEvaluator.cs	(revision 3938)
@@ -0,0 +1,153 @@
+﻿#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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Data;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  [Item("VRPMoveEvaluator", "A base class for operators which evaluate VRP moves.")]
+  [StorableClass]
+  public abstract class VRPMoveEvaluator : SingleSuccessorOperator, IVRPMoveEvaluator, IMoveOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<IVRPEncoding> VRPSolutionParameter {
+      get { return (ILookupParameter<IVRPEncoding>)Parameters["VRPSolution"]; }
+    }
+    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"]; }
+    }
+    public IValueParameter<DoubleValue> FleetUsageFactor {
+      get { return (IValueParameter<DoubleValue>)Parameters["FleetUsageFactor"]; }
+    }
+    public IValueParameter<DoubleValue> TimeFactor {
+      get { return (IValueParameter<DoubleValue>)Parameters["TimeFactor"]; }
+    }
+    public IValueParameter<DoubleValue> DistanceFactor {
+      get { return (IValueParameter<DoubleValue>)Parameters["DistanceFactor"]; }
+    }
+    public IValueParameter<DoubleValue> OverloadPenalty {
+      get { return (IValueParameter<DoubleValue>)Parameters["OverloadPenalty"]; }
+    }
+    public IValueParameter<DoubleValue> TardinessPenalty {
+      get { return (IValueParameter<DoubleValue>)Parameters["TardinessPenalty"]; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveVehcilesUtilizedParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveVehiclesUtilized"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveTravelTimeParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveTravelTime"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveDistanceParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveDistance"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveOverloadParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveOverload"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveTardinessParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveTardiness"]; }
+    }
+
+    protected VRPMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<IVRPEncoding>("VRPSolution", "The VRP solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of a VRP solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveVehiclesUtilized", "The number of vehicles utilized."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveTravelTime", "The total travel time."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveDistance", "The distance."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveOverload", "The overload."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveTardiness", "The tardiness."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The evaluated quality of a move on a VRP solution."));
+      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."));
+      Parameters.Add(new ValueParameter<DoubleValue>("FleetUsageFactor", "The fleet usage factor considered in the evaluation.", new DoubleValue(0)));
+      Parameters.Add(new ValueParameter<DoubleValue>("TimeFactor", "The time factor considered in the evaluation.", new DoubleValue(0)));
+      Parameters.Add(new ValueParameter<DoubleValue>("DistanceFactor", "The distance factor considered in the evaluation.", new DoubleValue(1)));
+      Parameters.Add(new ValueParameter<DoubleValue>("OverloadPenalty", "The overload penalty considered in the evaluation.", new DoubleValue(50)));
+      Parameters.Add(new ValueParameter<DoubleValue>("TardinessPenalty", "The tardiness penalty considered in the evaluation.", new DoubleValue(50)));
+    }
+
+    protected abstract TourEvaluation GetMoveQuality();
+
+    public override IOperation Apply() {
+      TourEvaluation tourEval = GetMoveQuality();
+
+      MoveQualityParameter.ActualValue = new DoubleValue(tourEval.Quality);
+      MoveDistanceParameter.ActualValue = new DoubleValue(tourEval.Distance);
+      MoveVehcilesUtilizedParameter.ActualValue = new DoubleValue(tourEval.VehcilesUtilized);
+      MoveOverloadParameter.ActualValue = new DoubleValue(tourEval.Overload);
+      MoveTardinessParameter.ActualValue = new DoubleValue(tourEval.Tardiness);
+      MoveTravelTimeParameter.ActualValue = new DoubleValue(tourEval.TravelTime);
+
+      if (tourEval.Quality < tourEval.Distance) {
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/SolomonParser.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/SolomonParser.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/SolomonParser.cs	(revision 3938)
@@ -0,0 +1,158 @@
+﻿#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 System.IO;
+using System.Text.RegularExpressions;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  class SolomonParser {
+    private string file;
+    private string problemName;
+    private int cities;
+    private int vehicles;
+    private double capacity;
+    private List<double> xCoord;
+    private List<double> yCoord;
+    private List<double> demand;
+    private List<double> readyTime;
+    private List<double> dueTime;
+    private List<double> serviceTime;
+
+    public int Cities {
+      get {
+        return cities;
+      }
+    }
+
+    public int Vehicles {
+      get {
+        return vehicles;
+      }
+    }
+
+    public double Capacity {
+      get {
+        return capacity;
+      }
+    }
+
+    public double[,] Coordinates {
+      get {
+        double[] x = xCoord.ToArray();
+        double[] y = yCoord.ToArray();
+        double[,] coord = new double[x.Length, 2];
+        for (int i = 0; i < x.Length; i++) {
+          coord[i, 0] = x[i];
+          coord[i, 1] = y[i];
+        }
+        return coord;
+      }
+    }
+
+    public double[] Demands {
+      get {
+        return demand.ToArray();
+      }
+    }
+
+    public double[] Readytimes {
+      get {
+        return readyTime.ToArray();
+      }
+    }
+
+    public double[] Duetimes {
+      get {
+        return dueTime.ToArray();
+      }
+    }
+
+    public double[] Servicetimes {
+      get {
+        return serviceTime.ToArray();
+      }
+    }
+
+    public String ProblemName {
+      get {
+        return problemName;
+      }
+    }
+
+    public SolomonParser(string file) {
+      this.file = file;
+      xCoord = new List<double>();
+      yCoord = new List<double>();
+      demand = new List<double>();
+      readyTime = new List<double>();
+      dueTime = new List<double>();
+      serviceTime = new List<double>();
+    }
+
+    public void Parse() {
+      string line;
+      Regex reg = new Regex(@"-?\d+");
+      MatchCollection m;
+
+      StreamReader reader = new StreamReader(file);
+
+      problemName = reader.ReadLine();
+      for (int i = 0; i < 3; i++) {
+        reader.ReadLine();
+      }
+      line = reader.ReadLine();
+
+      m = reg.Matches(line);
+      if (m.Count != 2)
+        throw new InvalidDataException("File has wrong format!");
+
+      vehicles = int.Parse(m[0].Value);
+      capacity = double.Parse(m[1].Value);
+
+      for (int i = 0; i < 4; i++) {
+        reader.ReadLine();
+      }
+
+      line = reader.ReadLine();
+      while ((line != null) && (line.Length > 5)) {
+        m = reg.Matches(line);
+        if (m.Count != 7) { continue; }
+        xCoord.Add((double)int.Parse(m[1].Value));
+        yCoord.Add((double)int.Parse(m[2].Value));
+        demand.Add((double)int.Parse(m[3].Value));
+        readyTime.Add((double)int.Parse(m[4].Value));
+        double st = (double)int.Parse(m[6].Value);
+        dueTime.Add(st + (double)int.Parse(m[5].Value));
+        serviceTime.Add(st);
+        line = reader.ReadLine();
+      }
+      cities = serviceTime.Count;
+    }
+
+    internal string OnReset() {
+      throw new NotImplementedException();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/VRPSolution.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/VRPSolution.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/VRPSolution.cs	(revision 3938)
@@ -0,0 +1,316 @@
+#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.Drawing;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  /// <summary>
+  /// Represents a VRP solution which can be visualized in the GUI.
+  /// </summary>
+  [Item("VRPSolution", "Represents a VRP solution which can be visualized in the GUI.")]
+  [StorableClass]
+  public sealed class VRPSolution : Item {
+    public override Image ItemImage {
+      get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Image; }
+    }
+
+    [Storable]
+    private DoubleMatrix coordinates;
+    public DoubleMatrix Coordinates {
+      get { return coordinates; }
+      set {
+        if (coordinates != value) {
+          if (coordinates != null) DeregisterCoordinatesEvents();
+          coordinates = value;
+          if (coordinates != null) RegisterCoordinatesEvents();
+          OnCoordinatesChanged();
+        }
+      }
+    }
+    [Storable]
+    private IVRPEncoding solution;
+    public IVRPEncoding Solution {
+      get { return solution; }
+      set {
+        if (solution != value) {
+          if (solution != null) DeregisterSolutionEvents();
+          solution = value;
+          if (solution != null) RegisterSolutionEvents();
+          OnSolutionChanged();
+        }
+      }
+    }
+    [Storable]
+    private DoubleValue quality;
+    public DoubleValue Quality {
+      get { return quality; }
+      set {
+        if (quality != value) {
+          if (quality != null) DeregisterQualityEvents();
+          quality = value;
+          if (quality != null) RegisterQualityEvents();
+          OnQualityChanged();
+        }
+      }
+    }
+    [Storable]
+    private DoubleValue distance;
+    public DoubleValue Distance {
+      get { return distance; }
+      set {
+        if (distance != value) {
+          if (distance != null) DeregisterDistanceEvents();
+          distance = value;
+          if (distance != null) RegisterDistanceEvents();
+          OnDistanceChanged();
+        }
+      }
+    }
+    [Storable]
+    private DoubleValue overload;
+    public DoubleValue Overload {
+      get { return overload; }
+      set {
+        if (overload != value) {
+          if (overload != null) DeregisterOverloadEvents();
+          overload = value;
+          if (overload != null) RegisterOverloadEvents();
+          OnOverloadChanged();
+        }
+      }
+    }
+    [Storable]
+    private DoubleValue tardiness;
+    public DoubleValue Tardiness {
+      get { return tardiness; }
+      set {
+        if (tardiness != value) {
+          if (tardiness != null) DeregisterTardinessEvents();
+          tardiness = value;
+          if (tardiness != null) RegisterTardinessEvents();
+          OnTardinessChanged();
+        }
+      }
+    }
+    [Storable]
+    private DoubleValue travelTime;
+    public DoubleValue TravelTime {
+      get { return travelTime; }
+      set {
+        if (travelTime != value) {
+          if (travelTime != null) DeregisterTravelTimeEvents();
+          travelTime = value;
+          if (travelTime != null) RegisterTravelTimeEvents();
+          OnTravelTimeChanged();
+        }
+      }
+    }
+    [Storable]
+    private DoubleValue vehicleUtilization;
+    public DoubleValue VehicleUtilization {
+      get { return vehicleUtilization; }
+      set {
+        if (vehicleUtilization != value) {
+          if (vehicleUtilization != null) DeregisterVehicleUtilizationEvents();
+          vehicleUtilization = value;
+          if (vehicleUtilization != null) RegisterVehicleUtilizationEvents();
+          OnVehicleUtilizationChanged();
+        }
+      }
+    }
+
+    public VRPSolution() : base() { }
+
+    public VRPSolution(DoubleMatrix coordinates, IVRPEncoding solution, DoubleValue quality, 
+      DoubleValue distance, DoubleValue overload, DoubleValue tardiness, DoubleValue travelTime, 
+      DoubleValue vehicleUtilization)
+      : base() {
+      this.coordinates = coordinates;
+      this.solution = solution;
+      this.quality = quality;
+      this.distance = distance;
+      this.overload = overload;
+      this.tardiness = tardiness;
+      this.travelTime = travelTime;
+      this.vehicleUtilization = vehicleUtilization;
+      Initialize();
+    }
+    [StorableConstructor]
+    private VRPSolution(bool deserializing) : base(deserializing) { }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      if (coordinates != null) RegisterCoordinatesEvents();
+      if (solution != null) RegisterSolutionEvents();
+      if (quality != null) RegisterQualityEvents();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      VRPSolution clone = new VRPSolution();
+      cloner.RegisterClonedObject(this, clone);
+      clone.coordinates = (DoubleMatrix)cloner.Clone(coordinates);
+      clone.solution = (IVRPEncoding)cloner.Clone(solution);
+      clone.quality = (DoubleValue)cloner.Clone(quality);
+      clone.distance = (DoubleValue)cloner.Clone(distance);
+      clone.overload = (DoubleValue)cloner.Clone(overload);
+      clone.tardiness = (DoubleValue)cloner.Clone(tardiness);
+      clone.travelTime = (DoubleValue)cloner.Clone(travelTime);
+      clone.vehicleUtilization = (DoubleValue)cloner.Clone(vehicleUtilization);
+      clone.Initialize();
+      return clone;
+    }
+
+    #region Events
+    public event EventHandler CoordinatesChanged;
+    private void OnCoordinatesChanged() {
+      var changed = CoordinatesChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+    public event EventHandler SolutionChanged;
+    private void OnSolutionChanged() {
+      var changed = SolutionChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+    public event EventHandler QualityChanged;
+    private void OnQualityChanged() {
+      var changed = QualityChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+    public event EventHandler DistanceChanged;
+    private void OnDistanceChanged() {
+      var changed = DistanceChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+    public event EventHandler OverloadChanged;
+    private void OnOverloadChanged() {
+      var changed = OverloadChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+    public event EventHandler TardinessChanged;
+    private void OnTardinessChanged() {
+      var changed = TardinessChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+    public event EventHandler TravelTimeChanged;
+    private void OnTravelTimeChanged() {
+      var changed = TravelTimeChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+    public event EventHandler VehicleUtilizationChanged;
+    private void OnVehicleUtilizationChanged() {
+      var changed = VehicleUtilizationChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+
+    private void RegisterCoordinatesEvents() {
+      Coordinates.ItemChanged += new EventHandler<EventArgs<int, int>>(Coordinates_ItemChanged);
+      Coordinates.Reset += new EventHandler(Coordinates_Reset);
+    }
+    private void DeregisterCoordinatesEvents() {
+      Coordinates.ItemChanged -= new EventHandler<EventArgs<int, int>>(Coordinates_ItemChanged);
+      Coordinates.Reset -= new EventHandler(Coordinates_Reset);
+    }
+    private void RegisterSolutionEvents() {
+      Solution.ToStringChanged += new EventHandler(Solution_ToStringChanged);
+    }
+    private void DeregisterSolutionEvents() {
+      Solution.ToStringChanged -= new EventHandler(Solution_ToStringChanged);
+    }
+    private void RegisterQualityEvents() {
+      Quality.ValueChanged += new EventHandler(Quality_ValueChanged);
+    }
+    private void DeregisterQualityEvents() {
+      Quality.ValueChanged -= new EventHandler(Quality_ValueChanged);
+    }
+    private void RegisterDistanceEvents() {
+      Distance.ValueChanged += new EventHandler(Distance_ValueChanged);
+    }
+    private void DeregisterDistanceEvents() {
+      Distance.ValueChanged -= new EventHandler(Distance_ValueChanged);
+    }
+    private void RegisterOverloadEvents() {
+      Overload.ValueChanged += new EventHandler(Overload_ValueChanged);
+    }
+    private void DeregisterOverloadEvents() {
+      Overload.ValueChanged -= new EventHandler(Overload_ValueChanged);
+    }
+    private void RegisterTardinessEvents() {
+      Tardiness.ValueChanged += new EventHandler(Tardiness_ValueChanged);
+    }
+    private void DeregisterTardinessEvents() {
+      Tardiness.ValueChanged -= new EventHandler(Tardiness_ValueChanged);
+    }
+    private void RegisterTravelTimeEvents() {
+      TravelTime.ValueChanged += new EventHandler(TravelTime_ValueChanged);
+    }
+    private void DeregisterTravelTimeEvents() {
+      TravelTime.ValueChanged -= new EventHandler(TravelTime_ValueChanged);
+    }
+    private void RegisterVehicleUtilizationEvents() {
+      VehicleUtilization.ValueChanged += new EventHandler(VehicleUtilization_ValueChanged);
+    }
+    private void DeregisterVehicleUtilizationEvents() {
+      VehicleUtilization.ValueChanged -= new EventHandler(VehicleUtilization_ValueChanged);
+    }
+
+    private void Coordinates_ItemChanged(object sender, EventArgs<int, int> e) {
+      OnCoordinatesChanged();
+    }
+    private void Coordinates_Reset(object sender, EventArgs e) {
+      OnCoordinatesChanged();
+    }
+    private void Solution_ToStringChanged(object sender, EventArgs e) {
+      OnSolutionChanged();
+    }
+    private void Quality_ValueChanged(object sender, EventArgs e) {
+      OnQualityChanged();
+    }
+    private void Distance_ValueChanged(object sender, EventArgs e) {
+      OnDistanceChanged();
+    }
+    private void Overload_ValueChanged(object sender, EventArgs e) {
+      OnOverloadChanged();
+    }
+    private void Tardiness_ValueChanged(object sender, EventArgs e) {
+      OnTardinessChanged();
+    }
+    private void TravelTime_ValueChanged(object sender, EventArgs e) {
+      OnTravelTimeChanged();
+    }
+    private void VehicleUtilization_ValueChanged(object sender, EventArgs e) {
+      OnVehicleUtilizationChanged();
+    }
+    #endregion
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs	(revision 3938)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/VehicleRoutingProblem.cs	(revision 3938)
@@ -0,0 +1,389 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+using HeuristicLab.Common;
+using System.Drawing;
+using HeuristicLab.Problems.VehicleRouting.Encodings.Alba;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Encodings.PermutationEncoding;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  [Item("Vehicle Routing Problem", "Represents a Vehicle Routing Problem.")]
+  [Creatable("Problems")]
+  [StorableClass]
+  public sealed class VehicleRoutingProblem : ParameterizedNamedItem, ISingleObjectiveProblem {
+    public override Image ItemImage {
+      get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Type; }
+    }
+
+    #region Parameter Properties
+    public ValueParameter<BoolValue> MaximizationParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    IParameter ISingleObjectiveProblem.MaximizationParameter {
+      get { return MaximizationParameter; }
+    }
+    public ValueParameter<DoubleMatrix> CoordinatesParameter {
+      get { return (ValueParameter<DoubleMatrix>)Parameters["Coordinates"]; }
+    }
+    public OptionalValueParameter<DoubleMatrix> DistanceMatrixParameter {
+      get { return (OptionalValueParameter<DoubleMatrix>)Parameters["DistanceMatrix"]; }
+    }
+    public ValueParameter<BoolValue> UseDistanceMatrixParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseDistanceMatrix"]; }
+    }
+    public ValueParameter<IntValue> VehiclesParameter {
+      get { return (ValueParameter<IntValue>)Parameters["Vehicles"]; }
+    }
+    public ValueParameter<DoubleValue> CapacityParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["Capacity"]; }
+    }
+    public ValueParameter<DoubleArray> DemandParameter {
+      get { return (ValueParameter<DoubleArray>)Parameters["Demand"]; }
+    }
+    public ValueParameter<DoubleArray> ReadyTimeParameter {
+      get { return (ValueParameter<DoubleArray>)Parameters["ReadyTime"]; }
+    }
+    public ValueParameter<DoubleArray> DueTimeParameter {
+      get { return (ValueParameter<DoubleArray>)Parameters["DueTime"]; }
+    }
+    public ValueParameter<DoubleArray> ServiceTimeParameter {
+      get { return (ValueParameter<DoubleArray>)Parameters["ServiceTime"]; }
+    }
+    ValueParameter<IVRPCreator> SolutionCreatorParameter {
+      get { return (ValueParameter<IVRPCreator>)Parameters["SolutionCreator"]; }
+    }
+    IParameter IProblem.SolutionCreatorParameter {
+      get { return SolutionCreatorParameter; }
+    }
+    ValueParameter<IVRPEvaluator> EvaluatorParameter {
+      get { return (ValueParameter<IVRPEvaluator>)Parameters["Evaluator"]; }
+    }
+    IParameter IProblem.EvaluatorParameter {
+      get { return EvaluatorParameter; }
+    }
+    public OptionalValueParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (OptionalValueParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
+    }
+    IParameter ISingleObjectiveProblem.BestKnownQualityParameter {
+      get { return BestKnownQualityParameter; }
+    }
+    #endregion
+
+    #region Properties
+    public DoubleMatrix Coordinates {
+      get { return CoordinatesParameter.Value; }
+      set { CoordinatesParameter.Value = value; }
+    }
+    public DoubleMatrix DistanceMatrix {
+      get { return DistanceMatrixParameter.Value; }
+      set { DistanceMatrixParameter.Value = value; }
+    }
+    public BoolValue UseDistanceMatrix {
+      get { return UseDistanceMatrixParameter.Value; }
+      set { UseDistanceMatrixParameter.Value = value; }
+    }
+    public IntValue Vehicles {
+      get { return VehiclesParameter.Value; }
+      set { VehiclesParameter.Value = value; }
+    }
+    public DoubleValue Capacity {
+      get { return CapacityParameter.Value; }
+      set { CapacityParameter.Value = value; }
+    }
+    public DoubleArray Demand {
+      get { return DemandParameter.Value; }
+      set { DemandParameter.Value = value; }
+    }
+    public DoubleArray ReadyTime {
+      get { return ReadyTimeParameter.Value; }
+      set { ReadyTimeParameter.Value = value; }
+    }
+    public DoubleArray DueTime {
+      get { return DueTimeParameter.Value; }
+      set { DueTimeParameter.Value = value; }
+    }
+    public DoubleArray ServiceTime {
+      get { return ServiceTimeParameter.Value; }
+      set { ServiceTimeParameter.Value = value; }
+    }
+    public DoubleValue BestKnownQuality {
+      get { return BestKnownQualityParameter.Value; }
+      set { BestKnownQualityParameter.Value = value; }
+    }
+    IVRPCreator SolutionCreator {
+      get { return SolutionCreatorParameter.Value; }
+      set { SolutionCreatorParameter.Value = value; }
+    }
+    ISolutionCreator IProblem.SolutionCreator {
+      get { return SolutionCreatorParameter.Value; }
+    }
+    IVRPEvaluator Evaluator {
+      get { return EvaluatorParameter.Value; }
+      set { EvaluatorParameter.Value = value; }
+    }
+    ISingleObjectiveEvaluator ISingleObjectiveProblem.Evaluator {
+      get { return EvaluatorParameter.Value; }
+    }
+    IEvaluator IProblem.Evaluator {
+      get { return EvaluatorParameter.Value; }
+    }
+    private List<IOperator> operators;
+    public IEnumerable<IOperator> Operators {
+      get { return operators; }
+    }
+    private BestVRPSolutionAnalyzer BestVRPSolutionAnalyzer {
+      get { return operators.OfType<BestVRPSolutionAnalyzer>().FirstOrDefault(); }
+    }
+    #endregion
+
+    public VehicleRoutingProblem()
+      : base() {
+      IVRPCreator creator = new AlbaPermutationCreator();
+      IVRPEvaluator evaluator = new VRPEvaluator();
+
+      Parameters.Add(new ValueParameter<BoolValue>("Maximization", "Set to false as the Vehicle Routing Problem is a minimization problem.", new BoolValue(false)));
+      Parameters.Add(new ValueParameter<DoubleMatrix>("Coordinates", "The x- and y-Coordinates of the cities.", new DoubleMatrix()));
+      Parameters.Add(new OptionalValueParameter<DoubleMatrix>("DistanceMatrix", "The matrix which contains the distances between the cities."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseDistanceMatrix", "True if a distance matrix should be calculated and used for evaluation, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<IntValue>("Vehicles", "The number of vehicles.", new IntValue(0)));
+      Parameters.Add(new ValueParameter<DoubleValue>("Capacity", "The capacity of each vehicle.", new DoubleValue(0)));
+      Parameters.Add(new ValueParameter<DoubleArray>("Demand", "The demand of each customer.", new DoubleArray()));
+      Parameters.Add(new ValueParameter<DoubleArray>("ReadyTime", "The ready time of each customer.", new DoubleArray()));
+      Parameters.Add(new ValueParameter<DoubleArray>("DueTime", "The due time of each customer.", new DoubleArray()));
+      Parameters.Add(new ValueParameter<DoubleArray>("ServiceTime", "The service time of each customer.", new DoubleArray()));
+      Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this VRP instance."));
+
+      Parameters.Add(new ValueParameter<IVRPCreator>("SolutionCreator", "The operator which should be used to create new VRP solutions.", creator));
+      Parameters.Add(new ValueParameter<IVRPEvaluator>("Evaluator", "The operator which should be used to evaluate VRP solutions.", evaluator));
+
+      creator.VRPSolutionParameter.ActualName = "VRPSolution";
+      evaluator.QualityParameter.ActualName = "VRPQuality";
+      ParameterizeSolutionCreator();
+      ParameterizeEvaluator();
+
+      Initialize();
+    }
+    [StorableConstructor]
+    private VehicleRoutingProblem(bool deserializing) : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      VehicleRoutingProblem clone = (VehicleRoutingProblem)base.Clone(cloner);
+      clone.DistanceMatrixParameter.Value = DistanceMatrixParameter.Value;
+      clone.Initialize();
+      return clone;
+    }
+
+    public void ImportFromSolomon(string solomonFileName) {
+      SolomonParser parser = new SolomonParser(solomonFileName);
+      parser.Parse();
+
+      this.Name = parser.ProblemName;
+
+      Coordinates = new DoubleMatrix(parser.Coordinates);
+      Vehicles.Value = parser.Vehicles;
+      Capacity.Value = parser.Capacity;
+      Demand = new DoubleArray(parser.Demands);
+      ReadyTime = new DoubleArray(parser.Readytimes);
+      DueTime = new DoubleArray(parser.Duetimes);
+      ServiceTime = new DoubleArray(parser.Servicetimes);
+
+      OnReset();
+    }
+
+    #region Events
+    public event EventHandler SolutionCreatorChanged;
+    private void OnSolutionCreatorChanged() {
+      EventHandler handler = SolutionCreatorChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler EvaluatorChanged;
+    private void OnEvaluatorChanged() {
+      EventHandler handler = EvaluatorChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler OperatorsChanged;
+    private void OnOperatorsChanged() {
+      EventHandler handler = OperatorsChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Reset;
+    private void OnReset() {
+      EventHandler handler = Reset;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    void VehiclesValue_ValueChanged(object sender, EventArgs e) {
+      ParameterizeSolutionCreator();
+    }
+    private void CoordinatesParameter_ValueChanged(object sender, EventArgs e) {
+      Coordinates.ItemChanged += new EventHandler<EventArgs<int, int>>(Coordinates_ItemChanged);
+      Coordinates.Reset += new EventHandler(Coordinates_Reset);
+      ParameterizeSolutionCreator();
+      ClearDistanceMatrix();
+    }
+    private void Coordinates_ItemChanged(object sender, EventArgs<int, int> e) {
+      ClearDistanceMatrix();
+    }
+    private void Coordinates_Reset(object sender, EventArgs e) {
+      ParameterizeSolutionCreator();
+      ClearDistanceMatrix();
+    }
+    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs e) {
+      ParameterizeSolutionCreator();
+      ParameterizeEvaluator();
+      ParameterizeAnalyzer();
+      ParameterizeOperators();
+      OnSolutionCreatorChanged();
+    }
+    private void SolutionCreator_PermutationParameter_ActualNameChanged(object sender, EventArgs e) {
+      ParameterizeEvaluator();
+      ParameterizeAnalyzer();
+      ParameterizeOperators();
+    }
+    private void EvaluatorParameter_ValueChanged(object sender, EventArgs e) {
+      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+      ParameterizeEvaluator();
+      UpdateMoveEvaluators();
+      ParameterizeAnalyzer();
+      //UpdateDistanceMatrix();
+      OnEvaluatorChanged();
+    }
+    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+      ParameterizeAnalyzer();
+    }
+    void TranslocationMoveParameter_ActualNameChanged(object sender, EventArgs e) {
+      string name = ((ILookupParameter<TranslocationMove>)sender).ActualName;
+      foreach (IPermutationTranslocationMoveOperator op in Operators.OfType<IPermutationTranslocationMoveOperator>()) {
+        op.TranslocationMoveParameter.ActualName = name;
+      }
+    }
+    #endregion
+
+    #region Helpers
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      InitializeOperators();
+      CoordinatesParameter.ValueChanged += new EventHandler(CoordinatesParameter_ValueChanged);
+      Vehicles.ValueChanged += new EventHandler(VehiclesValue_ValueChanged);
+      Coordinates.ItemChanged += new EventHandler<EventArgs<int, int>>(Coordinates_ItemChanged);
+      Coordinates.Reset += new EventHandler(Coordinates_Reset);
+      SolutionCreatorParameter.ValueChanged += new EventHandler(SolutionCreatorParameter_ValueChanged);
+      EvaluatorParameter.ValueChanged += new EventHandler(EvaluatorParameter_ValueChanged);
+      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+    }
+    private void InitializeOperators() {
+      operators = new List<IOperator>();
+      operators.Add(new BestVRPSolutionAnalyzer());
+      ParameterizeAnalyzer();
+      operators.AddRange(ApplicationManager.Manager.GetInstances<IVRPOperator>().Cast<IOperator>());
+      ParameterizeOperators();
+      UpdateMoveEvaluators();
+      InitializeMoveGenerators();
+    }
+    private void InitializeMoveGenerators() {
+      foreach (AlbaTranslocationMoveGenerator op in Operators.OfType<AlbaTranslocationMoveGenerator>()) {
+        if (op is IMoveGenerator) {
+          op.TranslocationMoveParameter.ActualNameChanged += new EventHandler(TranslocationMoveParameter_ActualNameChanged);
+        }
+      }
+
+    }
+    private void UpdateMoveEvaluators() {
+      ParameterizeOperators();
+      OnOperatorsChanged();
+    }
+    private void ParameterizeSolutionCreator() {
+      SolutionCreator.CitiesParameter.Value = new IntValue(Coordinates.Rows - 1);
+      SolutionCreator.VehiclesParameter.ActualName = VehiclesParameter.Name;
+      SolutionCreator.CoordinatesParameter.ActualName = CoordinatesParameter.Name;
+      Evaluator.DistanceMatrixParameter.ActualName = DistanceMatrixParameter.Name;
+      Evaluator.UseDistanceMatrixParameter.ActualName = UseDistanceMatrixParameter.Name;
+      SolutionCreator.CapacityParameter.ActualName = CapacityParameter.Name;
+      SolutionCreator.DemandParameter.ActualName = DemandParameter.Name;
+      SolutionCreator.ReadyTimeParameter.ActualName = ReadyTimeParameter.Name;
+      SolutionCreator.DueTimeParameter.ActualName = DueTimeParameter.Name;
+      SolutionCreator.ServiceTimeParameter.ActualName = ServiceTimeParameter.Name;
+    }
+    private void ParameterizeEvaluator() {
+      Evaluator.VRPSolutionParameter.ActualName = SolutionCreator.VRPSolutionParameter.ActualName;
+      Evaluator.CoordinatesParameter.ActualName = CoordinatesParameter.Name;
+      Evaluator.DistanceMatrixParameter.ActualName = DistanceMatrixParameter.Name;
+      Evaluator.UseDistanceMatrixParameter.ActualName = UseDistanceMatrixParameter.Name;
+      Evaluator.VehiclesParameter.ActualName = VehiclesParameter.Name;
+      Evaluator.CapacityParameter.ActualName = CapacityParameter.Name;
+      Evaluator.DemandParameter.ActualName = DemandParameter.Name;
+      Evaluator.ReadyTimeParameter.ActualName = ReadyTimeParameter.Name;
+      Evaluator.DueTimeParameter.ActualName = DueTimeParameter.Name;
+      Evaluator.ServiceTimeParameter.ActualName = ServiceTimeParameter.Name;
+    }
+    private void ParameterizeAnalyzer() {
+      BestVRPSolutionAnalyzer.CoordinatesParameter.ActualName = CoordinatesParameter.Name;
+      BestVRPSolutionAnalyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+      BestVRPSolutionAnalyzer.DistanceParameter.ActualName = Evaluator.DistanceParameter.ActualName;
+      BestVRPSolutionAnalyzer.OverloadParameter.ActualName = Evaluator.OverloadParameter.ActualName;
+      BestVRPSolutionAnalyzer.TardinessParameter.ActualName = Evaluator.TardinessParameter.ActualName;
+      BestVRPSolutionAnalyzer.VRPSolutionParameter.ActualName = SolutionCreator.VRPSolutionParameter.ActualName;
+      BestVRPSolutionAnalyzer.ResultsParameter.ActualName = "Results";
+    }
+    private void ParameterizeOperators() {
+      foreach (IVRPMoveOperator op in Operators.OfType<IVRPMoveOperator>()) {
+        op.VRPSolutionParameter.ActualName = SolutionCreator.VRPSolutionParameter.ActualName;
+      }
+      foreach (IVRPMoveEvaluator op in Operators.OfType<IVRPMoveEvaluator>()) {
+        op.CoordinatesParameter.ActualName = CoordinatesParameter.Name;
+        op.DistanceMatrixParameter.ActualName = DistanceMatrixParameter.Name;
+        op.UseDistanceMatrixParameter.ActualName = UseDistanceMatrixParameter.Name;
+        op.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+        op.VRPSolutionParameter.ActualName = SolutionCreator.VRPSolutionParameter.ActualName;
+        op.VehiclesParameter.ActualName = VehiclesParameter.Name;
+        op.CapacityParameter.ActualName = CapacityParameter.Name;
+        op.DemandParameter.ActualName = DemandParameter.Name;
+        op.ReadyTimeParameter.ActualName = ReadyTimeParameter.Name;
+        op.DueTimeParameter.ActualName = DueTimeParameter.Name;
+        op.ServiceTimeParameter.ActualName = ServiceTimeParameter.Name;
+      }
+      string translocationMove = Operators.OfType<IMoveGenerator>().OfType<IPermutationTranslocationMoveOperator>().First().TranslocationMoveParameter.ActualName;
+      foreach (IPermutationTranslocationMoveOperator op in Operators.OfType<IPermutationTranslocationMoveOperator>())
+        op.TranslocationMoveParameter.ActualName = translocationMove;
+
+      foreach (IVRPCrossover op in Operators.OfType<IVRPCrossover>()) {
+        op.ParentsParameter.ActualName = SolutionCreator.VRPSolutionParameter.ActualName;
+        op.ChildParameter.ActualName = SolutionCreator.VRPSolutionParameter.ActualName;
+      }
+      foreach (IVRPManipulator op in Operators.OfType<IVRPManipulator>()) {
+        op.VRPSolutionParameter.ActualName = SolutionCreator.VRPSolutionParameter.ActualName;
+      }
+    }
+    private void ClearDistanceMatrix() {
+      DistanceMatrixParameter.Value = null;
+    }
+    #endregion
+  }
+}
