Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/AlbaEncoding.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/AlbaEncoding.cs	(revision 4186)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/AlbaEncoding.cs	(revision 4204)
@@ -30,5 +30,5 @@
   [Item("AlbaEncoding", "Represents an Alba encoding of VRP solutions. It is implemented as described in Alba, E. and Dorronsoro, B. (2004). Solving the Vehicle Routing Problem by Using Cellular Genetic Algorithms.")]
   [StorableClass]
-  class AlbaEncoding : Permutation, IVRPEncoding {
+  public class AlbaEncoding : Permutation, IVRPEncoding {
     [Storable]
     private int cities;
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaCrossover.cs	(revision 4186)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/AlbaCrossover.cs	(revision 4204)
@@ -25,41 +25,25 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Data;
+using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
   [Item("AlbaCrossover", "An operator which crosses two Alba VRP representations.")]
   [StorableClass]
-  public sealed class AlbaCrossover : VRPCrossover {    
-    public IValueLookupParameter<IPermutationCrossover> InnerCrossoverParameter {
-      get { return (IValueLookupParameter<IPermutationCrossover>)Parameters["InnerCrossover"]; }
+  public abstract class AlbaCrossover : VRPCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-
+    
     [StorableConstructor]
-    private AlbaCrossover(bool deserializing) : base(deserializing) { }
+    protected AlbaCrossover(bool deserializing) : base(deserializing) { }
 
     public AlbaCrossover()
       : base() {
-      Parameters.Add(new ValueLookupParameter<IPermutationCrossover>("InnerCrossover", "The permutation crossover.", new EdgeRecombinationCrossover()));
-    
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+   
       AlbaEncoding.RemoveUnusedParameters(Parameters);
     }
 
-    private void Crossover() {
-      //note - the inner crossover is called here and the result is converted to an alba representation
-      //some refactoring should be done here in the future - the crossover operation should be called directly
-
-      InnerCrossoverParameter.ActualValue.ParentsParameter.ActualName = ParentsParameter.ActualName;
-      IAtomicOperation op = this.ExecutionContext.CreateOperation(
-        InnerCrossoverParameter.ActualValue, this.ExecutionContext.Scope);
-      op.Operator.Execute((IExecutionContext)op);
-
-      string childName = InnerCrossoverParameter.ActualValue.ChildParameter.ActualName;
-      if (ExecutionContext.Scope.Variables.ContainsKey(childName)) {
-        Permutation permutation = ExecutionContext.Scope.Variables[childName].Value as Permutation;
-        ExecutionContext.Scope.Variables.Remove(childName);
-
-        ChildParameter.ActualValue = new AlbaEncoding(permutation, Cities);
-      } else
-        ChildParameter.ActualValue = null;
-    }
+    protected abstract AlbaEncoding Crossover(IRandom random, AlbaEncoding parent1, AlbaEncoding parent2);
 
     public override IOperation Apply() {
@@ -76,5 +60,6 @@
       ParentsParameter.ActualValue = parents;
 
-      Crossover();
+      ChildParameter.ActualValue = 
+        Crossover(RandomParameter.ActualValue, parents[0] as AlbaEncoding, parents[1] as AlbaEncoding);
 
       return base.Apply();
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/PermutationCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/PermutationCrossover.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Crossovers/PermutationCrossover.cs	(revision 4204)
@@ -0,0 +1,63 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("PermutationCrossover", "An operator which crosses two Alba VRP representations using a standard permutation operator.")]
+  [StorableClass]
+  public sealed class PermutationCrossover : AlbaCrossover {    
+    public IValueLookupParameter<IPermutationCrossover> InnerCrossoverParameter {
+      get { return (IValueLookupParameter<IPermutationCrossover>)Parameters["InnerCrossover"]; }
+    }
+
+    [StorableConstructor]
+    private PermutationCrossover(bool deserializing) : base(deserializing) { }
+
+    public PermutationCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IPermutationCrossover>("InnerCrossover", "The permutation crossover.", new EdgeRecombinationCrossover()));
+    }
+
+    protected override AlbaEncoding Crossover(IRandom random, AlbaEncoding parent1, AlbaEncoding parent2) {
+      //note - the inner crossover is called here and the result is converted to an alba representation
+      //some refactoring should be done here in the future - the crossover operation should be called directly
+
+      InnerCrossoverParameter.ActualValue.ParentsParameter.ActualName = ParentsParameter.ActualName;
+      IAtomicOperation op = this.ExecutionContext.CreateOperation(
+        InnerCrossoverParameter.ActualValue, this.ExecutionContext.Scope);
+      op.Operator.Execute((IExecutionContext)op);
+
+      string childName = InnerCrossoverParameter.ActualValue.ChildParameter.ActualName;
+      if (ExecutionContext.Scope.Variables.ContainsKey(childName)) {
+        Permutation permutation = ExecutionContext.Scope.Variables[childName].Value as Permutation;
+        ExecutionContext.Scope.Variables.Remove(childName);
+
+        return new AlbaEncoding(permutation, Cities);
+      } else
+        return null;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaManipulator.cs	(revision 4186)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/AlbaManipulator.cs	(revision 4204)
@@ -25,21 +25,36 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Data;
+using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
-  [Item("AlbaManipulator", "An operator which manipulates an alba VRP representation.")]
+  [Item("AlbaManipulator", "An operator which manipulates an Alba VRP representation.")]
   [StorableClass]
-  public sealed class AlbaManipulator : VRPManipulator {
-    public IValueLookupParameter<IPermutationManipulator> InnerManipulatorParameter {
-      get { return (IValueLookupParameter<IPermutationManipulator>)Parameters["InnerManipulator"]; }
+  public abstract class AlbaManipulator : VRPManipulator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
 
     [StorableConstructor]
-    private AlbaManipulator(bool deserializing) : base(deserializing) { }
+    protected AlbaManipulator(bool deserializing) : base(deserializing) { }
 
     public AlbaManipulator()
       : base() {
-        Parameters.Add(new ValueLookupParameter<IPermutationManipulator>("InnerManipulator", "The permutation manipulator.", new TranslocationManipulator()));
+        Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
 
         AlbaEncoding.RemoveUnusedParameters(Parameters);
+    }
+
+    protected abstract void Manipulate(IRandom random, AlbaEncoding individual);
+
+    protected int FindCustomerLocation(int customer, AlbaEncoding individual) {
+      int pos = -1;
+      for (int i = 0; i < individual.Length; i++) {
+        if (individual[i] == customer) {
+          pos = i;
+          break;
+        }
+      }
+
+      return pos;
     }
 
@@ -49,14 +64,8 @@
         VRPToursParameter.ActualValue = AlbaEncoding.ConvertFrom(solution, VehiclesParameter.ActualValue.Value);
       }
-      
-      OperationCollection next = new OperationCollection(base.Apply());
 
-      IPermutationManipulator op = InnerManipulatorParameter.ActualValue;
-      if (op != null) {
-        op.PermutationParameter.ActualName = VRPToursParameter.ActualName;
-        next.Insert(0, ExecutionContext.CreateOperation(op));
-      }
+      Manipulate(RandomParameter.ActualValue, VRPToursParameter.ActualValue as AlbaEncoding);
 
-      return next;
+      return base.Apply();
     }
   }
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/CustomerInsertionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/CustomerInsertionManipulator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/CustomerInsertionManipulator.cs	(revision 4204)
@@ -0,0 +1,67 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("CustomerInsertionManipualtor", "An operator which manipulates an Alba VRP representation by inserting a customer in another place.  It is implemented as described in Alba, E. and Dorronsoro, B. (2004). Solving the Vehicle Routing Problem by Using Cellular Genetic Algorithms.")]
+  [StorableClass]
+  public sealed class CustomerInsertionManipualtor : AlbaManipulator {
+    [StorableConstructor]
+    private CustomerInsertionManipualtor(bool deserializing) : base(deserializing) { }
+
+    public CustomerInsertionManipualtor()
+      : base() {
+    }
+
+    protected override void Manipulate(IRandom random, AlbaEncoding individual) {
+      AlbaEncoding original = (AlbaEncoding)individual.Clone();
+      int cutIndex, insertIndex, number;
+
+      int customer = random.Next(Cities);
+      cutIndex = FindCustomerLocation(customer, individual);
+
+      insertIndex = random.Next(original.Length);
+      number = original[cutIndex];
+
+      int i = 0;  // index in new permutation
+      int j = 0;  // index in old permutation
+      while (i < original.Length) {
+        if (j == cutIndex) {
+          j++;
+        }
+        if (i == insertIndex) {
+          individual[i] = number;
+          i++;
+        }
+        if ((i < original.Length) && (j < original.Length)) {
+          individual[i] = original[j];
+          i++;
+          j++;
+        }
+      }
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/CustomerInversionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/CustomerInversionManipulator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/CustomerInversionManipulator.cs	(revision 4204)
@@ -0,0 +1,63 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("CustomerInversionManipualtor", "An operator which manipulates an Alba VRP representation by inverting the order the customers are visited.  It is implemented as described in Alba, E. and Dorronsoro, B. (2004). Solving the Vehicle Routing Problem by Using Cellular Genetic Algorithms.")]
+  [StorableClass]
+  public sealed class CustomerInversionManipualtor : AlbaManipulator {
+    [StorableConstructor]
+    private CustomerInversionManipualtor(bool deserializing) : base(deserializing) { }
+
+    public CustomerInversionManipualtor()
+      : base() {
+    }
+
+    protected override void Manipulate(IRandom random, AlbaEncoding individual) {
+      int breakPoint1, breakPoint2;
+
+      int customer1 = random.Next(Cities);
+      breakPoint1 = FindCustomerLocation(customer1, individual);
+
+      int customer2 = random.Next(Cities);
+      breakPoint2 = FindCustomerLocation(customer1, individual);
+
+      List<int> visitingOrder = new List<int>();
+      for (int i = breakPoint1; i <= breakPoint2; i++) {
+        if (individual[i] != 0)
+          visitingOrder.Add(individual[i]);
+      }
+      visitingOrder.Reverse();
+      for (int i = breakPoint1; i <= breakPoint2; i++) {
+        if (individual[i] != 0) {
+          individual[i] = visitingOrder[0];
+          visitingOrder.RemoveAt(0);
+        }
+      }
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/CustomerSwapManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/CustomerSwapManipulator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/CustomerSwapManipulator.cs	(revision 4204)
@@ -0,0 +1,53 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("CustomerSwapManipualtor", "An operator which manipulates an Alba VRP representation by swapping two customers.  It is implemented as described in Alba, E. and Dorronsoro, B. (2004). Solving the Vehicle Routing Problem by Using Cellular Genetic Algorithms.")]
+  [StorableClass]
+  public sealed class CustomerSwapManipualtor : AlbaManipulator {
+    [StorableConstructor]
+    private CustomerSwapManipualtor(bool deserializing) : base(deserializing) { }
+
+    public CustomerSwapManipualtor()
+      : base() {
+    }
+
+    protected override void Manipulate(IRandom random, AlbaEncoding individual) {
+      int index1, index2, temp;
+
+      int customer1 = random.Next(Cities);
+      index1 = FindCustomerLocation(customer1, individual);
+
+      int customer2 = random.Next(Cities);
+      index2 = FindCustomerLocation(customer2, individual);
+
+      temp = individual[index1];
+      individual[index1] = individual[index2];
+      individual[index2] = temp;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/LambdaInterchangeManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/LambdaInterchangeManipulator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/LambdaInterchangeManipulator.cs	(revision 4204)
@@ -0,0 +1,121 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using System;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("LambdaInterchangeManipulator", "An operator which applies the lambda interchange operation to an Alba VRP representation.  It is implemented as described in Alba, E. and Dorronsoro, B. (2004). Solving the Vehicle Routing Problem by Using Cellular Genetic Algorithms.")]
+  [StorableClass]
+  public sealed class LambdaInterchangeManipulator : AlbaManipulator {
+    public IValueParameter<IntValue> LambdaParameter {
+      get { return (IValueParameter<IntValue>)Parameters["Lambda"]; }
+    }
+    
+    [StorableConstructor]
+    private LambdaInterchangeManipulator(bool deserializing) : base(deserializing) { }
+
+    public LambdaInterchangeManipulator()
+      : base() {
+        Parameters.Add(new ValueParameter<IntValue>("Lambda", "The lambda value.", new IntValue(1)));
+     }
+
+    public static void Apply(AlbaEncoding individual, int tour1Index, int position1, int length1, 
+      int tour2Index, int position2, int length2) {
+      Tour tour1 = individual.Tours[tour1Index];
+      int tour1Start = -1;
+      for (int i = 0; i < individual.Length; i++) {
+        if (individual[i] == tour1.Cities[0] - 1) {
+          tour1Start = i;
+          break;
+        }
+      }
+
+      Tour tour2 = individual.Tours[tour2Index];
+      int tour2Start = -1;
+      for (int i = 0; i < individual.Length; i++) {
+        if (individual[i] == tour2.Cities[0] - 1) {
+          tour2Start = i;
+          break;
+        }
+      }
+
+      AlbaEncoding original = individual.Clone() as AlbaEncoding;
+      int index = 0;
+
+      int start1 = tour1Start + position1;
+      int end1 = start1 + length1;
+
+      int start2 = tour2Start + position2;
+      int end2 = start2 + length2;
+
+      for (int i = 0; i < original.Length; i++) {
+        if (index == start1) {
+          if (end2 - start2 == 0)
+            index = end1;
+          else
+            index = start2;
+        } else if (index == start2) {
+          if (end1 - start1 == 0)
+            index = end2;
+          else
+            index = start1;
+        } else if (index == end1) {
+          index = end2;
+        } else if (index == end2) {
+          index = end1;
+        }
+
+        individual[i] = original[index];
+
+        index++;
+      }
+    }
+
+    protected override void Manipulate(IRandom rand, AlbaEncoding individual) {
+      int lambda = LambdaParameter.Value.Value;
+      
+      int route1Index = rand.Next(individual.Tours.Count);
+      Tour route1 = individual.Tours[route1Index];
+
+      int route2Index = rand.Next(individual.Tours.Count - 1);
+      if (route2Index >= route1Index)
+        route2Index += 1;
+      Tour route2 = individual.Tours[route2Index];
+
+      int length1 = rand.Next(Math.Min(lambda + 1, route1.Cities.Count + 1));
+      int index1 = rand.Next(route1.Cities.Count - length1 + 1);
+
+      int l2Min = 0;
+      if (length1 == 0)
+        l2Min = 1;
+      int length2 = rand.Next(l2Min, Math.Min(lambda + 1, route2.Cities.Count + 1));
+      int index2 = rand.Next(route2.Cities.Count - length2 + 1);
+
+      Apply(individual, route1Index, index1, length1,
+        route2Index, index2, length2);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/PermutationManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/PermutationManipulator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/PermutationManipulator.cs	(revision 4204)
@@ -0,0 +1,52 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("PermutationManipulator", "An operator which manipulates an Alba VRP representation by using a standard permutation manipulator.")]
+  [StorableClass]
+  public sealed class PermutationManipualtor : AlbaManipulator {
+    public IValueLookupParameter<IPermutationManipulator> InnerManipulatorParameter {
+      get { return (IValueLookupParameter<IPermutationManipulator>)Parameters["InnerManipulator"]; }
+    }
+
+    [StorableConstructor]
+    private PermutationManipualtor(bool deserializing) : base(deserializing) { }
+
+    public PermutationManipualtor()
+      : base() {
+        Parameters.Add(new ValueLookupParameter<IPermutationManipulator>("InnerManipulator", "The permutation manipulator.", new TranslocationManipulator()));
+    }
+
+    protected override void Manipulate(IRandom random, AlbaEncoding individual) {
+      InnerManipulatorParameter.ActualValue.PermutationParameter.ActualName = VRPToursParameter.ActualName;
+
+      IAtomicOperation op = this.ExecutionContext.CreateOperation(
+        InnerManipulatorParameter.ActualValue, this.ExecutionContext.Scope);
+      op.Operator.Execute((IExecutionContext)op);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/SimpleLocalSearchManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/SimpleLocalSearchManipulator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Manipulators/SimpleLocalSearchManipulator.cs	(revision 4204)
@@ -0,0 +1,88 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using System;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("SimpleLocalSearchManipulator", "An operator which applies the SLS operation to an Alba VRP representation.  It is implemented as described in Alba, E. and Dorronsoro, B. (2004). Solving the Vehicle Routing Problem by Using Cellular Genetic Algorithms.")]
+  [StorableClass]
+  public sealed class SimpleLocalSearchManipulator : AlbaManipulator {   
+    [StorableConstructor]
+    private SimpleLocalSearchManipulator(bool deserializing) : base(deserializing) { }
+
+    public SimpleLocalSearchManipulator()
+      : base() {
+     }
+
+    public static void Apply(AlbaEncoding individual, int index1, int index2) {
+      if (index1 != -1 && index2 != -1) {
+        int breakPoint1 = index1 + 1;
+        int breakPoint2 = index2;
+        for (int i = 0; i <= (breakPoint2 - breakPoint1) / 2; i++) {  // invert permutation between breakpoints
+          int temp = individual[breakPoint1 + i];
+          individual[breakPoint1 + i] = individual[breakPoint2 - i];
+          individual[breakPoint2 - i] = temp;
+        }
+      }
+    }
+
+    protected override void Manipulate(IRandom rand, AlbaEncoding individual) {
+      int index1 = -1;
+      int index2 = -1;
+
+      List<Tour> validTours = new List<Tour>();
+      foreach (Tour tour in individual.Tours) {
+        if (tour.Cities.Count >= 4)
+          validTours.Add(tour);
+      }
+
+      if (validTours.Count > 0) {
+        Tour chosenTour = validTours[rand.Next(validTours.Count)];
+        int currentTourStart = -1;
+        for (int i = 0; i < individual.Length; i++) {
+          if (individual[i] + 1 == chosenTour.Cities[0]) {
+            currentTourStart = i;
+            break;
+          }
+        }
+
+        int currentTourEnd = currentTourStart;
+        while (currentTourEnd < individual.Length && 
+          individual[currentTourEnd] < individual.Cities) {
+          currentTourEnd++;
+        }
+
+        int tourLength = currentTourEnd - currentTourStart;
+        int a = rand.Next(tourLength - 3);
+        index1 = currentTourStart + a;
+        index2 = currentTourStart + rand.Next(a + 2, tourLength - 1);
+      }
+
+      Apply(individual, index1, index2);
+    }
+  }
+}
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 4186)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/AlbaMoveOperator.cs	(revision 4204)
@@ -30,7 +30,4 @@
   [StorableClass]
   public abstract class AlbaMoveOperator : VRPMoveOperator {    
-    [Storable]
-    protected abstract IPermutationMoveOperator PermutationMoveOperatorParameter { get; set; }
-
     [StorableConstructor]
     protected AlbaMoveOperator(bool deserializing) : base(deserializing) { }
@@ -47,8 +44,4 @@
       }
 
-      PermutationMoveOperatorParameter.PermutationParameter.ActualName = VRPToursParameter.ActualName;
-      IAtomicOperation op = this.ExecutionContext.CreateChildOperation(PermutationMoveOperatorParameter);
-      op.Operator.Execute((IExecutionContext)op);
-
       return base.Apply();
     }
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/Interfaces/IAlbaLambdaInterchangeMoveOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/Interfaces/IAlbaLambdaInterchangeMoveOperator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/Interfaces/IAlbaLambdaInterchangeMoveOperator.cs	(revision 4204)
@@ -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 HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  public interface IAlbaLambdaInterchangeMoveOperator : IVRPMoveOperator {
+    ILookupParameter<LambdaInterchangeMove> LambdaInterchangeMoveParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/Interfaces/IAlbaSimpleLocalSearchMoveOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/Interfaces/IAlbaSimpleLocalSearchMoveOperator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/Interfaces/IAlbaSimpleLocalSearchMoveOperator.cs	(revision 4204)
@@ -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 HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  public interface IAlbaSimpleLocalSearchMoveOperator : IVRPMoveOperator {
+    ILookupParameter<SimpleLocalSearchMove> SimpleLocalSearchMoveParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/Interfaces/IAlbaTranslocationMoveOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/Interfaces/IAlbaTranslocationMoveOperator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/Interfaces/IAlbaTranslocationMoveOperator.cs	(revision 4204)
@@ -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 HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  public interface IAlbaTranslocationMoveOperator : IVRPMoveOperator {
+    ILookupParameter<TranslocationMove> TranslocationMoveParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/ExhaustiveLambdaInterchangeMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/ExhaustiveLambdaInterchangeMoveGenerator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/ExhaustiveLambdaInterchangeMoveGenerator.cs	(revision 4204)
@@ -0,0 +1,67 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Encodings.Alba;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("ExhaustiveLambdaInterchangeMoveGenerator", "Generates all possible lambda interchange moves from a given Alba VRP encoding.")]
+  [StorableClass]
+  public sealed class ExhaustiveLambdaInterchangeMoveGenerator : LambdaInterchangeMoveGenerator, IExhaustiveMoveGenerator, IAlbaLambdaInterchangeMoveOperator {
+    [StorableConstructor]
+    private ExhaustiveLambdaInterchangeMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public ExhaustiveLambdaInterchangeMoveGenerator()
+      : base() {
+    }
+
+    protected override LambdaInterchangeMove[] GenerateMoves(AlbaEncoding individual, int lambda) {
+      List<LambdaInterchangeMove> moves = new List<LambdaInterchangeMove>();
+
+      for (int tour1Index = 0; tour1Index < individual.Tours.Count; tour1Index++) {
+        Tour tour1 = individual.Tours[tour1Index];
+        for (int tour2Index = tour1Index + 1; tour2Index < individual.Tours.Count; tour2Index++) {
+          Tour tour2 = individual.Tours[tour2Index];
+
+          for (int length1 = 0; length1 <= Math.Min(lambda, tour1.Cities.Count); length1++) {
+            for(int length2 = 0; length2 <= Math.Min(lambda, tour2.Cities.Count); length2++) {
+              if(length1 != 0 || length2 != 0) {
+                for(int index1 = 0; index1 < tour1.Cities.Count - length1 + 1; index1++) {
+                  for(int index2 = 0; index2 < tour2.Cities.Count - length2 + 1; index2++) {
+                    moves.Add(new LambdaInterchangeMove(tour1Index, index1, length1, 
+                      tour2Index, index2, length2));
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      return moves.ToArray();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMove.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMove.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMove.cs	(revision 4204)
@@ -0,0 +1,86 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("InversionMove", "Item that describes a lambda move on an Alba VRP representation.")]
+  [StorableClass]
+  public class LambdaInterchangeMove: Item {
+    [Storable]
+    public int Tour1 { get; protected set; }
+
+    [Storable]
+    public int Position1 { get; protected set; }
+
+    [Storable]
+    public int Length1 { get; protected set; }
+
+    [Storable]
+    public int Tour2 { get; protected set; }
+
+    [Storable]
+    public int Position2 { get; protected set; }
+
+    [Storable]
+    public int Length2 { get; protected set; }
+    
+    public LambdaInterchangeMove(): base() {
+      Tour1 = -1;
+      Position1 = -1;
+      Length1 = -1;
+
+      Tour2 = -1;
+      Position2 = -1;
+      Length2 = -1;
+    }
+
+    public LambdaInterchangeMove(int tour1, int position1, int length1, 
+      int tour2, int position2, int length2) {
+        Tour1 = tour1;
+        Position1 = position1;
+        Length1 = length1;
+
+        Tour2 = tour2;
+        Position2 = position2;
+        Length2 = length2;
+    }
+
+    public override IDeepCloneable Clone(HeuristicLab.Common.Cloner cloner) {
+      LambdaInterchangeMove clone = new LambdaInterchangeMove();
+
+      clone.Tour1 = Tour1;
+      clone.Position1 = Position1;
+      clone.Length1 = Length1;
+
+      clone.Tour2 = Tour2;
+      clone.Position2 = Position2;
+      clone.Length2 = Length2;
+
+      cloner.RegisterClonedObject(this, clone);
+      return clone;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMoveEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMoveEvaluator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMoveEvaluator.cs	(revision 4204)
@@ -0,0 +1,58 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Encodings.Alba;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  [Item("LambdaInterchangeMoveEvaluator", "Evaluates a lamnbda interchange move for the Alba representation.")]
+  [StorableClass]
+  public sealed class LambdaInterchangeMoveEvaluator : VRPMoveEvaluator, IAlbaLambdaInterchangeMoveOperator {
+    public ILookupParameter<LambdaInterchangeMove> LambdaInterchangeMoveParameter {
+      get { return (ILookupParameter<LambdaInterchangeMove>)Parameters["LambdaInterchangeMove"]; }
+    }
+
+    [StorableConstructor]
+    private LambdaInterchangeMoveEvaluator(bool deserializing) : base(deserializing) { }
+
+    public LambdaInterchangeMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<LambdaInterchangeMove>("LambdaInterchangeMove", "The move to evaluate."));
+    }
+
+    protected override TourEvaluation GetMoveQuality() {
+      LambdaInterchangeMove move = LambdaInterchangeMoveParameter.ActualValue;
+      //perform move
+      AlbaEncoding newSolution = VRPToursParameter.ActualValue.Clone() as AlbaEncoding;
+      LambdaInterchangeMoveMaker.Apply(newSolution, move);
+
+      return VRPEvaluator.Evaluate(
+        newSolution,
+        DueTimeParameter.ActualValue, ServiceTimeParameter.ActualValue, ReadyTimeParameter.ActualValue,
+        DemandParameter.ActualValue, CapacityParameter.ActualValue,
+        FleetUsageFactor.ActualValue, TimeFactor.ActualValue, DistanceFactor.ActualValue, OverloadPenalty.ActualValue, TardinessPenalty.ActualValue,
+        CoordinatesParameter.ActualValue, DistanceMatrixParameter, UseDistanceMatrixParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMoveGenerator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMoveGenerator.cs	(revision 4204)
@@ -0,0 +1,78 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Encodings.Alba;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("LambdaInterchangeMoveGenerator", "Generates lambda interchange moves from a given Alba VRP encoding.")]
+  [StorableClass]
+  public abstract class LambdaInterchangeMoveGenerator : AlbaMoveOperator, IExhaustiveMoveGenerator, IAlbaLambdaInterchangeMoveOperator {
+    #region IAlbaLambdaInterchangeMoveOperator Members
+
+    public ILookupParameter<LambdaInterchangeMove> LambdaInterchangeMoveParameter {
+      get { return (ILookupParameter<LambdaInterchangeMove>)Parameters["LambdaInterchangeMove"]; }
+    }
+
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    public IValueParameter<IntValue> LambdaParameter {
+      get { return (IValueParameter<IntValue>)Parameters["Lambda"]; }
+    }
+
+    #endregion
+
+    [StorableConstructor]
+    protected LambdaInterchangeMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public LambdaInterchangeMoveGenerator()
+      : base() {
+        Parameters.Add(new LookupParameter<LambdaInterchangeMove>("LambdaInterchangeMove", "The moves that should be generated in subscopes."));
+        Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
+        Parameters.Add(new ValueParameter<IntValue>("Lambda", "The lambda value.", new IntValue(1)));
+    }
+
+    protected abstract LambdaInterchangeMove[] GenerateMoves(AlbaEncoding individual, int lambda);
+
+    public override IOperation Apply() {
+      IOperation next = base.Apply();
+
+      AlbaEncoding individual = VRPToursParameter.ActualValue as AlbaEncoding;
+      LambdaInterchangeMove[] moves = GenerateMoves(individual, LambdaParameter.Value.Value);
+      Scope[] moveScopes = new Scope[moves.Length];
+      for (int i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        moveScopes[i].Variables.Add(new Variable(LambdaInterchangeMoveParameter.ActualName, moves[i]));
+      }
+      CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
+
+      return next;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMoveMaker.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMoveMaker.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/LambdaInterchangeMoveMaker.cs	(revision 4204)
@@ -0,0 +1,81 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("LambdaInterchangeMoveMaker", "Peforms a lambda interchange moves on a given Alba VRP encoding and updates the quality.")]
+  [StorableClass]
+  public class LambdaInterchangeMoveMaker : AlbaMoveMaker, IAlbaLambdaInterchangeMoveOperator, IMoveMaker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<LambdaInterchangeMove> LambdaInterchangeMoveParameter {
+      get { return (ILookupParameter<LambdaInterchangeMove>)Parameters["LambdaInterchangeMove"]; }
+    }
+
+    [StorableConstructor]
+    private LambdaInterchangeMoveMaker(bool deserializing) : base(deserializing) { }
+
+    public LambdaInterchangeMoveMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
+      Parameters.Add(new LookupParameter<LambdaInterchangeMove>("LambdaInterchangeMove", "The move to make."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The relative quality of the move."));
+    }
+
+    public static void Apply(AlbaEncoding solution, LambdaInterchangeMove move) {
+      LambdaInterchangeManipulator.Apply(
+        solution,
+        move.Tour1, move.Position1, move.Length1,
+        move.Tour2, move.Position2, move.Length2);
+    }
+
+    public override IOperation Apply() {
+      IOperation next = base.Apply();
+      
+      AlbaEncoding solution = VRPToursParameter.ActualValue as AlbaEncoding;
+
+      LambdaInterchangeMove move = LambdaInterchangeMoveParameter.ActualValue;
+      DoubleValue moveQuality = MoveQualityParameter.ActualValue;
+      DoubleValue quality = QualityParameter.ActualValue;
+     
+      //perform move
+      Apply(solution, move);
+
+      quality.Value = moveQuality.Value;
+
+      return next;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/StochasticLambdaInterchangeMutliMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/StochasticLambdaInterchangeMutliMoveGenerator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/StochasticLambdaInterchangeMutliMoveGenerator.cs	(revision 4204)
@@ -0,0 +1,64 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Encodings.Alba;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("StochasticLambdaInterchangeMultiMoveGenerator", "Generates multiple random lambda interchange moves from a given Alba VRP encoding.")]
+  [StorableClass]
+  public sealed class StochasticLambdaInterchangeMultiMoveGenerator : LambdaInterchangeMoveGenerator, IStochasticOperator, IMultiMoveGenerator, IAlbaLambdaInterchangeMoveOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+    
+    [StorableConstructor]
+    private StochasticLambdaInterchangeMultiMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public StochasticLambdaInterchangeMultiMoveGenerator()
+      : base() {
+        Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+        Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));
+    }
+
+    protected override LambdaInterchangeMove[] GenerateMoves(AlbaEncoding individual, int lambda) {
+      int sampleSize = SampleSizeParameter.ActualValue.Value;
+
+      LambdaInterchangeMove[] moves = new LambdaInterchangeMove[sampleSize];
+      for (int i = 0; i < sampleSize; i++) {
+        moves[i] = StochasticLambdaInterchangeSingleMoveGenerator.Apply(
+          individual, Cities, lambda, RandomParameter.ActualValue);
+      }
+
+      return moves;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/StochasticLambdaInterchangeSingleMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/StochasticLambdaInterchangeSingleMoveGenerator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/LambdaInterchange/StochasticLambdaInterchangeSingleMoveGenerator.cs	(revision 4204)
@@ -0,0 +1,77 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Encodings.Alba;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("StochasticLambdaInterchangeSingleMoveGenerator", "Generates one random lambda interchange move from a given Alba VRP encoding.")]
+  [StorableClass]
+  public sealed class StochasticLambdaInterchangeSingleMoveGenerator : LambdaInterchangeMoveGenerator, IStochasticOperator, ISingleMoveGenerator, IAlbaLambdaInterchangeMoveOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    
+    [StorableConstructor]
+    private StochasticLambdaInterchangeSingleMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public StochasticLambdaInterchangeSingleMoveGenerator()
+      : base() {
+        Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+    }
+
+    public static LambdaInterchangeMove Apply(AlbaEncoding individual, int cities, int lambda, IRandom rand) {
+      int route1Index = rand.Next(individual.Tours.Count);
+      Tour route1 = individual.Tours[route1Index];
+
+      int route2Index = rand.Next(individual.Tours.Count - 1);
+      if (route2Index >= route1Index)
+        route2Index += 1;
+      Tour route2 = individual.Tours[route2Index];
+
+      int length1 = rand.Next(Math.Min(lambda + 1, route1.Cities.Count + 1));
+      int index1 = rand.Next(route1.Cities.Count - length1 + 1);
+
+      int l2Min = 0;
+      if (length1 == 0)
+        l2Min = 1;
+      int length2 = rand.Next(l2Min, Math.Min(lambda + 1, route2.Cities.Count + 1));
+      int index2 = rand.Next(route2.Cities.Count - length2 + 1);
+
+      return new LambdaInterchangeMove(route1Index, index1, length1, route2Index, index2, length2);
+    }
+
+    protected override LambdaInterchangeMove[] GenerateMoves(AlbaEncoding individual, int lambda) {
+      List<LambdaInterchangeMove> moves = new List<LambdaInterchangeMove>();
+
+      LambdaInterchangeMove move = Apply(individual, Cities, lambda, RandomParameter.ActualValue);
+      if(move != null)
+        moves.Add(move);
+
+      return moves.ToArray();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/PermutationMoveOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/PermutationMoveOperator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/PermutationMoveOperator.cs	(revision 4204)
@@ -0,0 +1,55 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("PermutationMoveOperator", "A move operator for an Alba VRP representation using an inner permutation move operator.")]
+  [StorableClass]
+  public abstract class PermutationMoveOperator : AlbaMoveOperator {    
+    [Storable]
+    protected abstract IPermutationMoveOperator PermutationMoveOperatorParameter { get; set; }
+
+    [StorableConstructor]
+    protected PermutationMoveOperator(bool deserializing) : base(deserializing) { }
+
+    public PermutationMoveOperator()
+      : base() 
+    {
+    }
+
+    public override IOperation Apply() {
+      IOperation next = base.Apply();
+      
+      IVRPEncoding solution = VRPToursParameter.ActualValue;
+
+      PermutationMoveOperatorParameter.PermutationParameter.ActualName = VRPToursParameter.ActualName;
+      IAtomicOperation op = this.ExecutionContext.CreateChildOperation(PermutationMoveOperatorParameter);
+      op.Operator.Execute((IExecutionContext)op);
+
+      return next;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/ExhaustiveSimpleLocalSearchMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/ExhaustiveSimpleLocalSearchMoveGenerator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/ExhaustiveSimpleLocalSearchMoveGenerator.cs	(revision 4204)
@@ -0,0 +1,73 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Encodings.Alba;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("ExhaustiveSimpleLocalSearchMoveGenerator", "Generates all possible simple local search moves from a given Alba VRP encoding.")]
+  [StorableClass]
+  public sealed class ExhaustiveSimpleLocalSearchMoveGenerator : SimpleLocalSearchMoveGenerator, IExhaustiveMoveGenerator, IAlbaSimpleLocalSearchMoveOperator {
+    [StorableConstructor]
+    private ExhaustiveSimpleLocalSearchMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public ExhaustiveSimpleLocalSearchMoveGenerator()
+      : base() {
+    }
+
+    protected override SimpleLocalSearchMove[] GenerateMoves(AlbaEncoding individual) {
+      List<SimpleLocalSearchMove> moves = new List<SimpleLocalSearchMove>();
+
+      int currentTourStart = 0;
+      int currentTourEnd = 0;
+      while(currentTourEnd != individual.Length) {
+        currentTourEnd = currentTourStart;
+        while (individual[currentTourEnd] < individual.Cities && 
+          currentTourEnd < individual.Length) {
+          currentTourEnd++;
+        }
+
+        int tourLength = currentTourEnd - currentTourStart;
+        if (tourLength >= 4) {
+          for (int i = 0; i <= tourLength - 4; i++ ) {
+            for (int j = i + 2; j <= tourLength - 2; j++) {
+              SimpleLocalSearchMove move = new SimpleLocalSearchMove(
+                currentTourStart + i, 
+                currentTourStart + j, 
+                individual);
+
+              moves.Add(move);
+            }
+          }
+        }
+
+        currentTourStart = currentTourEnd;
+      }
+
+      return moves.ToArray();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/SimpleLocalSearchMove.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/SimpleLocalSearchMove.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/SimpleLocalSearchMove.cs	(revision 4204)
@@ -0,0 +1,54 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("InversionMove", "Item that describes a simple local search move on an Alba VRP representation.")]
+  [StorableClass]
+  public class SimpleLocalSearchMove : TwoIndexMove {
+    public SimpleLocalSearchMove()
+      : base() {
+    }
+
+    public SimpleLocalSearchMove(int index1, int index2)
+      : base(index1, index2, null) {
+    }
+
+    public SimpleLocalSearchMove(int index1, int index2, AlbaEncoding permutation)
+      : base(index1, index2, permutation) {
+    }
+
+    public override IDeepCloneable Clone(HeuristicLab.Common.Cloner cloner) {
+      SimpleLocalSearchMove clone = new SimpleLocalSearchMove(
+        Index1, Index2);
+
+      if (Permutation != null)
+        clone.Permutation = (AlbaEncoding)cloner.Clone(Permutation);
+
+      cloner.RegisterClonedObject(this, clone);
+      return clone;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/SimpleLocalSearchMoveEvaluator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/SimpleLocalSearchMoveEvaluator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/SimpleLocalSearchMoveEvaluator.cs	(revision 4204)
@@ -0,0 +1,58 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Encodings.Alba;
+
+namespace HeuristicLab.Problems.VehicleRouting {
+  [Item("SimpleLocalSearchMoveEvaluator", "Evaluates a simple local search move for the Alba representation.")]
+  [StorableClass]
+  public sealed class SimpleLocalSearchMoveEvaluator : VRPMoveEvaluator, IAlbaSimpleLocalSearchMoveOperator {
+    public ILookupParameter<SimpleLocalSearchMove> SimpleLocalSearchMoveParameter {
+      get { return (ILookupParameter<SimpleLocalSearchMove>)Parameters["SimpleLocalSearchMove"]; }
+    }
+
+    [StorableConstructor]
+    private SimpleLocalSearchMoveEvaluator(bool deserializing) : base(deserializing) { }
+
+    public SimpleLocalSearchMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<SimpleLocalSearchMove>("SimpleLocalSearchMove", "The move to evaluate."));
+    }
+
+    protected override TourEvaluation GetMoveQuality() {
+      SimpleLocalSearchMove move = SimpleLocalSearchMoveParameter.ActualValue;
+      //perform move
+      AlbaEncoding newSolution = VRPToursParameter.ActualValue.Clone() as AlbaEncoding;
+      SimpleLocalSearchMoveMaker.Apply(newSolution, move);
+
+      return VRPEvaluator.Evaluate(
+        newSolution,
+        DueTimeParameter.ActualValue, ServiceTimeParameter.ActualValue, ReadyTimeParameter.ActualValue,
+        DemandParameter.ActualValue, CapacityParameter.ActualValue,
+        FleetUsageFactor.ActualValue, TimeFactor.ActualValue, DistanceFactor.ActualValue, OverloadPenalty.ActualValue, TardinessPenalty.ActualValue,
+        CoordinatesParameter.ActualValue, DistanceMatrixParameter, UseDistanceMatrixParameter.ActualValue);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/SimpleLocalSearchMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/SimpleLocalSearchMoveGenerator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/SimpleLocalSearchMoveGenerator.cs	(revision 4204)
@@ -0,0 +1,72 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Encodings.Alba;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("SimpleLocalSearchMoveGenerator", "Generates local search moves from a given Alba VRP encoding.")]
+  [StorableClass]
+  public abstract class SimpleLocalSearchMoveGenerator : AlbaMoveOperator, IExhaustiveMoveGenerator, IAlbaSimpleLocalSearchMoveOperator {
+    #region IAlbaSimpleLocalSearchMoveOperator Members
+
+    public ILookupParameter<SimpleLocalSearchMove> SimpleLocalSearchMoveParameter {
+      get { return (ILookupParameter<SimpleLocalSearchMove>)Parameters["SimpleLocalSearchMove"]; }
+    }
+
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    #endregion
+
+    [StorableConstructor]
+    protected SimpleLocalSearchMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public SimpleLocalSearchMoveGenerator()
+      : base() {
+        Parameters.Add(new LookupParameter<SimpleLocalSearchMove>("SimpleLocalSearchMove", "The moves that should be generated in subscopes."));
+        Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
+    }
+
+    protected abstract SimpleLocalSearchMove[] GenerateMoves(AlbaEncoding individual);
+
+    public override IOperation Apply() {
+      IOperation next = base.Apply();
+
+      AlbaEncoding individual = VRPToursParameter.ActualValue as AlbaEncoding;
+      SimpleLocalSearchMove[] moves = GenerateMoves(individual);
+      Scope[] moveScopes = new Scope[moves.Length];
+      for (int i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        moveScopes[i].Variables.Add(new Variable(SimpleLocalSearchMoveParameter.ActualName, moves[i]));
+      }
+      CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
+
+      return next;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/SimpleLocalSearchMoveMaker.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/SimpleLocalSearchMoveMaker.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/SimpleLocalSearchMoveMaker.cs	(revision 4204)
@@ -0,0 +1,77 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("SimpleLocalSearchMoveMaker", "Peforms a simple local search moves on a given Alba VRP encoding and updates the quality.")]
+  [StorableClass]
+  public class SimpleLocalSearchMoveMaker : AlbaMoveMaker, IAlbaSimpleLocalSearchMoveOperator, IMoveMaker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<SimpleLocalSearchMove> SimpleLocalSearchMoveParameter {
+      get { return (ILookupParameter<SimpleLocalSearchMove>)Parameters["SimpleLocalSearchMove"]; }
+    }
+
+    [StorableConstructor]
+    private SimpleLocalSearchMoveMaker(bool deserializing) : base(deserializing) { }
+
+    public SimpleLocalSearchMoveMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
+      Parameters.Add(new LookupParameter<SimpleLocalSearchMove>("SimpleLocalSearchMove", "The move to make."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The relative quality of the move."));
+    }
+
+    public static void Apply(AlbaEncoding solution, SimpleLocalSearchMove move) {
+      SimpleLocalSearchManipulator.Apply(solution, move.Index1, move.Index2);
+    }
+
+    public override IOperation Apply() {
+      IOperation next = base.Apply();
+      
+      AlbaEncoding solution = VRPToursParameter.ActualValue as AlbaEncoding;
+
+      SimpleLocalSearchMove move = SimpleLocalSearchMoveParameter.ActualValue;
+      DoubleValue moveQuality = MoveQualityParameter.ActualValue;
+      DoubleValue quality = QualityParameter.ActualValue;
+     
+      //perform move
+      Apply(solution, move);
+
+      quality.Value = moveQuality.Value;
+
+      return next;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/StochasticSimpleLocalSearchMutliMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/StochasticSimpleLocalSearchMutliMoveGenerator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/StochasticSimpleLocalSearchMutliMoveGenerator.cs	(revision 4204)
@@ -0,0 +1,64 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Encodings.Alba;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("StochasticSimpleLocalSearchMultiMoveGenerator", "Generates multiple random simple local search moves from a given Alba VRP encoding.")]
+  [StorableClass]
+  public sealed class StochasticSimpleLocalSearchMultiMoveGenerator : SimpleLocalSearchMoveGenerator, IStochasticOperator, IMultiMoveGenerator, IAlbaSimpleLocalSearchMoveOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+    
+    [StorableConstructor]
+    private StochasticSimpleLocalSearchMultiMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public StochasticSimpleLocalSearchMultiMoveGenerator()
+      : base() {
+        Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+        Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));
+    }
+
+    protected override SimpleLocalSearchMove[] GenerateMoves(AlbaEncoding individual) {
+      int sampleSize = SampleSizeParameter.ActualValue.Value;
+
+      SimpleLocalSearchMove[] moves = new SimpleLocalSearchMove[sampleSize];
+      for (int i = 0; i < sampleSize; i++) {
+        moves[i] = StochasticSimpleLocalSearchSingleMoveGenerator.Apply(
+          individual, Cities, RandomParameter.ActualValue);
+      }
+
+      return moves;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/StochasticSimpleLocalSearchSingleMoveGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/StochasticSimpleLocalSearchSingleMoveGenerator.cs	(revision 4204)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/SimpleLocalSearch/StochasticSimpleLocalSearchSingleMoveGenerator.cs	(revision 4204)
@@ -0,0 +1,91 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.VehicleRouting.Encodings.Alba;
+using HeuristicLab.Parameters;
+using System.Collections.Generic;
+
+namespace HeuristicLab.Problems.VehicleRouting.Encodings.Alba {
+  [Item("StochasticSimpleLocalSearchSingleMoveGenerator", "Generates one random simple local search move from a given Alba VRP encoding.")]
+  [StorableClass]
+  public sealed class StochasticSimpleLocalSearchSingleMoveGenerator : SimpleLocalSearchMoveGenerator, IStochasticOperator, ISingleMoveGenerator, IAlbaSimpleLocalSearchMoveOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    
+    [StorableConstructor]
+    private StochasticSimpleLocalSearchSingleMoveGenerator(bool deserializing) : base(deserializing) { }
+
+    public StochasticSimpleLocalSearchSingleMoveGenerator()
+      : base() {
+        Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+    }
+
+    public static SimpleLocalSearchMove Apply(AlbaEncoding individual, int cities, IRandom rand) {
+      int index1 = -1;
+      int index2 = -1;
+
+      List<Tour> validTours = new List<Tour>();
+      foreach (Tour tour in individual.Tours) {
+        if (tour.Cities.Count >= 4)
+          validTours.Add(tour);
+      }
+
+      if (validTours.Count > 0) {
+        Tour chosenTour = validTours[rand.Next(validTours.Count)];
+        int currentTourStart = -1;
+        for (int i = 0; i < individual.Length; i++) {
+          if (individual[i] + 1 == chosenTour.Cities[0]) {
+            currentTourStart = i;
+            break;
+          }
+        }
+
+        int currentTourEnd = currentTourStart;
+        while (individual[currentTourEnd] < individual.Cities &&
+            currentTourEnd < individual.Length) {
+          currentTourEnd++;
+        }
+
+        int tourLength = currentTourEnd - currentTourStart;
+        int a = rand.Next(tourLength - 3);
+        index1 = currentTourStart + a;
+        index2 = currentTourStart + rand.Next(a + 2, tourLength - 1);
+      }
+
+      return new SimpleLocalSearchMove(index1, index2, individual);
+    }
+
+    protected override SimpleLocalSearchMove[] GenerateMoves(AlbaEncoding individual) {
+      List<SimpleLocalSearchMove> moves = new List<SimpleLocalSearchMove>();
+
+      SimpleLocalSearchMove move = Apply(individual, Cities, RandomParameter.ActualValue);
+      if(move != null)
+        moves.Add(move);
+
+      return moves.ToArray();
+    }
+  }
+}
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 4186)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveEvaluator.cs	(revision 4204)
@@ -29,5 +29,5 @@
   [Item("AlbaTranslocationMoveEvaluator", "Evaluates a translocation or insertion move (3-opt) for the Alba representation.")]
   [StorableClass]
-  public sealed class AlbaTranslocationMoveEvaluator : VRPMoveEvaluator {
+  public sealed class AlbaTranslocationMoveEvaluator : VRPMoveEvaluator, IAlbaTranslocationMoveOperator {
     public ILookupParameter<TranslocationMove> TranslocationMoveParameter {
       get { return (ILookupParameter<TranslocationMove>)Parameters["TranslocationMove"]; }
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 4186)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveGenerator.cs	(revision 4204)
@@ -31,5 +31,5 @@
   [Item("AlbaTranslocationMoveGenerator", "An operator which generates translocation moves for the Alba representation.")]
   [StorableClass]
-  public sealed class AlbaTranslocationMoveGenerator : AlbaMoveOperator, IAlbaTranslocationMoveOperator, IMultiMoveGenerator {
+  public sealed class AlbaTranslocationMoveGenerator : PermutationMoveOperator, IAlbaTranslocationMoveOperator, IMultiMoveGenerator {
     public IValueLookupParameter<TranslocationMoveGenerator> TranslocationMoveGeneratorParameter {
       get { return (IValueLookupParameter<TranslocationMoveGenerator>)Parameters["TranslocationMoveGenerator"]; }
@@ -86,35 +86,4 @@
       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] >= Cities &&
-                permutation[move.Index1 - 1] >= Cities &&
-                permutation[move.Index3 - 1] >= Cities);
-
-            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] >= Cities &&
-                permutation[move.Index2 + 1] >= Cities &&
-                permutation[index3] >= Cities);
-
-            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 4186)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveHardTabuCriterion.cs	(revision 4204)
@@ -29,5 +29,5 @@
   [Item("AlbaTranslocationMoveHardTabuCriterion", "An operator which checks if translocation moves are tabu using a hard criterion for the Alba representation.")]
   [StorableClass]
-  public sealed class AlbaTranslocationMoveHardTabuCriterion : AlbaMoveOperator, IAlbaTranslocationMoveOperator, ITabuChecker {
+  public sealed class AlbaTranslocationMoveHardTabuCriterion : PermutationMoveOperator, IAlbaTranslocationMoveOperator, ITabuChecker {
     private TranslocationMoveHardTabuCriterion tabuChecker;
     protected override IPermutationMoveOperator PermutationMoveOperatorParameter {
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 4186)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveMaker.cs	(revision 4204)
@@ -31,8 +31,4 @@
   public sealed class AlbaTranslocationMoveMaker : AlbaMoveMaker, IAlbaTranslocationMoveOperator, IVRPMoveMaker {
     private TranslocationMoveMaker moveMaker;
-    protected override IPermutationMoveOperator PermutationMoveOperatorParameter {
-      get { return moveMaker; }
-      set { moveMaker = value as TranslocationMoveMaker; }
-    }
 
     public ILookupParameter<TranslocationMove> TranslocationMoveParameter {
@@ -59,4 +55,16 @@
       moveMaker = new TranslocationMoveMaker();
     }
+
+    public override IOperation Apply() {
+      IOperation next = base.Apply();
+
+      IVRPEncoding solution = VRPToursParameter.ActualValue;
+
+      moveMaker.PermutationParameter.ActualName = VRPToursParameter.ActualName;
+      IAtomicOperation op = this.ExecutionContext.CreateChildOperation(moveMaker);
+      op.Operator.Execute((IExecutionContext)op);
+
+      return next;
+    }
   }
 }
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 4186)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveSoftTabuCriterion.cs	(revision 4204)
@@ -29,5 +29,5 @@
   [Item("AlbaTranslocationMoveSoftTabuCriterion", "An operator which checks if translocation moves are tabu using a soft criterion for the Alba representation.")]
   [StorableClass]
-  public sealed class AlbaTranslocationMoveSoftTabuCriterion : AlbaMoveOperator, IAlbaTranslocationMoveOperator, ITabuChecker {
+  public sealed class AlbaTranslocationMoveSoftTabuCriterion : PermutationMoveOperator, IAlbaTranslocationMoveOperator, ITabuChecker {
     private TranslocationMoveSoftTabuCriterion tabuChecker;
     protected override IPermutationMoveOperator PermutationMoveOperatorParameter {
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 4186)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/Encodings/Alba/Moves/ThreeOpt/AlbaTranslocationMoveTabuMaker.cs	(revision 4204)
@@ -29,5 +29,5 @@
   [Item("AlbaTranslocationMoveTabuMaker", "An operator which makes translocation moves tabu for the Alba representation.")]
   [StorableClass]
-  public sealed class AlbaTranslocationMoveTabuMaker : AlbaMoveOperator, IAlbaTranslocationMoveOperator, ITabuMaker {
+  public sealed class AlbaTranslocationMoveTabuMaker : PermutationMoveOperator, IAlbaTranslocationMoveOperator, ITabuMaker {
     private TranslocationMoveTabuMaker moveTabuMaker;
     protected override IPermutationMoveOperator PermutationMoveOperatorParameter {
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 4186)
+++ trunk/sources/HeuristicLab.Problems.VehicleRouting/3.3/HeuristicLab.Problems.VehicleRouting-3.3.csproj	(revision 4204)
@@ -107,4 +107,28 @@
   <ItemGroup>
     <Compile Include="Analyzers\BestVRPSolutionAnalyzer.cs" />
+    <Compile Include="Encodings\Alba\Crossovers\PermutationCrossover.cs" />
+    <Compile Include="Encodings\Alba\Manipulators\SimpleLocalSearchManipulator.cs" />
+    <Compile Include="Encodings\Alba\Manipulators\LambdaInterchangeManipulator.cs" />
+    <Compile Include="Encodings\Alba\Moves\Interfaces\IAlbaLambdaInterchangeMoveOperator.cs" />
+    <Compile Include="Encodings\Alba\Moves\Interfaces\IAlbaSimpleLocalSearchMoveOperator.cs" />
+    <Compile Include="Encodings\Alba\Manipulators\CustomerInversionManipulator.cs" />
+    <Compile Include="Encodings\Alba\Manipulators\CustomerSwapManipulator.cs" />
+    <Compile Include="Encodings\Alba\Manipulators\CustomerInsertionManipulator.cs" />
+    <Compile Include="Encodings\Alba\Manipulators\PermutationManipulator.cs" />
+    <Compile Include="Encodings\Alba\Moves\LambdaInterchange\ExhaustiveLambdaInterchangeMoveGenerator.cs" />
+    <Compile Include="Encodings\Alba\Moves\LambdaInterchange\LambdaInterchangeMove.cs" />
+    <Compile Include="Encodings\Alba\Moves\LambdaInterchange\LambdaInterchangeMoveGenerator.cs" />
+    <Compile Include="Encodings\Alba\Moves\LambdaInterchange\LambdaInterchangeMoveEvaluator.cs" />
+    <Compile Include="Encodings\Alba\Moves\LambdaInterchange\LambdaInterchangeMoveMaker.cs" />
+    <Compile Include="Encodings\Alba\Moves\LambdaInterchange\StochasticLambdaInterchangeSingleMoveGenerator.cs" />
+    <Compile Include="Encodings\Alba\Moves\LambdaInterchange\StochasticLambdaInterchangeMutliMoveGenerator.cs" />
+    <Compile Include="Encodings\Alba\Moves\PermutationMoveOperator.cs" />
+    <Compile Include="Encodings\Alba\Moves\SimpleLocalSearch\StochasticSimpleLocalSearchMutliMoveGenerator.cs" />
+    <Compile Include="Encodings\Alba\Moves\SimpleLocalSearch\StochasticSimpleLocalSearchSingleMoveGenerator.cs" />
+    <Compile Include="Encodings\Alba\Moves\SimpleLocalSearch\SimpleLocalSearchMoveGenerator.cs" />
+    <Compile Include="Encodings\Alba\Moves\SimpleLocalSearch\SimpleLocalSearchMoveEvaluator.cs" />
+    <Compile Include="Encodings\Alba\Moves\SimpleLocalSearch\ExhaustiveSimpleLocalSearchMoveGenerator.cs" />
+    <Compile Include="Encodings\Alba\Moves\SimpleLocalSearch\SimpleLocalSearchMoveMaker.cs" />
+    <Compile Include="Encodings\Alba\Moves\SimpleLocalSearch\SimpleLocalSearchMove.cs" />
     <Compile Include="Encodings\General\Crossovers\MultiVRPManipulator.cs" />
     <Compile Include="Encodings\General\Crossovers\MultiVRPCrossover.cs" />
@@ -124,5 +148,5 @@
     <Compile Include="Encodings\General\Creators\DefaultRepresentationCreator.cs" />
     <Compile Include="Encodings\Alba\Crossovers\AlbaCrossover.cs" />
-    <Compile Include="Encodings\Alba\Interfaces\IAlbaTranslocationMoveOperator.cs" />
+    <Compile Include="Encodings\Alba\Moves\Interfaces\IAlbaTranslocationMoveOperator.cs" />
     <Compile Include="Encodings\Alba\Manipulators\AlbaManipulator.cs" />
     <Compile Include="Encodings\Alba\Moves\AlbaMoveOperator.cs" />
