Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Creators/ExactGroupsLinearLinkageCreator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Creators/ExactGroupsLinearLinkageCreator.cs	(revision 12643)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Creators/ExactGroupsLinearLinkageCreator.cs	(revision 12643)
@@ -0,0 +1,74 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("Exactgroups Linear Linkage Creator", "Creates a random linear linkage LLE encoded solution with a given number of equal-sized groups.")]
+  [StorableClass]
+  public sealed class ExactGroupsLinearLinkageCreator : LinearLinkageCreator {
+
+    public IValueLookupParameter<IntValue> ExactGroupsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["ExactGroups"]; }
+    }
+
+    public IntValue ExactGroups {
+      get { return ExactGroupsParameter.Value; }
+      set { ExactGroupsParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    private ExactGroupsLinearLinkageCreator(bool deserializing) : base(deserializing) { }
+    private ExactGroupsLinearLinkageCreator(ExactGroupsLinearLinkageCreator original, Cloner cloner) : base(original, cloner) { }
+
+    public ExactGroupsLinearLinkageCreator() {
+      Parameters.Add(new ValueLookupParameter<IntValue>("ExactGroups", "The exact number of equal-sized groups to create.", new IntValue(3)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExactGroupsLinearLinkageCreator(this, cloner);
+    }
+
+    public static LinearLinkage Apply(IRandom random, int length, int groups) {
+      var solution = new LinearLinkage(length);
+      var groupNumbers = Enumerable.Range(0, length).Select(x => x % groups).Shuffle(random);
+      var grouping = Enumerable.Range(0, groups).Select(x => new List<int>()).ToList();
+      var idx = 0;
+      foreach (var g in groupNumbers)
+        grouping[g].Add(idx++);
+
+      solution.SetGroups(grouping);
+      return solution;
+    }
+
+    protected override LinearLinkage Create(IRandom random, int length) {
+      var groups = ExactGroupsParameter.ActualValue.Value;
+      return Apply(random, length, groups);
+    }
+  }
+}
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Creators/MaxGroupsLinearLinkageCreator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Creators/MaxGroupsLinearLinkageCreator.cs	(revision 12643)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Creators/MaxGroupsLinearLinkageCreator.cs	(revision 12643)
@@ -0,0 +1,70 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("Maxgroups Linear Linkage Creator", "Creates a random linear linkage LLE encoded solution with a given maximum number of groups.")]
+  [StorableClass]
+  public sealed class MaxGroupsLinearLinkageCreator : LinearLinkageCreator {
+
+    public IValueLookupParameter<IntValue> MaxGroupsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaxGroups"]; }
+    }
+
+    public IntValue MaxGroups {
+      get { return MaxGroupsParameter.Value; }
+      set { MaxGroupsParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    private MaxGroupsLinearLinkageCreator(bool deserializing) : base(deserializing) { }
+    private MaxGroupsLinearLinkageCreator(MaxGroupsLinearLinkageCreator original, Cloner cloner) : base(original, cloner) { }
+
+    public MaxGroupsLinearLinkageCreator() {
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaxGroups", "The maximum number of groups to create.", new IntValue(3)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MaxGroupsLinearLinkageCreator(this, cloner);
+    }
+
+    public static LinearLinkage Apply(IRandom random, int length, int maxGroups) {
+      var solution = new LinearLinkage(length);
+      var groups = Enumerable.Range(0, length).Select(x => Tuple.Create(x, random.Next(maxGroups)))
+                                              .GroupBy(x => x.Item2)
+                                              .Select(x => x.Select(y => y.Item1).ToList());
+      solution.SetGroups(groups);
+      return solution;
+    }
+
+    protected override LinearLinkage Create(IRandom random, int length) {
+      var maxGroups = MaxGroupsParameter.ActualValue.Value;
+      return Apply(random, length, maxGroups);
+    }
+  }
+}
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Creators/RandomLinearLinkageCreator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Creators/RandomLinearLinkageCreator.cs	(revision 12642)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Creators/RandomLinearLinkageCreator.cs	(revision 12643)
@@ -26,6 +26,6 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.LinearLinkageEncoding.Creators {
-  [Item("Random Linear Linkage Creator", "Creates a random linear linkage LLE encoded solution.")]
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("Random Linear Linkage Creator", "Creates a random linear linkage LLE encoded solution (similar to MaxGroups set to N).")]
   [StorableClass]
   public sealed class RandomLinearLinkageCreator : LinearLinkageCreator {
@@ -40,5 +40,5 @@
     }
 
-    protected override LinearLinkage Create(IRandom random, int length) {
+    public static LinearLinkage Apply(IRandom random, int length) {
       var solution = new LinearLinkage(length);
       var groups = Enumerable.Range(0, length).Select(x => Tuple.Create(x, random.Next(length)))
@@ -48,4 +48,8 @@
       return solution;
     }
+
+    protected override LinearLinkage Create(IRandom random, int length) {
+      return Apply(random, length);
+    }
   }
 }
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/GroupCrossover.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/GroupCrossover.cs	(revision 12642)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Crossovers/GroupCrossover.cs	(revision 12643)
@@ -22,5 +22,4 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj	(revision 12642)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/HeuristicLab.Encodings.LinearLinkageEncoding-3.3.csproj	(revision 12643)
@@ -102,4 +102,6 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Creators\ExactGroupsLinearLinkageCreator.cs" />
+    <Compile Include="Creators\MaxGroupsLinearLinkageCreator.cs" />
     <Compile Include="Creators\RandomLinearLinkageCreator.cs" />
     <Compile Include="Crossovers\GreedyPartitionCrossover.cs" />
