Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorCrossover.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorCrossover.cs	(revision 9495)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorCrossover.cs	(revision 9563)
@@ -30,5 +30,5 @@
   [Item("Grouping Vector Crossover", "An operator which crosses two GroupingVector representations.")]
   [StorableClass]
-  public class GroupingVectorCrossover : PackingSolutionCrossover, IGroupingVectorOperator {
+  public abstract class GroupingVectorCrossover : PackingSolutionCrossover, IGroupingVectorOperator {
 
     [StorableConstructor]
@@ -40,13 +40,6 @@
         ChildParameter.ActualName = "GroupingVector";
     }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new GroupingVectorCrossover(this, cloner);
-    }
 
-    public GroupingVectorEncoding Cross(IRandom random, GroupingVectorEncoding parent1, GroupingVectorEncoding parent2) {
-      GroupingVectorEncoding result = new GroupingVectorEncoding();
-      result.GroupingVector = SinglePointCrossover.Apply(random, parent1.GroupingVector, parent2.GroupingVector);
-      return result;
-    }
+    public abstract GroupingVectorEncoding Cross(IRandom random, GroupingVectorEncoding parent1, GroupingVectorEncoding parent2);
 
     public override IOperation Apply() {
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorDiscreteCrossover.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorDiscreteCrossover.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorDiscreteCrossover.cs	(revision 9563)
@@ -0,0 +1,51 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Grouping Vector Discrete Crossover", "An operator which crosses two GroupingVector representations.")]
+  [StorableClass]
+  public class GroupingVectorDiscreteCrossover : GroupingVectorCrossover, IGroupingVectorOperator {
+
+    [StorableConstructor]
+    protected GroupingVectorDiscreteCrossover (bool deserializing) : base(deserializing) { }
+    protected GroupingVectorDiscreteCrossover(GroupingVectorDiscreteCrossover original, Cloner cloner) : base(original, cloner) { }
+    public GroupingVectorDiscreteCrossover()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingVectorDiscreteCrossover(this, cloner);
+    }
+
+    public override GroupingVectorEncoding Cross(IRandom random, GroupingVectorEncoding parent1, GroupingVectorEncoding parent2) {
+      GroupingVectorEncoding result = new GroupingVectorEncoding();
+      result.GroupingVector = DiscreteCrossover.Apply(
+        random, new ItemArray<IntegerVector> (new IntegerVector[]{parent1.GroupingVector, parent2.GroupingVector}));
+      return result;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorOnePositionManipulator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorOnePositionManipulator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorOnePositionManipulator.cs	(revision 9563)
@@ -0,0 +1,53 @@
+﻿#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.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Grouping Vector One Position Manipulator", "An operator which manipulates a PackingSequence representation.")]
+  [StorableClass]
+  public class GroupingVectorOnePositionManipulator :  GroupingVectorManipulator {
+    [StorableConstructor]
+    protected GroupingVectorOnePositionManipulator(bool deserializing) : base(deserializing) { }
+    protected GroupingVectorOnePositionManipulator(GroupingVectorOnePositionManipulator original, Cloner cloner) : base(original, cloner) { }
+    public GroupingVectorOnePositionManipulator()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingVectorOnePositionManipulator(this, cloner);
+    }
+
+    protected override void Manipulate(IRandom random, GroupingVectorEncoding individual) {
+      int max = 0;
+      foreach (int i in individual.GroupingVector)
+        if (i > max) max = i;
+
+      int index = random.Next(individual.GroupingVector.Length);
+      individual.GroupingVector[index] = random.Next(max);
+    }
+
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorRandomCreator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorRandomCreator.cs	(revision 9495)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorRandomCreator.cs	(revision 9563)
@@ -68,5 +68,5 @@
 		}
 
-		protected override IPackingSolutionEncoding CreateSolution() {
+		protected override IItem CreateSolution() {
 			return Apply(PackingItemsParameter.ActualValue.Value, LowerBoundParameter.ActualValue.Value, RandomParameter.ActualValue);
 		}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorSinglePointCrossover.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorSinglePointCrossover.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorSinglePointCrossover.cs	(revision 9563)
@@ -0,0 +1,50 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Grouping Vector Single Point Crossover", "An operator which crosses two GroupingVector representations.")]
+  [StorableClass]
+  public class GroupingVectorSinglePointCrossover : GroupingVectorCrossover, IGroupingVectorOperator {
+
+    [StorableConstructor]
+    protected GroupingVectorSinglePointCrossover (bool deserializing) : base(deserializing) { }
+    protected GroupingVectorSinglePointCrossover(GroupingVectorSinglePointCrossover original, Cloner cloner) : base(original, cloner) { }
+    public GroupingVectorSinglePointCrossover()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingVectorSinglePointCrossover(this, cloner);
+    }
+
+    public override GroupingVectorEncoding Cross(IRandom random, GroupingVectorEncoding parent1, GroupingVectorEncoding parent2) {
+      GroupingVectorEncoding result = new GroupingVectorEncoding();
+      result.GroupingVector = SinglePointCrossover.Apply(random, parent1.GroupingVector, parent2.GroupingVector);
+      return result;
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorSwap2Manipulator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorSwap2Manipulator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorSwap2Manipulator.cs	(revision 9563)
@@ -0,0 +1,64 @@
+﻿#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.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Grouping Vector Swap2 Manipulator", "An operator which manipulates a PackingSequence representation.")]
+  [StorableClass]
+  public class GroupingVectorSwap2Manipulator :  GroupingVectorManipulator {
+    [StorableConstructor]
+    protected GroupingVectorSwap2Manipulator (bool deserializing) : base(deserializing) { }
+    protected GroupingVectorSwap2Manipulator(GroupingVectorSwap2Manipulator original, Cloner cloner) : base(original, cloner) { }
+    public GroupingVectorSwap2Manipulator()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingVectorSwap2Manipulator(this, cloner);
+    }
+
+    protected override void Manipulate(IRandom random, GroupingVectorEncoding individual) {
+
+      int index1 = 0;
+      int index2 = 1;
+
+      if (individual.GroupingVector.Length <= 1)
+        return;
+      else if (individual.GroupingVector.Length != 2) {
+        index1 = random.Next(individual.GroupingVector.Length);
+        index2 = random.Next(individual.GroupingVector.Length);
+        while (index2.Equals(index1)) {
+          index2 = random.Next(individual.GroupingVector.Length);
+        }
+      }
+
+      int temp = individual.GroupingVector [index1];
+      individual.GroupingVector[index1] = individual.GroupingVector[index2];
+      individual.GroupingVector[index2] = temp;
+    }
+
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMove.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMove.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMove.cs	(revision 9563)
@@ -0,0 +1,86 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Change Grouping Move", "A move on a grouping vector that is specified by a single group-assignment-index.")]
+  [StorableClass]
+  public class ChangeGroupingMove : GroupingMove, IPackingMove{
+    [Storable]
+    public int Index { get; protected set; }
+    [Storable]
+    public int NewGroup { get; protected set; }
+
+    [StorableConstructor]
+    protected ChangeGroupingMove(bool deserializing) : base(deserializing) { }
+    protected ChangeGroupingMove(ChangeGroupingMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index = original.Index;
+      this.NewGroup = original.NewGroup;
+    }
+    public ChangeGroupingMove(int index, int newGroup, GroupingVectorEncoding groupingVector)
+      : base(groupingVector) {
+      Index = index;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ChangeGroupingMove(this, cloner);
+    }
+
+    public override IPackingSolutionEncoding GetSolutionAfterMove() {
+      GroupingVectorEncoding newSolution = new GroupingVectorEncoding();
+      newSolution.GroupingVector = new IntegerVector(GroupingVector.GroupingVector);
+      newSolution.GroupingVector[Index] = NewGroup;
+      return newSolution;
+    }
+
+    public override Type GetMoveAttributeType() {
+      return typeof(ChangeGroupingMoveAttribute);
+    }
+
+    public override GroupingMoveAttribute GetAttribute(double quality) {
+      return new ChangeGroupingMoveAttribute(Index, NewGroup, quality);
+    }
+
+    public override bool BelongsToAttribute(GroupingMoveAttribute attribute, bool hardCriterion) {
+      var attr = attribute as ChangeGroupingMoveAttribute;
+      if (attr != null) {
+        if (hardCriterion) {
+          if (Index == attr.ItemIndex) //|| GroupingVector.GroupingVector[Index] == attr.AssignedBin)
+            return true;
+        } else
+          if (Index == attr.ItemIndex && GroupingVector.GroupingVector[Index] == attr.AssignedBin)
+            return true;
+      }
+      return false;
+    }
+
+    public override string ToString() {
+      return "CGM(i=" + Index + ", g=" + NewGroup + ")";
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMoveAttribute.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMoveAttribute.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMoveAttribute.cs	(revision 9563)
@@ -0,0 +1,53 @@
+﻿#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.GroupingVector {
+  [Item("ChangeGroupingMoveAttribute", "Specifies the tabu attributes for a ChangeGrouping move on a grouping vector.")]
+  [StorableClass]
+  public class ChangeGroupingMoveAttribute : GroupingMoveAttribute {
+    [Storable]
+    public int ItemIndex { get; protected set; }
+    [Storable]
+    public int AssignedBin { get; protected set; }
+
+    [StorableConstructor]
+    protected ChangeGroupingMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected ChangeGroupingMoveAttribute(ChangeGroupingMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.ItemIndex = original.ItemIndex;
+      this.AssignedBin = original.AssignedBin;
+    }
+    public ChangeGroupingMoveAttribute() : this(-1, -1, -1) { }
+    public ChangeGroupingMoveAttribute(int itemIndex, int assignedBin, double moveQuality)
+      : base(moveQuality) {
+      ItemIndex = itemIndex;
+      AssignedBin = assignedBin;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ChangeGroupingMoveAttribute(this, cloner);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMoveGenerator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMoveGenerator.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.GroupingVector {
+  [Item("Change Grouping Move Generator", "Base class for all ChangeGrouping move generators.")]
+  [StorableClass]
+  public abstract class ChangeGroupingMoveGenerator : SingleSuccessorOperator, IGroupingVectorMoveOperator, IMoveGenerator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (LookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    [StorableConstructor]
+    protected ChangeGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ChangeGroupingMoveGenerator(ChangeGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ChangeGroupingMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The grouping 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() {
+      GroupingVectorEncoding gv = GroupingVectorParameter.ActualValue;
+      ChangeGroupingMove[] moves = GenerateMoves(gv);
+      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 ChangeGroupingMove[] GenerateMoves(GroupingVectorEncoding groupingVector);
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/ExhaustiveChangeGroupingMoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/ExhaustiveChangeGroupingMoveGenerator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/ExhaustiveChangeGroupingMoveGenerator.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 System;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Exhaustive Change Grouping Move Generator", "Generates all possible ChangeGrouping moves from a given groupingVector.")]
+  [StorableClass]
+  public class ExhaustiveChangeGroupingMoveGenerator : ChangeGroupingMoveGenerator, IExhaustiveMoveGenerator {
+    [StorableConstructor]
+    protected ExhaustiveChangeGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ExhaustiveChangeGroupingMoveGenerator(ExhaustiveChangeGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveChangeGroupingMoveGenerator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveChangeGroupingMoveGenerator(this, cloner);
+    }
+
+    public static IEnumerable<ChangeGroupingMove> Generate(GroupingVectorEncoding groupingVector, int nrOfBins) {
+      for (int i = 0; i < groupingVector.GroupingVector.Length; i++)
+        for (int j = 0; j < nrOfBins; j++) {
+          if (j != groupingVector.GroupingVector[i])
+            yield return new ChangeGroupingMove(i, j, groupingVector);
+        }
+    }
+
+    public static ChangeGroupingMove[] Apply(GroupingVectorEncoding groupingVector) {
+      int nrOfBins = 0;
+      foreach (int binNr in groupingVector.GroupingVector) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+
+      int totalMoves = (groupingVector.GroupingVector.Length) * (nrOfBins - 1);
+      ChangeGroupingMove[] moves = new ChangeGroupingMove[totalMoves];
+      int count = 0;
+      foreach (ChangeGroupingMove move in Generate(groupingVector, nrOfBins)) {
+        moves[count++] = move;
+      }
+      return moves;
+    }
+
+    protected override ChangeGroupingMove[] GenerateMoves(GroupingVectorEncoding groupingVector) {
+      return Apply(groupingVector);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/StochasticChangeGroupingMoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/StochasticChangeGroupingMoveGenerator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/ChangeGrouping/StochasticChangeGroupingMoveGenerator.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.GroupingVector {
+  [Item("Stochastic ChangeGrouping Move Generator", "Generates a number of possible grouping moves from a given grouping vector.")]
+  [StorableClass]
+  public class StochasticChangeGroupingMoveGenerator : ChangeGroupingMoveGenerator, 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 StochasticChangeGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticChangeGroupingMoveGenerator(StochasticChangeGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticChangeGroupingMoveGenerator()
+      : 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 StochasticChangeGroupingMoveGenerator(this, cloner);
+    }
+
+    public static ChangeGroupingMove[] Apply(GroupingVectorEncoding groupingVector, IRandom random, int sampleSize) {
+
+      int nrOfBins = 0;
+      foreach (int binNr in groupingVector.GroupingVector) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+      var generatedMoves = new List<ChangeGroupingMove>();
+      var moves = new List<ChangeGroupingMove>(ExhaustiveChangeGroupingMoveGenerator.Generate(groupingVector, nrOfBins));
+      int moveCount = moves.Count;
+      for (int i = 0; i < sampleSize; i++) {
+        generatedMoves.Add(moves[random.Next(moveCount)]);
+      }
+
+      return generatedMoves.ToArray();
+    }
+
+    protected override ChangeGroupingMove[] GenerateMoves(GroupingVectorEncoding groupingVector) {
+      IRandom random = RandomParameter.ActualValue;
+      return Apply(groupingVector, random, SampleSizeParameter.ActualValue.Value);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/GroupingMove.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/GroupingMove.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/GroupingMove.cs	(revision 9563)
@@ -0,0 +1,53 @@
+﻿#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.PackingEncoding.GroupingVector;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("GroupingMove", "An abstract move for a groupingVector encoded solution.")]
+  [StorableClass]
+  public abstract class GroupingMove : Item, IPackingMove {
+    [Storable]
+    public GroupingVectorEncoding GroupingVector { get; protected set; }
+
+    [StorableConstructor]
+    protected GroupingMove(bool deserializing) : base(deserializing) { }
+    protected GroupingMove(GroupingMove original, Cloner cloner)
+      : base(original, cloner) {
+        if (original.GroupingVector != null)
+          this.GroupingVector = cloner.Clone(original.GroupingVector);
+    }
+    public GroupingMove(GroupingVectorEncoding groupingVector)
+      : base() {
+        GroupingVector = groupingVector;
+    }
+
+    public abstract IPackingSolutionEncoding GetSolutionAfterMove();
+    public abstract Type GetMoveAttributeType();
+    public abstract GroupingMoveAttribute GetAttribute(double quality);
+    public abstract bool BelongsToAttribute (GroupingMoveAttribute attribute, bool hardCriterion);
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/GroupingMoveAttribute.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/GroupingMoveAttribute.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/GroupingMoveAttribute.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.GroupingVector {
+  [Item("GroupingMoveAttribute", "Base class for specifying a move attribute for grouping vector moves.")]
+  [StorableClass]
+  public class GroupingMoveAttribute : Item {
+    [Storable]
+    public double MoveQuality { get; protected set; }
+
+    [StorableConstructor]
+    protected GroupingMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected GroupingMoveAttribute(GroupingMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.MoveQuality = original.MoveQuality;
+    }
+    public GroupingMoveAttribute() : this(0) { }
+    public GroupingMoveAttribute( double moveQuality)
+      : base() {
+      MoveQuality = moveQuality;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingMoveAttribute(this, cloner);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/GroupingMoveHardTabuCriterion.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/GroupingMoveHardTabuCriterion.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/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.GroupingVector {
+  [Item("GroupingMoveHardTabuCriterion", "<Missing>")]
+  [StorableClass]
+  public class GroupingMoveHardTabuCriterion : SingleSuccessorOperator, IGroupingVectorMoveOperator, ITabuChecker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+    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 GroupingMoveHardTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected GroupingMoveHardTabuCriterion(GroupingMoveHardTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public GroupingMoveHardTabuCriterion()
+      : base() {
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "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 GroupingMoveHardTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      GroupingMove move = PackingMoveParameter.ActualValue as GroupingMove;
+      GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue;
+      int length = groupingVector.GroupingVector.Length;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool maximization = MaximizationParameter.ActualValue.Value;   
+      bool useAspiration = UseAspirationCriterionParameter.Value.Value;
+      bool isTabu = IsMoveTabu(tabuList, move, groupingVector, moveQuality, maximization, useAspiration);
+
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+
+    private bool IsMoveTabu(ItemList<IItem> tabuList, GroupingMove move, GroupingVectorEncoding groupingVector, double moveQuality, bool maximization, bool useAspiration) {
+      bool isTabu = false;
+      var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType()));
+
+      foreach (IItem attr in attributes) {
+        GroupingMoveAttribute gvAttr = attr as GroupingMoveAttribute;
+        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/GroupingVector/Moves/GroupingMoveMaker.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/GroupingMoveMaker.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/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.GroupingVector {
+  [Item("Grouping Move Maker", "Peforms a grouping move on a given grouping vector and updates the quality.")]
+  [StorableClass]
+  public class GroupingMoveMaker : SingleSuccessorOperator, IMoveMaker, IGroupingVectorMoveOperator {
+    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<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+    public ILookupParameter<IPackingPlan> PackingPlanParameter {
+      get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlan"]; }
+    }
+    public ILookupParameter<IPackingPlan> PackingPlanAfterMoveParameter {
+      get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlanAfterMove"]; }
+    }
+
+    [StorableConstructor]
+    protected GroupingMoveMaker(bool deserializing) : base(deserializing) { }
+    protected GroupingMoveMaker(GroupingMoveMaker original, Cloner cloner) : base(original, cloner) { }
+    public GroupingMoveMaker()
+      : 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<GroupingVectorEncoding>("GroupingVector", "The solution as grouping 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 GroupingMoveMaker(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      IPackingMove move = PackingMoveParameter.ActualValue;
+      GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue;
+      DoubleValue moveQuality = MoveQualityParameter.ActualValue;
+      DoubleValue quality = QualityParameter.ActualValue;
+
+      groupingVector.GroupingVector = (move.GetSolutionAfterMove() as GroupingVectorEncoding).GroupingVector;
+      PackingPlanParameter.ActualValue = PackingPlanAfterMoveParameter.ActualValue;
+
+      quality.Value = moveQuality.Value;
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/GroupingMoveSoftTabuCriterion.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/GroupingMoveSoftTabuCriterion.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/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.GroupingVector {
+  [Item("GroupingMoveSoftTabuCriterion", "<Missing>")]
+  [StorableClass]
+  public class GroupingMoveSoftTabuCriterion : SingleSuccessorOperator, IGroupingVectorMoveOperator, ITabuChecker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+    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 GroupingMoveSoftTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected GroupingMoveSoftTabuCriterion(GroupingMoveSoftTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public GroupingMoveSoftTabuCriterion()
+      : base() {
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "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 GroupingMoveSoftTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      GroupingMove move = PackingMoveParameter.ActualValue as GroupingMove;
+      GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue;
+      int length = groupingVector.GroupingVector.Length;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool maximization = MaximizationParameter.ActualValue.Value;   
+      bool useAspiration = UseAspirationCriterionParameter.Value.Value;
+      bool isTabu = IsMoveTabu(tabuList, move, groupingVector, moveQuality, maximization, useAspiration);
+
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+
+    private bool IsMoveTabu(ItemList<IItem> tabuList, GroupingMove move, GroupingVectorEncoding groupingVector, double moveQuality, bool maximization, bool useAspiration) {
+      bool isTabu = false;
+      var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType()));
+
+      foreach (IItem attr in attributes) {
+        GroupingMoveAttribute gvAttr = attr as GroupingMoveAttribute;
+        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/GroupingVector/Moves/GroupingTabuMaker.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/GroupingTabuMaker.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/GroupingTabuMaker.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.GroupingVector {
+  [Item("Grouping tabu maker", "Declares a given grouping 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 GroupingTabuMaker : TabuMaker, IGroupingVectorMoveOperator{
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+
+    [StorableConstructor]
+    protected GroupingTabuMaker(bool deserializing) : base(deserializing) { }
+    protected GroupingTabuMaker(GroupingTabuMaker original, Cloner cloner) : base(original, cloner) { }
+    public GroupingTabuMaker()
+      : base() {
+        Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingTabuMaker(this, cloner);
+    }
+
+    protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) {
+      IPackingMove move = PackingMoveParameter.ActualValue;
+      GroupingVectorEncoding groupingVector = GroupingVectorParameter.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 gMove = move as GroupingMove;
+
+      if (gMove != null)
+        return gMove.GetAttribute(baseQuality);
+      else
+        return move.GetSolutionAfterMove();
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SwapGrouping/ExhaustiveSwapGroupingMoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SwapGrouping/ExhaustiveSwapGroupingMoveGenerator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SwapGrouping/ExhaustiveSwapGroupingMoveGenerator.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.GroupingVector {
+  [Item("Exhaustive Swap Grouping Move Generator", "Generates all possible Swap grouping moves from a given groupingVector.")]
+  [StorableClass]
+  public class ExhaustiveSwapGroupingMoveGenerator : SwapGroupingMoveGenerator, IExhaustiveMoveGenerator {
+    [StorableConstructor]
+    protected ExhaustiveSwapGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ExhaustiveSwapGroupingMoveGenerator(ExhaustiveSwapGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveSwapGroupingMoveGenerator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveSwapGroupingMoveGenerator(this, cloner);
+    }
+    public static IEnumerable<SwapGroupingMove> Generate(GroupingVectorEncoding groupingVector, int nrOfBins) {
+      for (int i = 0; i < groupingVector.GroupingVector.Length - 1; i++)
+        for (int j = i + 1; j < groupingVector.GroupingVector.Length; j++) {
+          if (j != i)
+            yield return new SwapGroupingMove(i, j, groupingVector);
+        }
+    }
+
+    public static SwapGroupingMove[] Apply(GroupingVectorEncoding groupingVector) {
+      int nrOfBins = 0;
+      foreach (int binNr in groupingVector.GroupingVector) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+
+      int totalMoves = (groupingVector.GroupingVector.Length * (groupingVector.GroupingVector.Length - 1)) / 2;
+      SwapGroupingMove[] moves = new SwapGroupingMove[totalMoves];
+      int count = 0;
+      foreach (SwapGroupingMove move in Generate(groupingVector, nrOfBins)) {
+        moves[count++] = move;
+      }
+      return moves;
+    }
+
+    protected override SwapGroupingMove[] GenerateMoves(GroupingVectorEncoding groupingVector) {
+      return Apply(groupingVector);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SwapGrouping/StochasticSwapGroupingMoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SwapGrouping/StochasticSwapGroupingMoveGenerator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SwapGrouping/StochasticSwapGroupingMoveGenerator.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.GroupingVector {
+  [Item("Stochastic SwapGrouping Move Generator", "Generates a number of possible grouping moves from a given grouping vector.")]
+  [StorableClass]
+  public class StochasticSwapGroupingMoveGenerator : SwapGroupingMoveGenerator, 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 StochasticSwapGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticSwapGroupingMoveGenerator(StochasticSwapGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticSwapGroupingMoveGenerator()
+      : 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 StochasticSwapGroupingMoveGenerator(this, cloner);
+    }
+
+    public static SwapGroupingMove[] Apply(GroupingVectorEncoding groupingVector, IRandom random, int sampleSize) {
+
+      int nrOfBins = 0;
+      foreach (int binNr in groupingVector.GroupingVector) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+      var generatedMoves = new List<SwapGroupingMove>();
+      var moves = new List<SwapGroupingMove>(ExhaustiveSwapGroupingMoveGenerator.Generate(groupingVector, nrOfBins));
+      int moveCount = moves.Count;
+      for (int i = 0; i < sampleSize; i++) {
+        generatedMoves.Add(moves[random.Next(moveCount)]);
+      }
+
+      return generatedMoves.ToArray();
+    }
+
+    protected override SwapGroupingMove[] GenerateMoves(GroupingVectorEncoding SwapGrouping) {
+      IRandom random = RandomParameter.ActualValue;
+      return Apply(SwapGrouping, random, SampleSizeParameter.ActualValue.Value);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SwapGrouping/SwapGroupingMove.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SwapGrouping/SwapGroupingMove.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SwapGrouping/SwapGroupingMove.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 System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Swap Grouping Move", "A move on a grouping vector that is specified by two group-assignment-indexes.")]
+  [StorableClass]
+  public class SwapGroupingMove : GroupingMove, IPackingMove {
+    [Storable]
+    public int Index1 { get; protected set; }
+    [Storable]
+    public int Index2 { get; protected set; }
+
+    [StorableConstructor]
+    protected SwapGroupingMove(bool deserializing) : base(deserializing) { }
+    protected SwapGroupingMove(SwapGroupingMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index1 = original.Index1;
+      this.Index2 = original.Index2;
+    }
+    public SwapGroupingMove(int index1, int index2, GroupingVectorEncoding groupingVector)
+      : base(groupingVector) {
+      Index1 = index1;
+      Index2 = index2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SwapGroupingMove(this, cloner);
+    }
+
+    public override IPackingSolutionEncoding GetSolutionAfterMove() {
+      GroupingVectorEncoding newSolution = new GroupingVectorEncoding();
+      newSolution.GroupingVector = new IntegerVector(GroupingVector.GroupingVector);
+      newSolution.GroupingVector[Index1] = GroupingVector.GroupingVector[Index2];
+      newSolution.GroupingVector[Index2] = GroupingVector.GroupingVector[Index1];
+      return newSolution;
+    }
+
+    public override Type GetMoveAttributeType() {
+      return typeof(SwapGroupingMoveAttribute);
+    }
+
+    public override GroupingMoveAttribute GetAttribute(double quality) {
+      return new SwapGroupingMoveAttribute(Index1, Index2, GroupingVector.GroupingVector[Index1], GroupingVector.GroupingVector[Index2], quality);
+    }
+
+    public override bool BelongsToAttribute(GroupingMoveAttribute attribute, bool hardCriterion) {
+      var attr = attribute as SwapGroupingMoveAttribute;
+      if (attr != null) {
+        if (hardCriterion) {
+          if (Index1 == attr.ItemIndex1 || Index2 == attr.ItemIndex2)// || GroupingVector.GroupingVector[Index1] == attr.AssignedBin1 || GroupingVector.GroupingVector[Index2] == attr.AssignedBin2)
+            return true;
+        } else
+          if (Index1 == attr.ItemIndex1 && Index2 == attr.ItemIndex2)// && GroupingVector.GroupingVector[Index1] == attr.AssignedBin1 && GroupingVector.GroupingVector[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/GroupingVector/Moves/SwapGrouping/SwapGroupingMoveAttribute.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SwapGrouping/SwapGroupingMoveAttribute.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SwapGrouping/SwapGroupingMoveAttribute.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.GroupingVector {
+  [Item("SwapGroupingMoveAttribute", "Specifies the tabu attributes for a Swap grouping move on a grouping vector.")]
+  [StorableClass]
+  public class SwapGroupingMoveAttribute : GroupingMoveAttribute {
+    [Storable]
+    public int ItemIndex1 { get; protected set; }
+    [Storable]
+    public int ItemIndex2 { get; protected set; }
+    [Storable]
+    public int AssignedBin1 { get; protected set; }
+    [Storable]
+    public int AssignedBin2 { get; protected set; }
+
+    [StorableConstructor]
+    protected SwapGroupingMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected SwapGroupingMoveAttribute(SwapGroupingMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.ItemIndex1 = original.ItemIndex1;
+      this.ItemIndex2 = original.ItemIndex2;
+      this.AssignedBin1 = original.AssignedBin1;
+      this.AssignedBin2 = original.AssignedBin2;
+    }
+    public SwapGroupingMoveAttribute() : this(-1, -1, -1, -1, -1) { }
+    public SwapGroupingMoveAttribute(int itemIndex1, int itemIndex2, int assignedBin1, int assignedBin2, double moveQuality)
+      : base(moveQuality) {
+      ItemIndex1 = itemIndex1;
+      ItemIndex2 = itemIndex2;
+      AssignedBin1 = assignedBin1;
+      AssignedBin2 = assignedBin2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SwapGroupingMoveAttribute(this, cloner);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SwapGrouping/SwapGroupingMoveGenerator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SwapGrouping/SwapGroupingMoveGenerator.cs	(revision 9563)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SwapGrouping/SwapGroupingMoveGenerator.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.GroupingVector {
+  [Item("Swap Grouping Move Generator", "Base class for all Swap grouping move generators.")]
+  [StorableClass]
+  public abstract class SwapGroupingMoveGenerator : SingleSuccessorOperator, IGroupingVectorMoveOperator, IMoveGenerator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (LookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    [StorableConstructor]
+    protected SwapGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected SwapGroupingMoveGenerator(SwapGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public SwapGroupingMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The grouping 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() {
+      GroupingVectorEncoding gv = GroupingVectorParameter.ActualValue;
+      SwapGroupingMove[] moves = GenerateMoves(gv);
+      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 SwapGroupingMove[] GenerateMoves(GroupingVectorEncoding groupingVector);
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/UniformGroupingVectorManipulator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/UniformGroupingVectorManipulator.cs	(revision 9495)
+++ 	(revision )
@@ -1,48 +1,0 @@
-﻿#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.Data;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-
-namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
-  [Item("Uniform Grouping Vector Manipulator", "An operator which manipulates a PackingSequence representation.")]
-  [StorableClass]
-  public class UniformGroupingVectorManipulator :  GroupingVectorManipulator {
-    [StorableConstructor]
-    protected UniformGroupingVectorManipulator(bool deserializing) : base(deserializing) { }
-    protected UniformGroupingVectorManipulator(UniformGroupingVectorManipulator original, Cloner cloner) : base(original, cloner) { }
-    public UniformGroupingVectorManipulator()
-      : base() {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new UniformGroupingVectorManipulator(this, cloner);
-    }
-
-    protected override void Manipulate(IRandom random, GroupingVectorEncoding individual) {
-      IntegerVectorEncoding.UniformOnePositionManipulator.Apply(random, individual.GroupingVector, new IntMatrix(new int[1,2] { {0, 5} }));
-    }
-
-  }
-}
