Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveHardTabuCriterion.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveHardTabuCriterion.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveHardTabuCriterion.cs	(revision 9563)
@@ -0,0 +1,113 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("SequenceMoveHardTabuCriterion", "<Missing>")]
+  [StorableClass]
+  public class SequenceMoveHardTabuCriterion : SingleSuccessorOperator, IPackingSequenceMoveOperator, ITabuChecker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
+      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    }
+    public ILookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (ILookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MoveTabu"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ValueParameter<BoolValue> UseAspirationCriterionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseAspirationCriterion"]; }
+    }
+
+    [StorableConstructor]
+    protected SequenceMoveHardTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected SequenceMoveHardTabuCriterion(SequenceMoveHardTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public SequenceMoveHardTabuCriterion()
+      : base() {
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The solution to evaluate."));
+      Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the current move."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseAspirationCriterion", "Whether to use the aspiration criterion or not.", new BoolValue(true)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SequenceMoveHardTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      SequenceMove move = PackingMoveParameter.ActualValue as SequenceMove;
+      PackingSequenceEncoding PackingSequence = PackingSequenceParameter.ActualValue;
+      int length = PackingSequence.PackingSequence.Length;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool maximization = MaximizationParameter.ActualValue.Value;   
+      bool useAspiration = UseAspirationCriterionParameter.Value.Value;
+      bool isTabu = IsMoveTabu(tabuList, move, PackingSequence, moveQuality, maximization, useAspiration);
+
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+
+    private bool IsMoveTabu(ItemList<IItem> tabuList, SequenceMove move, PackingSequenceEncoding PackingSequence, double moveQuality, bool maximization, bool useAspiration) {
+      bool isTabu = false;
+      var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType()));
+
+      foreach (IItem attr in attributes) {
+        SequenceMoveAttribute gvAttr = attr as SequenceMoveAttribute;
+        if (gvAttr != null
+          && (!useAspiration
+              || maximization && moveQuality <= gvAttr.MoveQuality
+              || !maximization && moveQuality >= gvAttr.MoveQuality)) {
+
+          isTabu = move.BelongsToAttribute(gvAttr, true);
+        }
+        if (isTabu) break;
+      }
+
+      return isTabu;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveMaker.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveMaker.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveMaker.cs	(revision 9563)
@@ -0,0 +1,88 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Sequence Move Maker", "Peforms a Sequence move on a given Sequence vector and updates the quality.")]
+  [StorableClass]
+  public class SequenceMoveMaker : SingleSuccessorOperator, IMoveMaker, IPackingSequenceMoveOperator {
+    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<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
+      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    }
+    public ILookupParameter<IPackingPlan> PackingPlanParameter {
+      get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlan"]; }
+    }
+    public ILookupParameter<IPackingPlan> PackingPlanAfterMoveParameter {
+      get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlanAfterMove"]; }
+    }
+
+    [StorableConstructor]
+    protected SequenceMoveMaker(bool deserializing) : base(deserializing) { }
+    protected SequenceMoveMaker(SequenceMoveMaker original, Cloner cloner) : base(original, cloner) { }
+    public SequenceMoveMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The relative quality of the move."));
+      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The solution as Sequence vector."));
+      Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlan", "The currently best performing, decoded bin-packing solution represented as generalized packing-plan."));
+      Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlanAfterMove", "The moved and decoded bin-packing solution represented as generalized packing-plan."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SequenceMoveMaker(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      IPackingMove move = PackingMoveParameter.ActualValue;
+      PackingSequenceEncoding PackingSequence = PackingSequenceParameter.ActualValue;
+      DoubleValue moveQuality = MoveQualityParameter.ActualValue;
+      DoubleValue quality = QualityParameter.ActualValue;
+
+      PackingSequence.PackingSequence = (move.GetSolutionAfterMove() as PackingSequenceEncoding).PackingSequence;
+      PackingPlanParameter.ActualValue = PackingPlanAfterMoveParameter.ActualValue;
+
+      quality.Value = moveQuality.Value;
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveSoftTabuCriterion.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveSoftTabuCriterion.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveSoftTabuCriterion.cs	(revision 9563)
@@ -0,0 +1,113 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("SequenceMoveSoftTabuCriterion", "<Missing>")]
+  [StorableClass]
+  public class SequenceMoveSoftTabuCriterion : SingleSuccessorOperator, IPackingSequenceMoveOperator, ITabuChecker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
+      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    }
+    public ILookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (ILookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MoveTabu"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ValueParameter<BoolValue> UseAspirationCriterionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseAspirationCriterion"]; }
+    }
+
+    [StorableConstructor]
+    protected SequenceMoveSoftTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected SequenceMoveSoftTabuCriterion(SequenceMoveSoftTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public SequenceMoveSoftTabuCriterion()
+      : base() {
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The solution to evaluate."));
+      Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the current move."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseAspirationCriterion", "Whether to use the aspiration criterion or not.", new BoolValue(true)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SequenceMoveSoftTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      SequenceMove move = PackingMoveParameter.ActualValue as SequenceMove;
+      PackingSequenceEncoding PackingSequence = PackingSequenceParameter.ActualValue;
+      int length = PackingSequence.PackingSequence.Length;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool maximization = MaximizationParameter.ActualValue.Value;   
+      bool useAspiration = UseAspirationCriterionParameter.Value.Value;
+      bool isTabu = IsMoveTabu(tabuList, move, PackingSequence, moveQuality, maximization, useAspiration);
+
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+
+    private bool IsMoveTabu(ItemList<IItem> tabuList, SequenceMove move, PackingSequenceEncoding PackingSequence, double moveQuality, bool maximization, bool useAspiration) {
+      bool isTabu = false;
+      var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType()));
+
+      foreach (IItem attr in attributes) {
+        SequenceMoveAttribute gvAttr = attr as SequenceMoveAttribute;
+        if (gvAttr != null
+          && (!useAspiration
+              || maximization && moveQuality <= gvAttr.MoveQuality
+              || !maximization && moveQuality >= gvAttr.MoveQuality)) {
+
+          isTabu = move.BelongsToAttribute(gvAttr, false);
+        }
+        if (isTabu) break;
+      }
+
+      return isTabu;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/ExhaustiveInsertionMoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/ExhaustiveInsertionMoveGenerator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/ExhaustiveInsertionMoveGenerator.cs	(revision 9563)
@@ -0,0 +1,70 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Exhaustive Insertion Move Generator", "Generates all possible Swap Sequence moves from a given PackingSequence.")]
+  [StorableClass]
+  public class ExhaustiveInsertionMoveGenerator : InsertionMoveGenerator, IExhaustiveMoveGenerator {
+    [StorableConstructor]
+    protected ExhaustiveInsertionMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ExhaustiveInsertionMoveGenerator(ExhaustiveInsertionMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveInsertionMoveGenerator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveInsertionMoveGenerator(this, cloner);
+    }
+    public static IEnumerable<InsertionMove> Generate(PackingSequenceEncoding PackingSequence, int nrOfBins) {
+      for (int i = 0; i < PackingSequence.PackingSequence.Length - 1; i++)
+        for (int j = i + 1; j < PackingSequence.PackingSequence.Length; j++) {
+          if (j != i)
+            yield return new InsertionMove(i, j, PackingSequence);
+        }
+    }
+
+    public static InsertionMove[] Apply(PackingSequenceEncoding PackingSequence) {
+      int nrOfBins = 0;
+      foreach (int binNr in PackingSequence.PackingSequence) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+
+      int totalMoves = (PackingSequence.PackingSequence.Length * (PackingSequence.PackingSequence.Length - 1)) / 2;
+      InsertionMove[] moves = new InsertionMove[totalMoves];
+      int count = 0;
+      foreach (InsertionMove move in Generate(PackingSequence, nrOfBins)) {
+        moves[count++] = move;
+      }
+      return moves;
+    }
+
+    protected override InsertionMove[] GenerateMoves(PackingSequenceEncoding PackingSequence) {
+      return Apply(PackingSequence);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMove.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMove.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMove.cs	(revision 9563)
@@ -0,0 +1,113 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Insertion Move", "A move on a Sequence vector that is specified by two group-assignment-indexes.")]
+  [StorableClass]
+  public class InsertionMove : SequenceMove, IPackingMove {
+    [Storable]
+    public int Index1 { get; protected set; }
+    [Storable]
+    public int Index2 { get; protected set; }
+
+    [StorableConstructor]
+    protected InsertionMove(bool deserializing) : base(deserializing) { }
+    protected InsertionMove(InsertionMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index1 = original.Index1;
+      this.Index2 = original.Index2;
+    }
+    public InsertionMove(int index1, int index2, PackingSequenceEncoding PackingSequence)
+      : base(PackingSequence) {
+      Index1 = index1;
+      Index2 = index2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new InsertionMove(this, cloner);
+    }
+
+    public override IPackingSolutionEncoding GetSolutionAfterMove() {
+      PackingSequenceEncoding newSolution = new PackingSequenceEncoding();
+
+      Permutation original = PackingSequence.PackingSequence;
+      Permutation resultingPermutation = (Permutation)PackingSequence.PackingSequence.Clone();
+      int cutIndex, insertIndex, number;
+
+      cutIndex = Index1;
+      insertIndex = Index2;
+      number = original[cutIndex];
+
+      int i = 0;  // index in new permutation
+      int j = 0;  // index in old permutation
+      while (i < PackingSequence.PackingSequence.Length) {
+        if (j == cutIndex) {
+          j++;
+        }
+        if (i == insertIndex) {
+          resultingPermutation[i] = number;
+          i++;
+        }
+        if ((i < original.Length) && (j < original.Length)) {
+          resultingPermutation[i] = original[j];
+          i++;
+          j++;
+        }
+      }
+
+      newSolution.PackingSequence = resultingPermutation;
+      return newSolution;
+    }
+
+    public override Type GetMoveAttributeType() {
+      return typeof(InsertionMoveAttribute);
+    }
+
+    public override SequenceMoveAttribute GetAttribute(double quality) {
+      return new InsertionMoveAttribute(Index1, Index2, PackingSequence.PackingSequence[Index1], PackingSequence.PackingSequence[Index2], quality);
+    }
+
+    public override bool BelongsToAttribute(SequenceMoveAttribute attribute, bool hardCriterion) {
+      var attr = attribute as InsertionMoveAttribute;
+      if (attr != null) {
+        if (hardCriterion) {
+          if (Index1 == attr.Index1 || Index2 == attr.Index2)
+            return true;
+        } else
+          if (Index1 == attr.Index1 && Index2 == attr.Index2)
+            return true;
+      }
+      return false;
+    }
+
+    public override string ToString() {
+      return "IM(i1="+Index1 + ", i2=" + Index2  +")";
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMoveAttribute.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMoveAttribute.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMoveAttribute.cs	(revision 9563)
@@ -0,0 +1,61 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.PackingEncoding.PackingSequence {
+  [Item("InsertionMoveAttribute", "Specifies the tabu attributes for a Insertion move on a packingSequence.")]
+  [StorableClass]
+  public class InsertionMoveAttribute : SequenceMoveAttribute {
+    [Storable]
+    public int Index1 { get; protected set; }
+    [Storable]
+    public int Index2 { get; protected set; }
+    [Storable]
+    public int ItemID1 { get; protected set; }
+    [Storable]
+    public int ItemID2 { get; protected set; }
+
+    [StorableConstructor]
+    protected InsertionMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected InsertionMoveAttribute(InsertionMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index1 = original.Index1;
+      this.Index2 = original.Index2;
+      this.ItemID1 = original.ItemID1;
+      this.ItemID2 = original.ItemID2;
+    }
+    public InsertionMoveAttribute() : this(-1, -1, -1, -1, -1) { }
+    public InsertionMoveAttribute(int index1, int index2, int itemID1, int itemID2, double moveQuality)
+      : base(moveQuality) {
+      Index1 = index1;
+      Index2 = index2;
+      ItemID1 = itemID1;
+      ItemID2 = itemID2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new InsertionMoveAttribute(this, cloner);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMoveGenerator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMoveGenerator.cs	(revision 9563)
@@ -0,0 +1,71 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Insertion Move Generator", "Base class for all Swap Sequence move generators.")]
+  [StorableClass]
+  public abstract class InsertionMoveGenerator : SingleSuccessorOperator, IPackingSequenceMoveOperator, IMoveGenerator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
+      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (LookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    [StorableConstructor]
+    protected InsertionMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected InsertionMoveGenerator(InsertionMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public InsertionMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The Sequence vector for which moves should be generated."));
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The moves that should be generated in subscopes."));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
+    }
+
+    public override IOperation Apply() {
+      PackingSequenceEncoding ps = PackingSequenceParameter.ActualValue;
+      InsertionMove[] moves = GenerateMoves(ps);
+      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(PackingMoveParameter.ActualName, moves[i]));
+      }
+      CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
+      return base.Apply();
+    }
+
+    protected abstract InsertionMove[] GenerateMoves(PackingSequenceEncoding PackingSequence);
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/StochasticInsertionMoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/StochasticInsertionMoveGenerator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/StochasticInsertionMoveGenerator.cs	(revision 9563)
@@ -0,0 +1,82 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Stochastic Insertion Move Generator", "Generates a number of possible Sequence moves from a given Sequence vector.")]
+  [StorableClass]
+  public class StochasticInsertionMoveGenerator : InsertionMoveGenerator, 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 StochasticInsertionMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticInsertionMoveGenerator(StochasticInsertionMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticInsertionMoveGenerator()
+      : 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 StochasticInsertionMoveGenerator(this, cloner);
+    }
+
+    public static InsertionMove[] Apply(PackingSequenceEncoding PackingSequence, IRandom random, int sampleSize) {
+
+      int nrOfBins = 0;
+      foreach (int binNr in PackingSequence.PackingSequence) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+      var generatedMoves = new List<InsertionMove>();
+      var moves = new List<InsertionMove>(ExhaustiveInsertionMoveGenerator.Generate(PackingSequence, nrOfBins));
+      int moveCount = moves.Count;
+      for (int i = 0; i < sampleSize; i++) {
+        generatedMoves.Add(moves[random.Next(moveCount)]);
+      }
+
+      return generatedMoves.ToArray();
+    }
+
+    protected override InsertionMove[] GenerateMoves(PackingSequenceEncoding SwapSequence) {
+      IRandom random = RandomParameter.ActualValue;
+      return Apply(SwapSequence, random, SampleSizeParameter.ActualValue.Value);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceMove.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceMove.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceMove.cs	(revision 9563)
@@ -0,0 +1,52 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("SequenceMove", "An abstract move for a packingSequence encoded solution.")]
+  [StorableClass]
+  public abstract class SequenceMove : Item, IPackingMove {
+    [Storable]
+    public PackingSequenceEncoding PackingSequence { get; protected set; }
+
+    [StorableConstructor]
+    protected SequenceMove(bool deserializing) : base(deserializing) { }
+    protected SequenceMove(SequenceMove original, Cloner cloner)
+      : base(original, cloner) {
+        if (original.PackingSequence != null)
+          this.PackingSequence = cloner.Clone(original.PackingSequence);
+    }
+    public SequenceMove(PackingSequenceEncoding packingSequence)
+      : base() {
+        PackingSequence = packingSequence;
+    }
+
+    public abstract IPackingSolutionEncoding GetSolutionAfterMove();
+    public abstract Type GetMoveAttributeType();
+    public abstract SequenceMoveAttribute GetAttribute(double quality);
+    public abstract bool BelongsToAttribute (SequenceMoveAttribute attribute, bool hardCriterion);
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceMoveAttribute.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceMoveAttribute.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceMoveAttribute.cs	(revision 9563)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.PackingEncoding.PackingSequence{
+  [Item("SequenceMoveAttribute", "Base class for specifying a move attribute for sequence moves.")]
+  [StorableClass]
+  public class SequenceMoveAttribute : Item {
+    [Storable]
+    public double MoveQuality { get; protected set; }
+
+    [StorableConstructor]
+    protected SequenceMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected SequenceMoveAttribute(SequenceMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.MoveQuality = original.MoveQuality;
+    }
+    public SequenceMoveAttribute() : this(0) { }
+    public SequenceMoveAttribute( double moveQuality)
+      : base() {
+      MoveQuality = moveQuality;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SequenceMoveAttribute(this, cloner);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceTabuMaker.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceTabuMaker.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceTabuMaker.cs	(revision 9563)
@@ -0,0 +1,69 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Sequence tabu maker", "Declares a given Sequence move as tabu, by adding its attributes to the tabu list and also store the solution quality or the move quality (whichever is better).")]
+  [StorableClass]
+  public class SequenceTabuMaker : TabuMaker, IPackingSequenceMoveOperator{
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
+      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    }
+
+    [StorableConstructor]
+    protected SequenceTabuMaker(bool deserializing) : base(deserializing) { }
+    protected SequenceTabuMaker(SequenceTabuMaker original, Cloner cloner) : base(original, cloner) { }
+    public SequenceTabuMaker()
+      : base() {
+        Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The solution to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SequenceTabuMaker(this, cloner);
+    }
+
+    protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) {
+      IPackingMove move = PackingMoveParameter.ActualValue;
+      PackingSequenceEncoding PackingSequence = PackingSequenceParameter.ActualValue;    
+      double baseQuality = moveQuality;
+      if (maximization && quality > moveQuality || !maximization && quality < moveQuality) 
+        baseQuality = quality; // we make an uphill move, the lower bound is the solution quality
+
+      var sMove = move as SequenceMove;
+
+      if (sMove != null)
+        return sMove.GetAttribute(baseQuality);
+      else
+        return move.GetSolutionAfterMove();
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/ExhaustiveSwap2MoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/ExhaustiveSwap2MoveGenerator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/ExhaustiveSwap2MoveGenerator.cs	(revision 9563)
@@ -0,0 +1,70 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Exhaustive Swap2 Move Generator", "Generates all possible Swap Sequence moves from a given PackingSequence.")]
+  [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(PackingSequenceEncoding PackingSequence, int nrOfBins) {
+      for (int i = 0; i < PackingSequence.PackingSequence.Length - 1; i++)
+        for (int j = i + 1; j < PackingSequence.PackingSequence.Length; j++) {
+          if (j != i)
+            yield return new Swap2Move(i, j, PackingSequence);
+        }
+    }
+
+    public static Swap2Move[] Apply(PackingSequenceEncoding PackingSequence) {
+      int nrOfBins = 0;
+      foreach (int binNr in PackingSequence.PackingSequence) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+
+      int totalMoves = (PackingSequence.PackingSequence.Length * (PackingSequence.PackingSequence.Length - 1)) / 2;
+      Swap2Move[] moves = new Swap2Move[totalMoves];
+      int count = 0;
+      foreach (Swap2Move move in Generate(PackingSequence, nrOfBins)) {
+        moves[count++] = move;
+      }
+      return moves;
+    }
+
+    protected override Swap2Move[] GenerateMoves(PackingSequenceEncoding PackingSequence) {
+      return Apply(PackingSequence);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/StochasticSwap2MoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/StochasticSwap2MoveGenerator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/StochasticSwap2MoveGenerator.cs	(revision 9563)
@@ -0,0 +1,82 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Stochastic Swap2 Move Generator", "Generates a number of possible Sequence moves from a given Sequence vector.")]
+  [StorableClass]
+  public class StochasticSwap2MoveGenerator : 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 StochasticSwap2MoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticSwap2MoveGenerator(StochasticSwap2MoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticSwap2MoveGenerator()
+      : 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 StochasticSwap2MoveGenerator(this, cloner);
+    }
+
+    public static Swap2Move[] Apply(PackingSequenceEncoding PackingSequence, IRandom random, int sampleSize) {
+
+      int nrOfBins = 0;
+      foreach (int binNr in PackingSequence.PackingSequence) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+      var generatedMoves = new List<Swap2Move>();
+      var moves = new List<Swap2Move>(ExhaustiveSwap2MoveGenerator.Generate(PackingSequence, nrOfBins));
+      int moveCount = moves.Count;
+      for (int i = 0; i < sampleSize; i++) {
+        generatedMoves.Add(moves[random.Next(moveCount)]);
+      }
+
+      return generatedMoves.ToArray();
+    }
+
+    protected override Swap2Move[] GenerateMoves(PackingSequenceEncoding SwapSequence) {
+      IRandom random = RandomParameter.ActualValue;
+      return Apply(SwapSequence, random, SampleSizeParameter.ActualValue.Value);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2Move.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2Move.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2Move.cs	(revision 9563)
@@ -0,0 +1,89 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Swap2 Move", "A move on a Sequence vector that is specified by two group-assignment-indexes.")]
+  [StorableClass]
+  public class Swap2Move : SequenceMove, IPackingMove {
+    [Storable]
+    public int Index1 { get; protected set; }
+    [Storable]
+    public int Index2 { get; protected set; }
+
+    [StorableConstructor]
+    protected Swap2Move(bool deserializing) : base(deserializing) { }
+    protected Swap2Move(Swap2Move original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index1 = original.Index1;
+      this.Index2 = original.Index2;
+    }
+    public Swap2Move(int index1, int index2, PackingSequenceEncoding PackingSequence)
+      : base(PackingSequence) {
+      Index1 = index1;
+      Index2 = index2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Swap2Move(this, cloner);
+    }
+
+    public override IPackingSolutionEncoding GetSolutionAfterMove() {
+      PackingSequenceEncoding newSolution = new PackingSequenceEncoding();
+      newSolution.PackingSequence = (Permutation)PackingSequence.PackingSequence.Clone(new Cloner());
+      newSolution.PackingSequence[Index1] = PackingSequence.PackingSequence[Index2];
+      newSolution.PackingSequence[Index2] = PackingSequence.PackingSequence[Index1];
+      return newSolution;
+    }
+
+    public override Type GetMoveAttributeType() {
+      return typeof(Swap2MoveAttribute);
+    }
+
+    public override SequenceMoveAttribute GetAttribute(double quality) {
+      return new Swap2MoveAttribute(Index1, Index2, PackingSequence.PackingSequence[Index1], PackingSequence.PackingSequence[Index2], quality);
+    }
+
+    public override bool BelongsToAttribute(SequenceMoveAttribute attribute, bool hardCriterion) {
+      var attr = attribute as Swap2MoveAttribute;
+      if (attr != null) {
+        if (hardCriterion) {
+          if (Index1 == attr.Index1 || Index2 == attr.Index2)// || PackingSequence.PackingSequence[Index1] == attr.AssignedBin1 || PackingSequence.PackingSequence[Index2] == attr.AssignedBin2)
+            return true;
+        } else
+          if (Index1 == attr.Index1 && Index2 == attr.Index2)// && PackingSequence.PackingSequence[Index1] == attr.AssignedBin1 && PackingSequence.PackingSequence[Index2] == attr.AssignedBin2)
+            return true;
+      }
+      return false;
+    }
+
+    public override string ToString() {
+      return "SGM(i1="+Index1 + ", i2=" + Index2  +")";
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2MoveAttribute.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2MoveAttribute.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2MoveAttribute.cs	(revision 9563)
@@ -0,0 +1,61 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.PackingEncoding.PackingSequence {
+  [Item("Swap2MoveAttribute", "Specifies the tabu attributes for a Swap2 move on a packingSequence.")]
+  [StorableClass]
+  public class Swap2MoveAttribute : SequenceMoveAttribute {
+    [Storable]
+    public int Index1 { get; protected set; }
+    [Storable]
+    public int Index2 { get; protected set; }
+    [Storable]
+    public int ItemID1 { get; protected set; }
+    [Storable]
+    public int ItemID2 { get; protected set; }
+
+    [StorableConstructor]
+    protected Swap2MoveAttribute(bool deserializing) : base(deserializing) { }
+    protected Swap2MoveAttribute(Swap2MoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index1 = original.Index1;
+      this.Index2 = original.Index2;
+      this.ItemID1 = original.ItemID1;
+      this.ItemID2 = original.ItemID2;
+    }
+    public Swap2MoveAttribute() : this(-1, -1, -1, -1, -1) { }
+    public Swap2MoveAttribute(int index1, int index2, int itemID1, int itemID2, double moveQuality)
+      : base(moveQuality) {
+      Index1 = index1;
+      Index2 = index2;
+      ItemID1 = itemID1;
+      ItemID2 = itemID2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Swap2MoveAttribute(this, cloner);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2MoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2MoveGenerator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2MoveGenerator.cs	(revision 9563)
@@ -0,0 +1,71 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Swap2 Move Generator", "Base class for all Swap Sequence move generators.")]
+  [StorableClass]
+  public abstract class Swap2MoveGenerator : SingleSuccessorOperator, IPackingSequenceMoveOperator, IMoveGenerator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
+      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (LookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    [StorableConstructor]
+    protected Swap2MoveGenerator(bool deserializing) : base(deserializing) { }
+    protected Swap2MoveGenerator(Swap2MoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public Swap2MoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The Sequence vector for which moves should be generated."));
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The moves that should be generated in subscopes."));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
+    }
+
+    public override IOperation Apply() {
+      PackingSequenceEncoding ps = PackingSequenceParameter.ActualValue;
+      Swap2Move[] moves = GenerateMoves(ps);
+      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(PackingMoveParameter.ActualName, moves[i]));
+      }
+      CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
+      return base.Apply();
+    }
+
+    protected abstract Swap2Move[] GenerateMoves(PackingSequenceEncoding PackingSequence);
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceCrossover.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceCrossover.cs	(revision 9348)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceCrossover.cs	(revision 9563)
@@ -29,5 +29,5 @@
   [Item("PackingSequenceCrossover", "An operator which crosses two PackingSequence representations.")]
   [StorableClass]
-  public class PackingSequenceCrossover : PackingSolutionCrossover, IPackingSequenceOperator {
+  public abstract class PackingSequenceCrossover : PackingSolutionCrossover, IPackingSequenceOperator {
 
     [StorableConstructor]
@@ -39,13 +39,6 @@
         ChildParameter.ActualName = "PackingSequence";
     }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingSequenceCrossover(this, cloner);
-    }
 
-    public PackingSequenceEncoding Cross(IRandom random, PackingSequenceEncoding parent1, PackingSequenceEncoding parent2) {
-      PackingSequenceEncoding result = new PackingSequenceEncoding();
-      result.PackingSequence = CosaCrossover.Apply(random, parent1.PackingSequence, parent2.PackingSequence);
-      return result;
-    }
+    public abstract PackingSequenceEncoding Cross(IRandom random, PackingSequenceEncoding parent1, PackingSequenceEncoding parent2);
 
     public override IOperation Apply() {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceEncoding.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceEncoding.cs	(revision 9348)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceEncoding.cs	(revision 9563)
@@ -30,5 +30,5 @@
   [Item("Packing Sequence Encoding", "Represents an encoding for a bin packing problem using permutation of item-indexes to define the packing sequence.")]
   [StorableClass]
-  public class PackingSequenceEncoding : Item, IPackingSolutionEncoding{
+  public class PackingSequenceEncoding : Item, IPackingSolutionEncoding {
 
     [Storable]
@@ -39,5 +39,5 @@
     protected PackingSequenceEncoding(PackingSequenceEncoding original, Cloner cloner)
       : base(original, cloner) {
-        this.PackingSequence = cloner.Clone(original.PackingSequence);
+      this.PackingSequence = cloner.Clone(original.PackingSequence);
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -53,5 +53,5 @@
       StringBuilder sb = new StringBuilder();
       sb.Append("[ ");
-      sb.Append(PackingSequence.ToString() + " \n");         
+      sb.Append(PackingSequence.ToString() + " \n");
       sb.Append("]");
       return sb.ToString();
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceInsertionManipulator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceInsertionManipulator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceInsertionManipulator.cs	(revision 9563)
@@ -0,0 +1,48 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("PackingSequence Insertion Manipulator", "An operator which manipulates a PackingSequence representation.")]
+  [StorableClass]
+  public class PackingSequenceInsertionManipulator : PackingSequenceManipulator, IPackingSequenceOperator {
+    [StorableConstructor]
+    protected PackingSequenceInsertionManipulator(bool deserializing) : base(deserializing) { }
+    protected PackingSequenceInsertionManipulator(PackingSequenceManipulator original, Cloner cloner) : base(original, cloner) { }
+    public PackingSequenceInsertionManipulator()
+      : base() {
+        EncodedSolutionParameter.ActualName = "PackingSequence";
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingSequenceInsertionManipulator(this, cloner);
+    }
+
+    protected override void Manipulate(IRandom random, PackingSequenceEncoding individual) {
+      Swap2Manipulator.Apply(random, individual.PackingSequence);
+    }   
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceManipulator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceManipulator.cs	(revision 9348)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceManipulator.cs	(revision 9563)
@@ -30,5 +30,5 @@
   [Item("PackingSequenceManipulator", "An operator which manipulates a PackingSequence representation.")]
   [StorableClass]
-  public class PackingSequenceManipulator : PackingSolutionManipulator, IPackingSequenceOperator {
+  public abstract class PackingSequenceManipulator : PackingSolutionManipulator, IPackingSequenceOperator {
     [StorableConstructor]
     protected PackingSequenceManipulator(bool deserializing) : base(deserializing) { }
@@ -38,11 +38,6 @@
         EncodedSolutionParameter.ActualName = "PackingSequence";
     }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingSequenceManipulator(this, cloner);
-    }
 
-    protected void Manipulate(IRandom random, PackingSequenceEncoding individual) {
-      Swap2Manipulator.Apply(random, individual.PackingSequence);
-    }
+    protected abstract void Manipulate(IRandom random, PackingSequenceEncoding individual);
 
     public override IOperation Apply() {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceOrderCrossover.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceOrderCrossover.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceOrderCrossover.cs	(revision 9563)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("PackingSequence OX", "An operator which crosses two PackingSequence representations using the OX-strategy.")]
+  [StorableClass]
+  public class PackingSequenceOrderCrossover : PackingSequenceCrossover, IPackingSequenceOperator {
+
+    [StorableConstructor]
+    protected PackingSequenceOrderCrossover(bool deserializing) : base(deserializing) { }
+    protected PackingSequenceOrderCrossover(PackingSequenceOrderCrossover original, Cloner cloner) : base(original, cloner) { }
+    public PackingSequenceOrderCrossover()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingSequenceOrderCrossover(this, cloner);
+    }
+
+    public override PackingSequenceEncoding Cross(IRandom random, PackingSequenceEncoding parent1, PackingSequenceEncoding parent2)  {
+      PackingSequenceEncoding result = new PackingSequenceEncoding();
+      result.PackingSequence = OrderCrossover2.Apply(random, parent1.PackingSequence, parent2.PackingSequence);
+      return result;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequencePartiallyMatchedCrossover.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequencePartiallyMatchedCrossover.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequencePartiallyMatchedCrossover.cs	(revision 9563)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("PackingSequence PMX", "An operator which crosses two PackingSequence representations using the OX-strategy.")]
+  [StorableClass]
+  public class PackingSequencePartiallyMatchedCrossover : PackingSequenceCrossover, IPackingSequenceOperator {
+
+    [StorableConstructor]
+    protected PackingSequencePartiallyMatchedCrossover(bool deserializing) : base(deserializing) { }
+    protected PackingSequencePartiallyMatchedCrossover(PackingSequencePartiallyMatchedCrossover original, Cloner cloner) : base(original, cloner) { }
+    public PackingSequencePartiallyMatchedCrossover()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingSequencePartiallyMatchedCrossover(this, cloner);
+    }
+
+    public override PackingSequenceEncoding Cross(IRandom random, PackingSequenceEncoding parent1, PackingSequenceEncoding parent2)  {
+      PackingSequenceEncoding result = new PackingSequenceEncoding();
+      result.PackingSequence = PartiallyMatchedCrossover.Apply(random, parent1.PackingSequence, parent2.PackingSequence);
+      return result;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceRandomCreator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceRandomCreator.cs	(revision 9348)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceRandomCreator.cs	(revision 9563)
@@ -60,9 +60,9 @@
     public static PackingSequenceEncoding Apply(int items, IRandom random) {
       var solution = new PackingSequenceEncoding();
-		  solution.PackingSequence = new Permutation(PermutationTypes.Absolute, items, random);
-			return solution;
-		}
+      solution.PackingSequence = new Permutation(PermutationTypes.Absolute, items, random);
+      return solution;
+    }
 
-		protected override IPackingSolutionEncoding CreateSolution() {
+		protected override IItem CreateSolution() {
 			return Apply(PackingItemsParameter.ActualValue.Value, RandomParameter.ActualValue);
 		}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceSwap2Manipulator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceSwap2Manipulator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceSwap2Manipulator.cs	(revision 9563)
@@ -0,0 +1,48 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("PackingSequence Swap2 Manipulator", "An operator which manipulates a PackingSequence representation.")]
+  [StorableClass]
+  public class PackingSequenceSwap2Manipulator : PackingSequenceManipulator, IPackingSequenceOperator {
+    [StorableConstructor]
+    protected PackingSequenceSwap2Manipulator(bool deserializing) : base(deserializing) { }
+    protected PackingSequenceSwap2Manipulator(PackingSequenceManipulator original, Cloner cloner) : base(original, cloner) { }
+    public PackingSequenceSwap2Manipulator()
+      : base() {
+        EncodedSolutionParameter.ActualName = "PackingSequence";
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingSequenceSwap2Manipulator(this, cloner);
+    }
+
+    protected override void Manipulate(IRandom random, PackingSequenceEncoding individual) {
+      Swap2Manipulator.Apply(random, individual.PackingSequence);
+    }    
+  }
+}