@@ -108,4 +110,6 @@
     <Compile Include="Crossovers\MultiLLECrossover.cs" />
     <Compile Include="Crossovers\SinglePointCrossover.cs" />
+    <Compile Include="Interfaces\ILinearLinkageMoveOperator.cs" />
+    <Compile Include="Interfaces\ILinearLinkageSwap2MoveOperator.cs" />
     <Compile Include="Interfaces\ILinearLinkageCreator.cs" />
     <Compile Include="LinearLinkage.cs" />
@@ -118,4 +122,10 @@
     <Compile Include="Manipulators\MergeGroupManipulator.cs" />
     <Compile Include="Manipulators\MultiLLEManipulator.cs" />
+    <Compile Include="Moves\Swap\ExhaustiveSwap2MoveGenerator.cs" />
+    <Compile Include="Moves\Swap\StochasticSwap2MultiMoveGenerator.cs" />
+    <Compile Include="Moves\Swap\StochasticSwap2SingleMoveGenerator.cs" />
+    <Compile Include="Moves\Swap\Swap2Move.cs" />
+    <Compile Include="Moves\Swap\Swap2MoveGenerator.cs" />
+    <Compile Include="Moves\Swap\Swap2MoveMaker.cs" />
     <Compile Include="ShakingOperators\LLEShakingOperator.cs" />
     <None Include="HeuristicLab.snk" />
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageCrossover.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageCrossover.cs	(revision 12642)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageCrossover.cs	(revision 12643)
@@ -1,3 +1,24 @@
-﻿using HeuristicLab.Core;
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Optimization;
 
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageManipulator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageManipulator.cs	(revision 12642)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageManipulator.cs	(revision 12643)
@@ -1,3 +1,24 @@
-﻿using HeuristicLab.Core;
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Optimization;
 
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageMoveOperator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageMoveOperator.cs	(revision 12643)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageMoveOperator.cs	(revision 12643)
@@ -0,0 +1,36 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Optimization;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  /// <summary>
+  /// Move operators can be extended by deriving a new interface from this interface
+  /// and implementing that derived interface in all move operators that belong to
+  /// the same group of move operators.
+  /// 
+  /// See <see cref="ILinearLinkageSwap2MoveOperator"/> for a reference implementation.
+  /// </summary>
+  public interface ILinearLinkageMoveOperator : IMoveOperator, ILinearLinkageOperator {
+    ILookupParameter<LinearLinkage> LLEParameter { get; }
+  }
+}
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageOperator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageOperator.cs	(revision 12642)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageOperator.cs	(revision 12643)
@@ -1,3 +1,23 @@
-﻿
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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;
 
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageShakingOperator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageShakingOperator.cs	(revision 12642)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageShakingOperator.cs	(revision 12643)
@@ -1,3 +1,24 @@
-﻿using HeuristicLab.Core;
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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;
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageSwap2MoveOperator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageSwap2MoveOperator.cs	(revision 12643)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Interfaces/ILinearLinkageSwap2MoveOperator.cs	(revision 12643)
@@ -0,0 +1,28 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  public interface ILinearLinkageSwap2MoveOperator : ILinearLinkageMoveOperator {
+    ILookupParameter<Swap2Move> Swap2MoveParameter { get; }
+  }
+}
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkage.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkage.cs	(revision 12642)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkage.cs	(revision 12643)
@@ -131,5 +131,5 @@
     /// <remarks>
     /// Throws an ArgumentException when there is an element assigned to
-    /// multiple groups or elements that  are not assigned to any group.
+    /// multiple groups or elements that are not assigned to any group.
     /// </remarks>
     /// <param name="grouping">The grouping of the elements, each element must
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageEncoding.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageEncoding.cs	(revision 12642)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkageEncoding.cs	(revision 12643)
@@ -26,5 +26,4 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.LinearLinkageEncoding.Creators;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -108,5 +107,6 @@
           typeof (ILinearLinkageCrossover),
           typeof (ILinearLinkageManipulator),
-          typeof (ILinearLinkageShakingOperator)
+          typeof (ILinearLinkageShakingOperator),
+          typeof (ILinearLinkageMoveOperator)
       };
     }
@@ -128,4 +128,6 @@
       ConfigureManipulators(operators.OfType<ILinearLinkageManipulator>());
       ConfigureShakingOperators(operators.OfType<ILinearLinkageShakingOperator>());
+      ConfigureMoveOperators(operators.OfType<ILinearLinkageMoveOperator>());
+      ConfigureSwap2MoveOperators(operators.OfType<ILinearLinkageSwap2MoveOperator>());
     }
 
@@ -153,4 +155,14 @@
       }
     }
+    private void ConfigureMoveOperators(IEnumerable<ILinearLinkageMoveOperator> moveOperators) {
+      foreach (var moveOperator in moveOperators) {
+        moveOperator.LLEParameter.ActualName = Name;
+      }
+    }
+    private void ConfigureSwap2MoveOperators(IEnumerable<ILinearLinkageSwap2MoveOperator> swap2MoveOperators) {
+      foreach (var swap2MoveOperator in swap2MoveOperators) {
+        swap2MoveOperator.Swap2MoveParameter.ActualName = Name + ".Swap2Move";
+      }
+    }
     #endregion
   }
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/ExhaustiveSwap2MoveGenerator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/ExhaustiveSwap2MoveGenerator.cs	(revision 12643)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/ExhaustiveSwap2MoveGenerator.cs	(revision 12643)
@@ -0,0 +1,62 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("ExhaustiveSwap2MoveGenerator", "Generates all possible swap-2 moves from a given permutation.")]
+  [StorableClass]
+  public class ExhaustiveSwap2MoveGenerator : Swap2MoveGenerator, IExhaustiveMoveGenerator {
+    [StorableConstructor]
+    protected ExhaustiveSwap2MoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ExhaustiveSwap2MoveGenerator(ExhaustiveSwap2MoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveSwap2MoveGenerator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveSwap2MoveGenerator(this, cloner);
+    }
+
+    public static IEnumerable<Swap2Move> Generate(LinearLinkage lle) {
+      int length = lle.Length;
+      if (length == 1) throw new ArgumentException("ExhaustiveSwap2MoveGenerator: There cannot be an Swap move given only one item.", "lle");
+
+      var groups = lle.GetGroups().ToList();
+      if (groups.Count == 1) throw new InvalidOperationException("ExhaustiveSwap2MoveGenerator: Swap moves cannot be applied when there is only one group.");
+
+      for (int i = 0; i < groups.Count; i++)
+        for (int j = i + 1; j < groups.Count; j++)
+          for (var k = 0; k < groups[i].Count; k++)
+            for (var m = 0; m < groups[j].Count; m++) {
+              yield return new Swap2Move(groups[i][k], groups[j][m]);
+            }
+    }
+
+    protected override Swap2Move[] GenerateMoves(LinearLinkage lle) {
+      return Generate(lle).ToArray();
+    }
+  }
+}
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/StochasticSwap2MultiMoveGenerator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/StochasticSwap2MultiMoveGenerator.cs	(revision 12643)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/StochasticSwap2MultiMoveGenerator.cs	(revision 12643)
@@ -0,0 +1,72 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("StochasticSwap2MultiMoveGenerator", "Randomly samples n from all possible swap-2 moves from a given lle grouping.")]
+  [StorableClass]
+  public class StochasticSwap2MultiMoveGenerator : Swap2MoveGenerator, IMultiMoveGenerator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+
+    public IntValue SampleSize {
+      get { return SampleSizeParameter.Value; }
+      set { SampleSizeParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected StochasticSwap2MultiMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticSwap2MultiMoveGenerator(StochasticSwap2MultiMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticSwap2MultiMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StochasticSwap2MultiMoveGenerator(this, cloner);
+    }
+
+    public static Swap2Move[] Apply(LinearLinkage lle, IRandom random, int sampleSize) {
+      int length = lle.Length;
+      Swap2Move[] moves = new Swap2Move[sampleSize];
+      for (int i = 0; i < sampleSize; i++) {
+        moves[i] = StochasticSwap2SingleMoveGenerator.Apply(lle, random);
+      }
+      return moves;
+    }
+
+    protected override Swap2Move[] GenerateMoves(LinearLinkage lle) {
+      IRandom random = RandomParameter.ActualValue;
+      return Apply(lle, random, SampleSizeParameter.ActualValue.Value);
+    }
+  }
+}
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/StochasticSwap2SingleMoveGenerator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/StochasticSwap2SingleMoveGenerator.cs	(revision 12643)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/StochasticSwap2SingleMoveGenerator.cs	(revision 12643)
@@ -0,0 +1,73 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("StochasticSwap2SingleMoveGenerator", "Randomly samples a single from all possible swap-2 moves from a given grouping.")]
+  [StorableClass]
+  public class StochasticSwap2SingleMoveGenerator : Swap2MoveGenerator, IStochasticOperator, ISingleMoveGenerator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    [StorableConstructor]
+    protected StochasticSwap2SingleMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticSwap2SingleMoveGenerator(StochasticSwap2SingleMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticSwap2SingleMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StochasticSwap2SingleMoveGenerator(this, cloner);
+    }
+
+    public static Swap2Move Apply(LinearLinkage lle, IRandom random) {
+      int length = lle.Length;
+      if (length < 2) throw new ArgumentException("StochasticSwap2SingleMoveGenerator: There cannot be a swap-2 move given only one item.", "lle");
+
+      var groups = lle.GetGroups().ToList();
+      if (groups.Count == 1) throw new InvalidOperationException("StochasticSwap2SingleMoveGenerator: Swap moves cannot be applied when there is only one group.");
+
+      int index1 = random.Next(groups.Count), index2 = 0;
+      do {
+        index2 = random.Next(length);
+      } while (index1 == index2);
+
+      var item1 = random.Next(groups[index1].Count);
+      var item2 = random.Next(groups[index2].Count);
+
+      return new Swap2Move(groups[index1][item1], groups[index2][item2]);
+    }
+
+    protected override Swap2Move[] GenerateMoves(LinearLinkage lle) {
+      IRandom random = RandomParameter.ActualValue;
+      return new[] { Apply(lle, random) };
+    }
+  }
+}
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/Swap2Move.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/Swap2Move.cs	(revision 12643)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/Swap2Move.cs	(revision 12643)
@@ -0,0 +1,53 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("Swap2Move", "Item that describes a swap-2 move.")]
+  [StorableClass]
+  public class Swap2Move : Item {
+    [Storable]
+    public int Item1 { get; protected set; }
+    [Storable]
+    public int Item2 { get; protected set; }
+    [Storable]
+    public LinearLinkage LLE { get; protected set; }
+
+    [StorableConstructor]
+    protected Swap2Move(bool deserializing) : base(deserializing) { }
+    protected Swap2Move(Swap2Move original, Cloner cloner) : base(original, cloner) { }
+    public Swap2Move() : this(-1, -1, null) { }
+    public Swap2Move(int item1, int item2) : this(item1, item2, null) { }
+    public Swap2Move(int item1, int item2, LinearLinkage lle)
+      : base() {
+      Item1 = item1;
+      Item2 = item2;
+      LLE = lle;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Swap2Move(this, cloner);
+    }
+  }
+}
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/Swap2MoveGenerator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/Swap2MoveGenerator.cs	(revision 12643)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/Swap2MoveGenerator.cs	(revision 12643)
@@ -0,0 +1,66 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("Swap2MoveGenerator", "Base class for all swap-2 move generators.")]
+  [StorableClass]
+  public abstract class Swap2MoveGenerator : SingleSuccessorOperator, ILinearLinkageSwap2MoveOperator, IMoveGenerator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<LinearLinkage> LLEParameter {
+      get { return (ILookupParameter<LinearLinkage>)Parameters["LLE"]; }
+    }
+    public ILookupParameter<Swap2Move> Swap2MoveParameter {
+      get { return (LookupParameter<Swap2Move>)Parameters["Swap2Move"]; }
+    }
+
+    [StorableConstructor]
+    protected Swap2MoveGenerator(bool deserializing) : base(deserializing) { }
+    protected Swap2MoveGenerator(Swap2MoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public Swap2MoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<LinearLinkage>("LLE", "The LLE solution for which moves should be generated."));
+      Parameters.Add(new LookupParameter<Swap2Move>("Swap2Move", "The moves that should be generated in subscopes."));
+    }
+
+    public override IOperation Apply() {
+      var lle = LLEParameter.ActualValue;
+      var moves = GenerateMoves(lle);
+      var moveScopes = new Scope[moves.Length];
+      for (var i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        moveScopes[i].Variables.Add(new Variable(Swap2MoveParameter.ActualName, moves[i]));
+      }
+      ExecutionContext.Scope.SubScopes.AddRange(moveScopes);
+      return base.Apply();
+    }
+
+    protected abstract Swap2Move[] GenerateMoves(LinearLinkage lle);
+  }
+}
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/Swap2MoveMaker.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/Swap2MoveMaker.cs	(revision 12643)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/Moves/Swap/Swap2MoveMaker.cs	(revision 12643)
@@ -0,0 +1,106 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.LinearLinkageEncoding {
+  [Item("Swap2MoveMaker", "Peforms a swap-2 move on a given grouping and updates the quality.")]
+  [StorableClass]
+  public class Swap2MoveMaker : SingleSuccessorOperator, ILinearLinkageSwap2MoveOperator, IMoveMaker, ISingleObjectiveOperator {
+    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<Swap2Move> Swap2MoveParameter {
+      get { return (ILookupParameter<Swap2Move>)Parameters["Swap2Move"]; }
+    }
+    public ILookupParameter<LinearLinkage> LLEParameter {
+      get { return (ILookupParameter<LinearLinkage>)Parameters["LLE"]; }
+    }
+
+    [StorableConstructor]
+    protected Swap2MoveMaker(bool deserializing) : base(deserializing) { }
+    protected Swap2MoveMaker(Swap2MoveMaker original, Cloner cloner) : base(original, cloner) { }
+    public Swap2MoveMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
+      Parameters.Add(new LookupParameter<Swap2Move>("Swap2Move", "The move to apply."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The relative quality of the move."));
+      Parameters.Add(new LookupParameter<LinearLinkage>("LLE", "The linear linkage encoded solution to which the move should be applied."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Swap2MoveMaker(this, cloner);
+    }
+
+    public static void Apply(LinearLinkage lle, Swap2Move move) {
+      var groups = lle.GetGroups().ToList();
+      int g1 = -1, g2 = -1, g1Idx = -1, g2Idx = -1;
+      for (var i = 0; i < groups.Count; i++) {
+        if (g1 < 0) {
+          g1Idx = groups[i].IndexOf(move.Item1);
+          if (g1Idx >= 0) {
+            g1 = i;
+            continue;
+          }
+        }
+        if (g2 < 0) {
+          g2Idx = groups[i].IndexOf(move.Item2);
+          if (g2Idx >= 0) g2 = i;
+        }
+      }
+
+      // can happen if (for some reason) the items belong to the same group
+      if (g1 < 0 || g2 < 0) throw new InvalidOperationException("Swap2MoveMaker: Cannot apply swap move, items are not found in different groups.");
+
+      var h = groups[g1][g1Idx];
+      groups[g1][g1Idx] = groups[g2][g2Idx];
+      groups[g2][g2Idx] = h;
+      lle.SetGroups(groups);
+    }
+
+    public override IOperation Apply() {
+      var move = Swap2MoveParameter.ActualValue;
+      var lle = LLEParameter.ActualValue;
+      var moveQuality = MoveQualityParameter.ActualValue;
+      var quality = QualityParameter.ActualValue;
+
+      Apply(lle, move);
+
+      quality.Value = moveQuality.Value;
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/ShakingOperators/LLEShakingOperator.cs
===================================================================
--- /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/ShakingOperators/LLEShakingOperator.cs	(revision 12642)
+++ /branches/LinearLinkage/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/ShakingOperators/LLEShakingOperator.cs	(revision 12643)
@@ -31,7 +31,4 @@
 
 namespace HeuristicLab.Encodings.LinearLinkageEncoding {
-  /// <summary>
-  /// A shaking operator for VNS.
-  /// </summary>
   [Item("LLE Shaking Operator", "A shaking operator for VNS which uses LLE manipulators to perform the shaking.")]
   [StorableClass]
