Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlans/PackingPlan2DView.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlans/PackingPlan2DView.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlans/PackingPlan2DView.cs	(revision 9495)
@@ -18,4 +18,13 @@
     public PackingPlan2DView() {
       InitializeComponent();
+    }       
+
+    protected override void DeregisterContentEvents() {
+      Content.QualityChanged -= new EventHandler(Content_QualityChanged);
+      base.DeregisterContentEvents();
+    }
+    protected override void RegisterContentEvents() {
+      base.RegisterContentEvents();
+      Content.QualityChanged += new EventHandler(Content_QualityChanged);
     }
 
@@ -46,5 +55,5 @@
     private void Redraw(PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> plan) {     
       int currentBin = (binSelection != null && binSelection.SelectedItem != null) ? (int)(binSelection.SelectedItem) : 0;
-      var bin = plan.PackingBinMeasures;
+      var bin = plan.GetPackingBinMeasuresForBinNr(currentBin);
       packingPlan2D.InitializeContainer(bin.Width, bin.Height);
       int i = 0;
@@ -65,4 +74,22 @@
     }
 
+
+
+    private void Content_QualityChanged(object sender, EventArgs e) {
+      if (InvokeRequired)
+        Invoke(new EventHandler(Content_QualityChanged), sender, e);
+      else {
+        binSelection.Items.Clear();
+        if (Content == null) {
+          Redraw();
+        } else {
+          for (int i = 0; i < Content.NrOfBins; i++)
+            binSelection.Items.Add(i);
+          Redraw(Content);
+        }
+        packingPlan2D.Invalidate();
+        packingPlan2D.Update();
+      }
+    }  
   }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlans/PackingPlan3DView.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlans/PackingPlan3DView.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlans/PackingPlan3DView.cs	(revision 9495)
@@ -18,7 +18,16 @@
     public PackingPlan3DView() {
       InitializeComponent();
-      this.nameTextBox.Text = "XX";
+      this.nameTextBox.Text = "Packing Plan";
     }
 
+
+    protected override void DeregisterContentEvents() {
+      Content.QualityChanged -= new EventHandler(Content_QualityChanged);
+      base.DeregisterContentEvents();
+    }
+    protected override void RegisterContentEvents() {
+      base.RegisterContentEvents();
+      Content.QualityChanged += new EventHandler(Content_QualityChanged);
+    }
 
     public new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Content {
@@ -34,5 +43,5 @@
         packingPlan3D.InitializeContainer(0, 0, 0);
       } else {
-        Content.Name = "XX";
+        Content.Name = "Packing Plan";
         for (int i = 0; i < Content.NrOfBins; i++)
           binSelection.Items.Add(i);
@@ -45,5 +54,5 @@
     private void UpdateModel() {
       int currentBin = (binSelection != null && binSelection.SelectedItem != null) ? (int)(binSelection.SelectedItem) : 0;
-      var bin = Content.PackingBinMeasures;
+      var bin = Content.GetPackingBinMeasuresForBinNr(currentBin);
       packingPlan3D.InitializeContainer(bin.Width, bin.Height, bin.Depth);
       int i = 0;
@@ -58,14 +67,4 @@
         i++;
       }
-
-      int selectedItem = -1;
-      if ((itemSelection != null && itemSelection.SelectedItem != null)) {
-        if (!Int32.TryParse(itemSelection.SelectedItem.ToString(), out selectedItem)) {
-          //if (itemSelection.SelectedItem.ToString().Equals("enum"))
-          //  packingPlan3D.StartItemEnumeration();
-          selectedItem = -1;
-        } else
-          packingPlan3D.SelectItem(selectedItem);
-      } 
     }
 
@@ -80,5 +79,4 @@
           itemSelection.Items.Add(i);
       }
-      //itemSelection.Items.Add("enum");
 
       packingPlan3D.Invalidate();
@@ -88,8 +86,32 @@
     private void itemSelection_SelectedIndexChanged(object sender, EventArgs e) {
       UpdateModel();
+
+      int selectedItem = -1;
+      if ((itemSelection != null && itemSelection.SelectedItem != null) && Int32.TryParse(itemSelection.SelectedItem.ToString(), out selectedItem)) {
+        packingPlan3D.SelectItem(selectedItem);
+      } else      
+        packingPlan3D.UnselectItem();
+
       packingPlan3D.Invalidate();
       packingPlan3D.Update();
     }
 
+    private void Content_QualityChanged(object sender, EventArgs e) {
+      if (InvokeRequired)
+        Invoke(new EventHandler(Content_QualityChanged), sender, e);
+      else {
+        binSelection.Items.Clear();
+        if (Content == null) {
+          packingPlan3D.InitializeContainer(0, 0, 0);
+        } else {
+          Content.Name = "Packing Plan";
+          for (int i = 0; i < Content.NrOfBins; i++)
+            binSelection.Items.Add(i);
+          binSelection.SelectedIndex = 0;
+          UpdateModel();
+          packingPlan3D.StartRendering();
+        }
+      }
+    }  
   }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Plugin.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Plugin.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Plugin.cs	(revision 9495)
@@ -26,5 +26,5 @@
   /// Plugin class for HeuristicLab.Problems.BinPacking.Views plugin.
   /// </summary>
-  [Plugin("HeuristicLab.Problems.BinPacking.Views", "3.3.7.9440")]
+  [Plugin("HeuristicLab.Problems.BinPacking.Views", "3.3.7.9473")]
   [PluginFile("HeuristicLab.Problems.BinPacking.Views-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Common", "3.3")]
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Properties/AssemblyInfo.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Properties/AssemblyInfo.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Properties/AssemblyInfo.cs	(revision 9495)
@@ -54,3 +54,3 @@
 // by using the '*' as shown below:
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.7.9440")]
+[assembly: AssemblyFileVersion("3.3.7.9473")]
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftFunctions.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftFunctions.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftFunctions.cs	(revision 9495)
@@ -5,4 +5,6 @@
 using HeuristicLab.Collections;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
 using HeuristicLab.Problems.BinPacking.Dimensions;
@@ -14,11 +16,173 @@
 namespace HeuristicLab.Problems.BinPacking.Decoders {
   public static class BottomLeftFunctions {
-    
-
-
-    public static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
+
+
+    public static ObservableDictionary<int, TwoDimensionalPacking> BottomLeftPacking(
+      MultiComponentVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+      int nrOfBins = solution.NrOfBins;
+
+      //Get all indexes of items for every bin according to grouping-vector
+      Dictionary<int, List<PackingInformation>> unpackedItemIndexesPerBin = new Dictionary<int, List<PackingInformation>>();
+
+      for (int i = 0; i < nrOfBins; i++) {
+        unpackedItemIndexesPerBin[i] = new List<PackingInformation>(solution.PackingInformations[i]);
+      }
+
+      ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
+      var remainingItems = new List<PackingInformation>();
+
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins; binNr++) {
+        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
+        var unpackedItems = unpackedItemIndexesPerBin[binNr];
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemID;
+          var item = itemMeasures[itemIndex];
+          TwoDimensionalPacking position = null;
+
+          position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures, unpackedItems[i].Rotated);
+
+          if (position == null) {
+            position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures, !unpackedItems[i].Rotated);
+          }
+          if (position == null) {
+            remainingItems.Add(unpackedItems[i]);
+          } else {
+            packingPositions[itemIndex] = position;
+            solution.PackingInformations[binNr].Remove(unpackedItems[i]);
+            solution.PackingInformations[binNr].Find(pi => pi.ItemID == itemIndex).Rotated = position.Rotated;
+          }
+        }
+      }
+
+      //Packing of remaining items
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
+        var unpackedItems = new List<PackingInformation>(remainingItems);
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemID;
+          var item = itemMeasures[itemIndex];
+          TwoDimensionalPacking position = null;
+
+          //Look for space in current bin
+          position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures, unpackedItems[i].Rotated);
+
+          if (position == null) {
+            position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures, !unpackedItems[i].Rotated);
+          }
+          if (position != null) {
+            packingPositions[itemIndex] = position;
+            remainingItems.Remove(unpackedItems[i]);
+            solution.PackingInformations[binNr].Add(unpackedItems[i]);
+            solution.PackingInformations[binNr].Find(pi => pi.ItemID == itemIndex).Rotated = position.Rotated;
+          }
+        }
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          solution.PackingInformations[nrOfBins] = new ItemList<PackingInformation>();
+          nrOfBins++;
+        }
+      }
+
+      return packingPositions;
+    }
+
+    public static ObservableDictionary<int, TwoDimensionalPacking> BottomLeftPacking(
+      GroupingVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+
+      int nrOfBins = solution.GroupingVector.Max() + 1;
+
+      //Get all indexes of items for every bin according to grouping-vector
+      //It is assumed, that at this point the item-indexes are sorted according to their item-size!
+      Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>();
+
+      for (int i = 0; i < nrOfBins; i++) {
+        unpackedItemIndexesPerBin[i] = solution.GroupingVector
+          .Select((Value, Index) => new { Value, Index })
+          .Where(temp => temp.Value == i)
+          .Select(temp => temp.Index).ToList();
+      }
+
+      ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
+      var remainingItems = new List<int>();
+
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins; binNr++) {
+        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
+        var unpackedItems = unpackedItemIndexesPerBin[binNr];
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i];
+          var item = itemMeasures[itemIndex];
+          TwoDimensionalPacking position = null;
+
+          //Look for space in current bin
+          position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures);
+
+          //Did not find enough space in current bin
+          if (position == null) {
+            remainingItems.Add(itemIndex);
+          } else
+            packingPositions[itemIndex] = position;
+        }
+      }
+
+      //Packing of remaining items
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
+        var unpackedItems = new List<int>(remainingItems);
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i];
+          var item = itemMeasures[itemIndex];
+          TwoDimensionalPacking position = null;
+
+          //Look for space in current bin
+          position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures);
+
+          if (position != null) {
+            packingPositions[itemIndex] = position;
+            remainingItems.Remove(itemIndex);
+            solution.GroupingVector[itemIndex] = binNr;
+          }
+        }
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          nrOfBins++;
+        }
+      }
+
+      return packingPositions;
+    }
+
+    public static ObservableDictionary<int, TwoDimensionalPacking> BottomLeftPacking(
+      PackingSequenceEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+
+      ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
+      int nrOfBins = 1;
+      for (int i = 0; i < solution.PackingSequence.Length; i++) {
+        var item = itemMeasures[solution.PackingSequence[i]];
+        TwoDimensionalPacking position = null;
+        //Look for space in existing bins
+        for (int binNr = 0; binNr < nrOfBins; binNr++) {
+          position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures);
+          if (position != null)
+            break;
+        }
+        //Did not find enough space in any of the existing bins => create new bin
+        if (position == null) {
+          nrOfBins++;
+          position = BottomLeftFunctions.BottomLeftPosition(binMeasures, nrOfBins - 1, item, packingPositions, itemMeasures);
+        }
+
+        if (position == null)
+          position = new TwoDimensionalPacking(-1, 0, 0);
+
+        packingPositions[solution.PackingSequence[i]] = position;
+      }
+
+      return packingPositions;
+    }
+
+    private static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
       return BottomLeftPosition(binMeasures, binNr, currentItem, itemPositions, itemMeasures, false);
     }
-    public static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures, bool rotated) {      
+    private static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures, bool rotated) {      
       TwoDimensionalPacking currentPosition = new TwoDimensionalPacking(binNr, 
         binMeasures.Width - (rotated ? currentItem.Height : currentItem.Width), 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftGroupingVectorDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftGroupingVectorDecoder.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftGroupingVectorDecoder.cs	(revision 9495)
@@ -41,9 +41,8 @@
   [Item("Identical bin two dimensional grouping vector decoder", "<Description missing...>")]
   [StorableClass]
-  public class BottomLeftGroupingVectorDecoder : IdenticalBinPackingSolutionDecoder<
+  public class BottomLeftGroupingVectorDecoder : PackingSolutionDecoder<
       TwoDimensionalPacking,
       RectangularPackingBin,
-      RectangularPackingItem,
-      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+      RectangularPackingItem> {
 
     public BottomLeftGroupingVectorDecoder()
@@ -61,5 +60,5 @@
 
 
-    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
 
       var solution = encodedSolution as GroupingVectorEncoding;
@@ -69,76 +68,5 @@
         new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
 
-      int nrOfBins = solution.GroupingVector.Max() + 1;
-
-      //Get all indexes of items for every bin according to grouping-vector
-      //It is assumed, that at this point the item-indexes are sorted according to their item-size!
-      Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>();
-
-      for (int i = 0; i < nrOfBins; i++) {
-        unpackedItemIndexesPerBin[i] = solution.GroupingVector
-          .Select((Value, Index) => new { Value, Index })
-          .Where(temp => temp.Value == i)
-          .Select(temp => temp.Index).ToList();
-      }
-
-      ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
-      var remainingItems = new List<int>();
-
-      //Iterate over all bin-lists
-      for (int binNr = 0; binNr < nrOfBins; binNr++ ) {
-        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
-        var unpackedItems = unpackedItemIndexesPerBin [binNr];
-        for (int i = 0; i < unpackedItems.Count; i++ ) {
-          var itemIndex = unpackedItems[i];
-          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
-          TwoDimensionalPacking position = null;
-
-          //Look for space in current bin
-          position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-
-          //Did not find enough space in current bin
-          if (position == null) {
-            remainingItems.Add(itemIndex);
-            //if (binNr + 1 >= nrOfBins) {
-            //  nrOfBins++;
-            //  unpackedItemIndexesPerBin[binNr + 1] = new List<int>();
-            //  unpackedItemIndexesPerBin[binNr + 1].Add(itemIndex);
-            //  unpackedItemIndexesPerBin[binNr].Remove(itemIndex);
-            //} else {
-            //  unpackedItemIndexesPerBin[binNr + 1].Add(itemIndex);
-            //  unpackedItemIndexesPerBin[binNr + 1].Sort();
-            //}
-            //solution.GroupingVector[itemIndex] = binNr + 1;
-          } else
-            packingPositions[itemIndex] = position;
-        }
-      }
-
-      //Packing of remaining items
-      //Iterate over all bin-lists
-      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
-        var unpackedItems = new List<int>(remainingItems);
-        for (int i = 0; i < unpackedItems.Count; i++) {
-          var itemIndex = unpackedItems[i];
-          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
-          TwoDimensionalPacking position = null;
-
-          //Look for space in current bin
-          position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-
-          if (position != null) {
-            packingPositions[itemIndex] = position;
-            remainingItems.Remove(itemIndex);
-            solution.GroupingVector[itemIndex] = binNr;
-          }
-        }
-        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
-          nrOfBins++;
-        }
-      }
-
-      result.PackingItemPositions = packingPositions;
-
-
+      result.PackingItemPositions = BottomLeftFunctions.BottomLeftPacking(solution, binMeasures, itemMeasures);
       return result;
     }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftMultiComponentVectorDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftMultiComponentVectorDecoder.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftMultiComponentVectorDecoder.cs	(revision 9495)
@@ -41,9 +41,8 @@
   [Item("Identical bin two dimensional multi component vector decoder", "<Description missing...>")]
   [StorableClass]
-  public class BottomLeftMultiComponentVectorDecoder : IdenticalBinPackingSolutionDecoder<
+  public class BottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<
       TwoDimensionalPacking,
       RectangularPackingBin,
-      RectangularPackingItem,
-      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+      RectangularPackingItem> {
 
     public BottomLeftMultiComponentVectorDecoder()
@@ -61,5 +60,5 @@
 
 
-    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
 
       var solution = encodedSolution as MultiComponentVectorEncoding;
@@ -68,69 +67,6 @@
       PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
         new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
-      int nrOfBins = solution.PackingInformations.Max(pi => pi.AssignedBin) + 1;
-
-      //Get all indexes of items for every bin according to grouping-vector
-      Dictionary<int, List<PackingInformation>> unpackedItemIndexesPerBin = new Dictionary<int, List<PackingInformation>>();
-
-      for (int i = 0; i < nrOfBins; i++) {
-        unpackedItemIndexesPerBin[i] = solution.PackingInformations
-          .Where(pi => pi.AssignedBin == i)
-          .ToList();
-      }
-
-      ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
-      var remainingItems = new List<PackingInformation>();
-
-      //Iterate over all bin-lists
-      for (int binNr = 0; binNr < nrOfBins; binNr++) {
-        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
-        var unpackedItems = unpackedItemIndexesPerBin[binNr];
-        for (int i = 0; i < unpackedItems.Count; i++) {
-          var itemIndex = unpackedItems[i].ItemIndex;
-          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
-          TwoDimensionalPacking position = null;
-
-          position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, unpackedItems[i].Rotated);
-
-          if (position == null) {
-            position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, !unpackedItems[i].Rotated);
-          }
-          if (position == null) {
-            remainingItems.Add(unpackedItems[i]);
-          } else {
-            packingPositions[itemIndex] = position;
-            solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).Rotated = position.Rotated;
-          }
-        }
-      }
-
-      //Packing of remaining items
-      //Iterate over all bin-lists
-      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
-        var unpackedItems = new List<PackingInformation>(remainingItems);
-        for (int i = 0; i < unpackedItems.Count; i++) {
-          var itemIndex = unpackedItems[i].ItemIndex;
-          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
-          TwoDimensionalPacking position = null;
-
-          //Look for space in current bin
-          position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, unpackedItems[i].Rotated);
-
-          if (position == null) {
-            position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, !unpackedItems[i].Rotated);
-          }
-          if (position != null) {
-            packingPositions[itemIndex] = position;
-            remainingItems.Remove(unpackedItems[i]);
-            solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).AssignedBin = binNr;
-            solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).Rotated = position.Rotated;
-          }
-        }
-        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
-          nrOfBins++;
-        }
-      }
-
-      result.PackingItemPositions = packingPositions;
+      
+      result.PackingItemPositions = BottomLeftFunctions.BottomLeftPacking(solution, binMeasures, itemMeasures);
 
       return result;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftPackingSequenceDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftPackingSequenceDecoder.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftPackingSequenceDecoder.cs	(revision 9495)
@@ -40,9 +40,8 @@
   [Item("Identical bin, two dimensional, direct permutation decoder", "<Description missing...>")]
   [StorableClass]
-  public class BottomLeftPackingSequenceDecoder : IdenticalBinPackingSolutionDecoder<
+  public class BottomLeftPackingSequenceDecoder : PackingSolutionDecoder<
       TwoDimensionalPacking,
       RectangularPackingBin,
-      RectangularPackingItem,
-      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+      RectangularPackingItem> {
 
     public BottomLeftPackingSequenceDecoder()
@@ -60,5 +59,5 @@
 
 
-    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
 
       var solution = encodedSolution as PackingSequenceEncoding;
@@ -68,28 +67,5 @@
         new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
 
-      ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
-      int nrOfBins = 1;
-      for (int i = 0; i < solution.PackingSequence.Length; i++) {
-        var item = PackingItemMeasuresParameter.ActualValue[solution.PackingSequence[i]];
-        TwoDimensionalPacking position = null;
-        //Look for space in existing bins
-        for (int binNr = 0; binNr < nrOfBins; binNr++) {
-          position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-          if (position != null)
-            break;
-        }
-        //Did not find enough space in any of the existing bins => create new bin
-        if (position == null) {
-          nrOfBins++;
-          position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, nrOfBins - 1, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-        }
-
-        if (position == null)
-          position = new TwoDimensionalPacking(-1, 0, 0);
-
-        packingPositions[solution.PackingSequence[i]] = position;
-      }
-
-      result.PackingItemPositions = packingPositions;
+      result.PackingItemPositions = BottomLeftFunctions.BottomLeftPacking (solution, binMeasures, itemMeasures);
 
       return result;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointGroupingVectorDecoder2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointGroupingVectorDecoder2D.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointGroupingVectorDecoder2D.cs	(revision 9495)
@@ -41,9 +41,8 @@
   [Item("Identical bin, two dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointGroupingVectorDecoder2D : IdenticalBinPackingSolutionDecoder<
+  public class ExtremePointGroupingVectorDecoder2D : PackingSolutionDecoder<
       TwoDimensionalPacking,
       RectangularPackingBin,
-      RectangularPackingItem,
-      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+      RectangularPackingItem> {
 
     public ExtremePointGroupingVectorDecoder2D ()
@@ -68,5 +67,5 @@
     }
 
-    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
                       
       var solution = encodedSolution as GroupingVectorEncoding;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointMultiComponentVectorDecoder2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointMultiComponentVectorDecoder2D.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointMultiComponentVectorDecoder2D.cs	(revision 9495)
@@ -42,9 +42,8 @@
   [Item("Identical bin, two dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointMultiComponentVectorDecoder2D : IdenticalBinPackingSolutionDecoder<
+  public class ExtremePointMultiComponentVectorDecoder2D : PackingSolutionDecoder<
       TwoDimensionalPacking,
       RectangularPackingBin,
-      RectangularPackingItem,
-      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+      RectangularPackingItem> {
 
     public ExtremePointMultiComponentVectorDecoder2D ()
@@ -69,10 +68,10 @@
     }
 
-    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
 
       var solution = encodedSolution as MultiComponentVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
 
-      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      return Decode(solution, binMeasures, itemMeasures);
     }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointPackingSequenceDecoder2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 9495)
@@ -40,9 +40,8 @@
   [Item("Identical bin, two dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointPackingSequenceDecoder2D : IdenticalBinPackingSolutionDecoder<
+  public class ExtremePointPackingSequenceDecoder2D : PackingSolutionDecoder<
       TwoDimensionalPacking,
       RectangularPackingBin,
-      RectangularPackingItem,
-      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+      RectangularPackingItem> {
 
     public ExtremePointPackingSequenceDecoder2D ()
@@ -59,5 +58,5 @@
 
 
-    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
 
       var solution = encodedSolution as PackingSequenceEncoding;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointsFunctions2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointsFunctions2D.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointsFunctions2D.cs	(revision 9495)
@@ -24,5 +24,5 @@
 
       #region Preperations
-      int nrOfBins = solution.PackingInformations.Max(x => x.AssignedBin) + 1;
+          int nrOfBins = solution.NrOfBins;
 
       //Get all indexes of items for every bin according to grouping-vector                      
@@ -32,7 +32,5 @@
 
       for (int i = 0; i < nrOfBins; i++) {        
-        unpackedItemIndexesPerBin[i] = solution.PackingInformations
-          .Where(pi => pi.AssignedBin == i)
-          .ToList();
+        unpackedItemIndexesPerBin[i] = new List<PackingInformation> (solution.PackingInformations[i]);
 
         extremePointsForBin[i] = new HashSet<TwoDimensionalPacking>();
@@ -52,8 +50,8 @@
         var unpackedItems = unpackedItemIndexesPerBin[binNr];
         for (int i = 0; i < unpackedItems.Count; i++) {
-          var itemIndex = unpackedItems[i].ItemIndex;
+          var itemIndex = unpackedItems[i].ItemID;
           var item = itemMeasures[itemIndex];
 
-          extremePointsForBin[binNr] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
           var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
           if (positionFound != null) {
@@ -62,6 +60,8 @@
             occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
             extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
-          } else
+          } else {
             remainingItems.Add(unpackedItems[i]);
+            solution.PackingInformations[binNr].Remove(unpackedItems[i]);
+          }
         }
       }
@@ -74,8 +74,8 @@
         //Iterate over all the remaining items
         for (int i = 0; i < unpackedItems.Count; i++) {
-          var itemIndex = unpackedItems[i].ItemIndex;
+          var itemIndex = unpackedItems[i].ItemID;
           var item = itemMeasures[itemIndex];
 
-          extremePointsForBin[binNr] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
           var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
           if (positionFound != null) {
@@ -85,4 +85,5 @@
             extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
             remainingItems.Remove(unpackedItems[i]);
+            solution.PackingInformations[binNr].Add(unpackedItems[i]);
           }
         }
@@ -91,4 +92,5 @@
           extremePointsForBin[nrOfBins].Add(new TwoDimensionalPacking(nrOfBins, 0, 0, false));
           occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+          solution.PackingInformations[nrOfBins] = new ItemList<PackingInformation>();
           nrOfBins++;
         }
@@ -136,5 +138,5 @@
           var item = itemMeasures[itemIndex];
 
-          extremePointsForBin[binNr] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
           var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
           if (positionFound != null) {
@@ -159,5 +161,5 @@
           var item = itemMeasures[itemIndex];
 
-          extremePointsForBin[binNr] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
           var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
           if (positionFound != null) {
@@ -197,5 +199,5 @@
       foreach (int itemIndex in solution.PackingSequence) {
         var item = itemMeasures[itemIndex];
-        extremePoints = new HashSet<TwoDimensionalPacking>(extremePoints.OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+        extremePoints = OrderExtremePoints(extremePoints, occupiedPoints, binMeasures);
         var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions);
         if (positionFound != null) {
@@ -296,4 +298,8 @@
       return extremePoints;
     }
+
+    public static HashSet<TwoDimensionalPacking> OrderExtremePoints(HashSet<TwoDimensionalPacking> hashSet, List<int[,]> occupiedPoints, RectangularPackingBin binMeasures) {
+      return new HashSet<TwoDimensionalPacking>(hashSet.OrderBy(ep => ep.AssignedBin).ThenBy(ep => ep.X).ThenBy(ep => ep.Y).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+    }
     private static int ShortestPossibleSideFromEP(TwoDimensionalPacking ep, List<int[,]> occupiedPoints, RectangularPackingBin binMeasures) {
       int shortestSide = int.MaxValue;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftFunctions.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftFunctions.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftFunctions.cs	(revision 9495)
@@ -6,4 +6,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
 using HeuristicLab.Problems.BinPacking.Dimensions;
@@ -16,4 +17,72 @@
   public static class DeepestBottomLeftFunctions {
 
+    public static ObservableDictionary<int, ThreeDimensionalPacking> DeepestLeftBottomPacking(MultiComponentVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+      int nrOfBins = solution.NrOfBins;
+
+      //Get all indexes of items for every bin according to grouping-vector
+      Dictionary<int, List<PackingInformation>> unpackedItemIndexesPerBin = new Dictionary<int, List<PackingInformation>>();
+
+      for (int i = 0; i < nrOfBins; i++) {
+        unpackedItemIndexesPerBin[i] = new List<PackingInformation>(solution.PackingInformations[i]);
+      }
+
+      ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
+      var remainingItems = new List<PackingInformation>();
+
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins; binNr++) {
+        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
+        var unpackedItems = unpackedItemIndexesPerBin[binNr];
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemID;
+          var item = itemMeasures[itemIndex];
+          ThreeDimensionalPacking position = null;
+
+          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures, unpackedItems[i].Rotated);
+
+          if (position == null) {
+            position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures, !unpackedItems[i].Rotated);
+          }
+          if (position == null) {
+            remainingItems.Add(unpackedItems[i]);
+            solution.PackingInformations[binNr].Remove(unpackedItems[i]);
+          } else {
+            packingPositions[itemIndex] = position;
+            solution.PackingInformations[binNr].Find(pi => pi.ItemID == itemIndex).Rotated = position.Rotated;
+          }
+        }
+      }
+
+      //Packing of remaining items
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
+        var unpackedItems = new List<PackingInformation>(remainingItems);
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemID;
+          var item = itemMeasures[itemIndex];
+          ThreeDimensionalPacking position = null;
+
+          //Look for space in current bin
+          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures, unpackedItems[i].Rotated);
+
+          if (position == null) {
+            position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures, !unpackedItems[i].Rotated);
+          }
+          if (position != null) {
+            packingPositions[itemIndex] = position;
+            remainingItems.Remove(unpackedItems[i]);
+            solution.PackingInformations[binNr].Add(unpackedItems[i]);
+            solution.PackingInformations[binNr].Find(pi => pi.ItemID == itemIndex).Rotated = position.Rotated;
+          }
+        }
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          solution.PackingInformations[nrOfBins] = new ItemList<PackingInformation>();
+          nrOfBins++;
+        }
+      }
+
+      return packingPositions;
+    }
+
     public static ObservableDictionary<int, ThreeDimensionalPacking> DeepestLeftBottomPacking(GroupingVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
       int nrOfBins = solution.GroupingVector.Max() + 1;
@@ -77,5 +146,30 @@
     }
 
-
+    public static ObservableDictionary<int, ThreeDimensionalPacking> DeepestLeftBottomPacking(PackingSequenceEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+      ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
+      int nrOfBins = 1;
+      for (int i = 0; i < solution.PackingSequence.Length; i++) {
+        var item = itemMeasures[solution.PackingSequence[i]];
+        ThreeDimensionalPacking position = null;
+        //Look for space in existing bins
+        for (int binNr = 0; binNr < nrOfBins; binNr++) {
+          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures);
+          if (position != null)
+            break;
+        }
+        //Did not find enough space in any of the existing bins => create new bin
+        if (position == null) {
+          nrOfBins++;
+          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, nrOfBins - 1, item, packingPositions, itemMeasures);
+        }
+
+        if (position == null)
+          position = new ThreeDimensionalPacking(-1, 0, 0, 0);
+
+        packingPositions[solution.PackingSequence[i]] = position;
+      }
+
+      return packingPositions;
+    }
 
     public static ThreeDimensionalPacking DeepestLeftBottomPosition(CuboidPackingBin binMeasures, int binNr, CuboidPackingItem currentItem, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures) {
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftGroupingVectorDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftGroupingVectorDecoder.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftGroupingVectorDecoder.cs	(revision 9495)
@@ -40,9 +40,8 @@
   [Item("Identical bin three dimensional direct grouping vector decoder", "<Description missing...>")]
   [StorableClass]
-  public class DeepestBottomLeftGroupingVectorDecoder : IdenticalBinPackingSolutionDecoder<
+  public class DeepestBottomLeftGroupingVectorDecoder : PackingSolutionDecoder<
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem,
-      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+      CuboidPackingItem> {
 
     public DeepestBottomLeftGroupingVectorDecoder()
@@ -60,5 +59,5 @@
 
 
-    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
 
       var solution = encodedSolution as GroupingVectorEncoding;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs	(revision 9495)
@@ -41,9 +41,8 @@
   [Item("Identical bin three dimensional multi component vector decoder", "<Description missing...>")]
   [StorableClass]
-  public class DeepestBottomLeftMultiComponentVectorDecoder : IdenticalBinPackingSolutionDecoder<
+  public class DeepestBottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem,
-      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+      CuboidPackingItem> {
 
     public DeepestBottomLeftMultiComponentVectorDecoder()
@@ -61,5 +60,5 @@
 
 
-    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
 
       var solution = encodedSolution as MultiComponentVectorEncoding;
@@ -68,69 +67,6 @@
       PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = 
         new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
-      int nrOfBins = solution.PackingInformations.Max(pi => pi.AssignedBin) + 1;
-
-      //Get all indexes of items for every bin according to grouping-vector
-      Dictionary<int, List<PackingInformation>> unpackedItemIndexesPerBin = new Dictionary<int, List<PackingInformation>>();
-
-      for (int i = 0; i < nrOfBins; i++) {
-        unpackedItemIndexesPerBin[i] = solution.PackingInformations
-          .Where(pi => pi.AssignedBin == i)
-          .ToList();
-      }
-
-      ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
-      var remainingItems = new List<PackingInformation>();
-
-      //Iterate over all bin-lists
-      for (int binNr = 0; binNr < nrOfBins; binNr++) {
-        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
-        var unpackedItems = unpackedItemIndexesPerBin[binNr];
-        for (int i = 0; i < unpackedItems.Count; i++) {
-          var itemIndex = unpackedItems[i].ItemIndex;
-          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
-          ThreeDimensionalPacking position = null;
-
-          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, unpackedItems[i].Rotated);
-
-          if (position == null) {
-            position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, !unpackedItems[i].Rotated);
-          }
-          if (position == null) {
-            remainingItems.Add(unpackedItems[i]);
-          } else {
-            packingPositions[itemIndex] = position;
-            solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).Rotated = position.Rotated;
-          }
-        }
-      }
-
-      //Packing of remaining items
-      //Iterate over all bin-lists
-      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
-        var unpackedItems = new List<PackingInformation>(remainingItems);
-        for (int i = 0; i < unpackedItems.Count; i++) {
-          var itemIndex = unpackedItems[i].ItemIndex;
-          var item = PackingItemMeasuresParameter.ActualValue[itemIndex];
-          ThreeDimensionalPacking position = null;
-
-          //Look for space in current bin
-          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, unpackedItems[i].Rotated);
-
-          if (position == null) {
-            position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, !unpackedItems[i].Rotated);
-          }
-          if (position != null) {    
-            packingPositions[itemIndex] = position;
-            remainingItems.Remove(unpackedItems[i]);
-            solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).AssignedBin = binNr;
-            solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).Rotated = position.Rotated;
-          } 
-        }  
-        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
-          nrOfBins++;
-        }
-      }
-
-      result.PackingItemPositions = packingPositions;
+      
+      result.PackingItemPositions = DeepestBottomLeftFunctions.DeepestLeftBottomPacking (solution, binMeasures, itemMeasures);
 
       return result;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftPackingSequenceDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftPackingSequenceDecoder.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftPackingSequenceDecoder.cs	(revision 9495)
@@ -40,9 +40,8 @@
   [Item("Identical bin, three dimensional, direct permutation decoder", "<Description missing...>")]
   [StorableClass]
-  public class DeepestBottomLeftPackingSequenceDecoder : IdenticalBinPackingSolutionDecoder<
+  public class DeepestBottomLeftPackingSequenceDecoder : PackingSolutionDecoder<
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem,
-      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+      CuboidPackingItem> {
 
     public DeepestBottomLeftPackingSequenceDecoder()
@@ -60,5 +59,5 @@
 
 
-    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
 
       var solution = encodedSolution as PackingSequenceEncoding;
@@ -68,28 +67,5 @@
         new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
 
-      ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
-      int nrOfBins = 1;
-      for (int i = 0; i < solution.PackingSequence.Length; i++) {
-        var item = PackingItemMeasuresParameter.ActualValue[solution.PackingSequence[i]];
-        ThreeDimensionalPacking position = null;
-        //Look for space in existing bins
-        for (int binNr = 0; binNr < nrOfBins; binNr++) {
-          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-          if (position != null)
-            break;
-        }
-        //Did not find enough space in any of the existing bins => create new bin
-        if (position == null) {
-          nrOfBins++;
-          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, nrOfBins - 1, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-        }
-
-        if (position == null)
-          position = new ThreeDimensionalPacking(-1, 0, 0, 0);
-
-        packingPositions[solution.PackingSequence[i]] = position;
-      }
-
-      result.PackingItemPositions = packingPositions;
+      result.PackingItemPositions = DeepestBottomLeftFunctions.DeepestLeftBottomPacking (solution, binMeasures, itemMeasures);
 
       return result;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointGroupingVectorDecoder3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointGroupingVectorDecoder3D.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointGroupingVectorDecoder3D.cs	(revision 9495)
@@ -41,9 +41,8 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointGroupingVectorDecoder3D : IdenticalBinPackingSolutionDecoder<
+  public class ExtremePointGroupingVectorDecoder3D : PackingSolutionDecoder<
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem,
-      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+      CuboidPackingItem> {
 
     public ExtremePointGroupingVectorDecoder3D ()
@@ -68,10 +67,10 @@
     }
 
-    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
                       
       var solution = encodedSolution as GroupingVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
 
-      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      return Decode(solution, binMeasures, itemMeasures);
     }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointMultiComponentVectorDecoder3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointMultiComponentVectorDecoder3D.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointMultiComponentVectorDecoder3D.cs	(revision 9495)
@@ -42,9 +42,8 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointMultiComponentVectorDecoder3D : IdenticalBinPackingSolutionDecoder<
+  public class ExtremePointMultiComponentVectorDecoder3D : PackingSolutionDecoder<
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem,
-      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+      CuboidPackingItem> {
 
     public ExtremePointMultiComponentVectorDecoder3D ()
@@ -69,10 +68,10 @@
     }
 
-    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
 
       var solution = encodedSolution as MultiComponentVectorEncoding;
       if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
 
-      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      return Decode(solution, binMeasures, itemMeasures);
     }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPackingSequenceDecoder3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 9495)
@@ -40,9 +40,8 @@
   [Item("Identical bin, three dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")]
   [StorableClass]
-  public class ExtremePointPackingSequenceDecoder3D : IdenticalBinPackingSolutionDecoder<
+  public class ExtremePointPackingSequenceDecoder3D : PackingSolutionDecoder<
       ThreeDimensionalPacking,
       CuboidPackingBin,
-      CuboidPackingItem,
-      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+      CuboidPackingItem> {
 
     public ExtremePointPackingSequenceDecoder3D ()
@@ -59,5 +58,5 @@
 
 
-    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+    public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
 
       var solution = encodedSolution as PackingSequenceEncoding;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointsFunctions3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointsFunctions3D.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointsFunctions3D.cs	(revision 9495)
@@ -9,5 +9,4 @@
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Encodings.PackingEncoding.Potvin;
 using HeuristicLab.Problems.BinPacking.Dimensions;
 using HeuristicLab.Problems.BinPacking.Interfaces;
@@ -20,153 +19,9 @@
 
 
-
-    public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(ref PotvinEncoding solution, 
-      ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) {
-        if (!solution.DelimiterInitialized) {
-          #region Preperations
-          var itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
-          int nrOfBins = 1;
-
-          var occupiedPoints = new List<int[, ,]>();
-          occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
-
-          HashSet<ThreeDimensionalPacking> extremePoints = new HashSet<ThreeDimensionalPacking>();
-          extremePoints.Add(new ThreeDimensionalPacking(0, 0, 0, 0, false));
-          #endregion
-
-          Dictionary<int, List<int>> itemIndexesForBin = new Dictionary<int, List<int>>();
-          itemIndexesForBin[0] = new List<int>();
-
-          foreach (int itemIndex in solution.IntVector) {
-            var item = itemMeasures[itemIndex];
-            extremePoints = OrderExtremePoints(extremePoints, occupiedPoints, binMeasures);
-            var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions);
-            if (positionFound != null) {
-              extremePoints.Remove(positionFound);
-            } else {
-              positionFound = new ThreeDimensionalPacking(nrOfBins, 0, 0, 0);
-              occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
-              itemIndexesForBin[nrOfBins] = new List<int>();
-              nrOfBins++;
-            }
-            itemPositions[itemIndex] = positionFound;
-            itemIndexesForBin[positionFound.AssignedBin].Add(itemIndex);
-            occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
-            extremePoints = GenerateNewExtremePointsForNewItem(extremePoints, occupiedPoints, item, positionFound, binMeasures);
-          }
-          List<int> intVector = new List<int>();
-          foreach (var indexes in itemIndexesForBin) {
-            foreach (var index in indexes.Value) {
-              intVector.Add(index);
-            }
-            intVector.Add(-1);
-          }
-          intVector.RemoveAt(intVector.Count - 1);
-          solution.IntVector = new IntegerVector (intVector.ToArray());
-
-          return itemPositions;
-        } else {
-          #region Preperations
-          int nrOfBins = solution.IntVector.Count(i => i.Equals (-1)) + 1;
-
-          //Get all indexes of items for every bin according to int vector
-          Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>();
-          Dictionary<int, HashSet<ThreeDimensionalPacking>> extremePointsForBin = new Dictionary<int, HashSet<ThreeDimensionalPacking>>();
-          var occupiedPoints = new List<int[, ,]>();
-
-          int binCounter = 0;
-          unpackedItemIndexesPerBin[binCounter] = new List<int>();
-          for (int i = 0; i < solution.IntVector.Length; i++) {
-            if (solution.IntVector[i].Equals(-1)) {
-              unpackedItemIndexesPerBin[binCounter++] = new List<int>();
-              extremePointsForBin[i] = new HashSet<ThreeDimensionalPacking>();
-              extremePointsForBin[i].Add(new ThreeDimensionalPacking(i, 0, 0, 0, false));
-              occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
-            } else {
-              unpackedItemIndexesPerBin[binCounter].Add(solution.IntVector[i]);
-            }
-
-          }
-
-
-          ObservableDictionary<int, ThreeDimensionalPacking> itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
-          var remainingItems = new List<int>();
-
-          #endregion Preperations
-
-
-
-          //Iterate over all bin-lists
-          for (int binNr = 0; binNr < nrOfBins; binNr++) {
-            //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
-            var unpackedItems = unpackedItemIndexesPerBin[binNr];
-            for (int i = 0; i < unpackedItems.Count; i++) {
-              var itemIndex = unpackedItems[i];
-              var item = itemMeasures[itemIndex];
-
-              extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
-              var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
-              if (positionFound != null) {
-                extremePointsForBin[binNr].Remove(positionFound);
-                itemPositions[itemIndex] = positionFound;
-                occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
-                extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
-              } else
-                remainingItems.Add(itemIndex);
-            }
-          }
-
-
-
-          //Packing of remaining items    
-          //Iterate over all bin-lists
-          for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
-            var unpackedItems = new List<int>(remainingItems);
-            //Iterate over all the remaining items
-            for (int i = 0; i < unpackedItems.Count; i++) {
-              var itemIndex = unpackedItems[i];
-              var item = itemMeasures[itemIndex];
-
-              extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
-              var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
-              if (positionFound != null) {
-                extremePointsForBin[binNr].Remove(positionFound);
-                InsertItemgeneAfterLastItemgeneOfUsedBin(ref solution, itemIndex, binNr);
-                itemPositions[itemIndex] = positionFound;
-                occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
-                extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
-                remainingItems.Remove(itemIndex);
-              }
-            }
-            if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
-              extremePointsForBin[nrOfBins] = new HashSet<ThreeDimensionalPacking>();
-              extremePointsForBin[nrOfBins].Add(new ThreeDimensionalPacking(nrOfBins, 0, 0, 0, false));
-              occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
-              nrOfBins++;
-            }
-          }
-
-          return itemPositions;
-        }
-    }
-    private static void InsertItemgeneAfterLastItemgeneOfUsedBin(ref PotvinEncoding solution, int itemIndex, int binNr) { 
-      List<int> temp = new List<int> (solution.IntVector);
-      temp.Remove(itemIndex);
-      var delimiterIndexes = temp.Select((value, index) => value == -1).Select((value, index) => index);
-      int insertionIndex = temp.Count; 
-      if (binNr < delimiterIndexes.Count()) {
-        insertionIndex = delimiterIndexes.ElementAt(binNr);
-      }
-      temp.Insert(insertionIndex, itemIndex);
-      solution.IntVector = new IntegerVector (temp.ToArray());
-    }
-
-
     public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(ref MultiComponentVectorEncoding solution, 
         ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) {
 
       #region Preperations
-      int lowerBound = solution.PackingInformations.Max(x => x.AssignedBin);
-      int nrOfBins = lowerBound + 1;
+      int nrOfBins = solution.NrOfBins;
 
       //Get all indexes of items for every bin according to grouping-vector                      
@@ -176,7 +31,5 @@
 
       for (int i = 0; i < nrOfBins; i++) {        
-        unpackedItemIndexesPerBin[i] = solution.PackingInformations
-          .Where(pi => pi.AssignedBin == i)
-          .ToList();
+        unpackedItemIndexesPerBin[i] = new List<PackingInformation> (solution.PackingInformations[i]);
 
         extremePointsForBin[i] = new HashSet<ThreeDimensionalPacking>();
@@ -196,5 +49,5 @@
         var unpackedItems = unpackedItemIndexesPerBin[binNr];
         for (int i = 0; i < unpackedItems.Count; i++) {
-          var itemIndex = unpackedItems[i].ItemIndex;
+          var itemIndex = unpackedItems[i].ItemID;
           var item = itemMeasures[itemIndex];
 
@@ -206,6 +59,8 @@
             occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
             extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
-          } else
+          } else {
             remainingItems.Add(unpackedItems[i]);
+            solution.PackingInformations[binNr].Remove(unpackedItems[i]);
+          }
         }
       }
@@ -218,5 +73,5 @@
         //Iterate over all the remaining items
         for (int i = 0; i < unpackedItems.Count; i++) {
-          var itemIndex = unpackedItems[i].ItemIndex;
+          var itemIndex = unpackedItems[i].ItemID;
           var item = itemMeasures[itemIndex];
 
@@ -227,9 +82,7 @@
             itemPositions[itemIndex] = positionFound;
             occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
-            extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+            extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);      
             remainingItems.Remove(unpackedItems[i]);
-            if (binNr <= lowerBound) {
-              InsertItemgeneAfterLastItemgeneOfUsedBin(ref solution, itemIndex, binNr);
-            }
+            solution.PackingInformations[binNr].Add(unpackedItems[i]);
           }
         }
@@ -238,4 +91,5 @@
           extremePointsForBin[nrOfBins].Add(new ThreeDimensionalPacking(nrOfBins, 0, 0, 0, false));
           occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+          solution.PackingInformations[nrOfBins] = new ItemList<PackingInformation>();
           nrOfBins++;
         }
@@ -243,11 +97,4 @@
 
       return itemPositions;
-    }
-    private static void InsertItemgeneAfterLastItemgeneOfUsedBin(ref MultiComponentVectorEncoding solution, int itemIndex, int binNr) {
-      var itemgene = solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex);
-      solution.PackingInformations.Remove (itemgene);
-      itemgene.AssignedBin = binNr;
-      int targetIndex = solution.PackingInformations.FindLastIndex(pi => pi.AssignedBin == binNr);
-      solution.PackingInformations.Insert(targetIndex + 1, itemgene);
     }
 
@@ -370,9 +217,9 @@
 
 
-    private static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures,
+    public static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures,
         HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions) {
           return FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions, false);
     }
-    private static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures, 
+    public static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures, 
         HashSet<ThreeDimensionalPacking> extremePoints, List<int[,,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, bool rotated) {
 
@@ -397,5 +244,5 @@
       return null;
     }
-    private static List<int[, ,]> IncreaseBinCountForOccupiedPoints(List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
+    public static List<int[, ,]> IncreaseBinCountForOccupiedPoints(List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
       occupiedPoints.Add(new int[binMeasures.Width, binMeasures.Height, binMeasures.Depth]);
       int lastIndex = occupiedPoints.Count - 1;
@@ -409,5 +256,5 @@
       return occupiedPoints;
     }
-    private static bool IsStaticStable(int[, ,] occupiedPoints, CuboidPackingItem item, ThreeDimensionalPacking ep) {
+    public static bool IsStaticStable(int[, ,] occupiedPoints, CuboidPackingItem item, ThreeDimensionalPacking ep) {
       //Static stability is given, if item is placed on the ground
       if (ep.Y == 0)
@@ -433,5 +280,5 @@
       return false;
     }
-    private static List<int[, ,]>  OccupyPointsForNewItem(List<int[, ,]> occupiedPoints, CuboidPackingItem newItem, ThreeDimensionalPacking position, int itemIndex) {
+    public static List<int[, ,]>  OccupyPointsForNewItem(List<int[, ,]> occupiedPoints, CuboidPackingItem newItem, ThreeDimensionalPacking position, int itemIndex) {
       int width = position.Rotated ? newItem.Depth : newItem.Width; 
       int depth = position.Rotated ? newItem.Width : newItem.Depth;
@@ -445,5 +292,5 @@
       return occupiedPoints;
     }
-    private static HashSet<ThreeDimensionalPacking> GenerateNewExtremePointsForNewItem(HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, 
+    public static HashSet<ThreeDimensionalPacking> GenerateNewExtremePointsForNewItem(HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, 
         CuboidPackingItem newItem, ThreeDimensionalPacking position, CuboidPackingBin binMeasures) {
       int currentBin = position.AssignedBin;
@@ -518,8 +365,8 @@
 
 
-    private static HashSet<ThreeDimensionalPacking> OrderExtremePoints(HashSet<ThreeDimensionalPacking> hashSet, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
+    public static HashSet<ThreeDimensionalPacking> OrderExtremePoints(HashSet<ThreeDimensionalPacking> hashSet, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
       return new HashSet<ThreeDimensionalPacking>(hashSet.OrderBy(ep => ep.AssignedBin).ThenBy(ep => ep.Z).ThenBy(ep => ep.X).ThenBy(ep => ep.Y).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
     }
-    private static int ShortestPossibleSideFromEP(ThreeDimensionalPacking ep, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
+    public static int ShortestPossibleSideFromEP(ThreeDimensionalPacking ep, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
       int shortestSide = int.MaxValue;
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ISOContainerMultiComponentVectorDecoder3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ISOContainerMultiComponentVectorDecoder3D.cs	(revision 9495)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ISOContainerMultiComponentVectorDecoder3D.cs	(revision 9495)
@@ -0,0 +1,155 @@
+﻿#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 System.Linq;
+using System.Text;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, three dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ISOContainerMultiComponentVectorDecoder3D : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public ISOContainerMultiComponentVectorDecoder3D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ISOContainerMultiComponentVectorDecoder3D (bool deserializing) : base(deserializing) { }
+    protected ISOContainerMultiComponentVectorDecoder3D(ISOContainerMultiComponentVectorDecoder3D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ISOContainerMultiComponentVectorDecoder3D(this, cloner);
+    }
+
+    public static MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Decode(MultiComponentVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+      
+      MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result =
+        new MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(new ObservableDictionary<int, CuboidPackingBin>(), itemMeasures);
+
+      #region Preperations
+      int nrOfBins = solution.NrOfBins;
+
+      //Get all indexes of items for every bin according to grouping-vector                      
+      Dictionary<int, List<PackingInformation>> unpackedItemIndexesPerBin = new Dictionary<int, List<PackingInformation>>();
+      Dictionary<int, HashSet<ThreeDimensionalPacking>> extremePointsForBin = new Dictionary<int, HashSet<ThreeDimensionalPacking>>();
+      var occupiedPoints = new List<int[, ,]>();
+
+      for (int i = 0; i < nrOfBins; i++) {
+        unpackedItemIndexesPerBin[i] = new List<PackingInformation>(solution.PackingInformations[i]);
+
+        extremePointsForBin[i] = new HashSet<ThreeDimensionalPacking>();
+        extremePointsForBin[i].Add(new ThreeDimensionalPacking(i, 0, 0, 0, false));
+        occupiedPoints = ExtremePointsFunctions3D.IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+      }
+
+      ObservableDictionary<int, ThreeDimensionalPacking> itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
+      var remainingItems = new List<PackingInformation>();
+
+      #endregion Preperations
+
+
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins; binNr++) {
+        //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
+        var unpackedItems = unpackedItemIndexesPerBin[binNr];
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemID;
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = ExtremePointsFunctions3D.OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
+          var positionFound = ExtremePointsFunctions3D.FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          if (positionFound != null) {
+            extremePointsForBin[binNr].Remove(positionFound);
+            itemPositions[itemIndex] = positionFound;
+            occupiedPoints = ExtremePointsFunctions3D.OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+            extremePointsForBin[binNr] = ExtremePointsFunctions3D.GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+          } else {
+            remainingItems.Add(unpackedItems[i]);
+            //solution.PackingInformations[binNr].Remove(unpackedItems[i]);
+          }
+        }
+      }
+
+
+      //Packing of remaining items    
+      //Iterate over all bin-lists
+      for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
+        var unpackedItems = new List<PackingInformation>(remainingItems);
+        //Iterate over all the remaining items
+        for (int i = 0; i < unpackedItems.Count; i++) {
+          var itemIndex = unpackedItems[i].ItemID;
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = ExtremePointsFunctions3D.OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
+          var positionFound = ExtremePointsFunctions3D.FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          if (positionFound != null) {
+            extremePointsForBin[binNr].Remove(positionFound);
+            itemPositions[itemIndex] = positionFound;
+            occupiedPoints = ExtremePointsFunctions3D.OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+            extremePointsForBin[binNr] = ExtremePointsFunctions3D.GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+            remainingItems.Remove(unpackedItems[i]);
+            //solution.PackingInformations[binNr].Add(unpackedItems[i]);
+          }
+        }
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          extremePointsForBin[nrOfBins] = new HashSet<ThreeDimensionalPacking>();
+          extremePointsForBin[nrOfBins].Add(new ThreeDimensionalPacking(nrOfBins, 0, 0, 0, false));
+          occupiedPoints = ExtremePointsFunctions3D.IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+          //solution.PackingInformations[nrOfBins] = new ItemList<PackingInformation>();
+          nrOfBins++;
+        }
+      }
+
+      return itemPositions;
+
+
+      return result;
+    }
+
+    protected override MultipleBinSizePackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
+
+      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/ExtremePointsFunctions.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/ExtremePointsFunctions.cs	(revision 9495)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/ExtremePointsFunctions.cs	(revision 9495)
@@ -0,0 +1,51 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Collections;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Problems.BinPacking.Shapes;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  public static class ExtremePointsFunctions<D,B,I>
+    where D : class, IPackingDimensions
+    where B : PackingShape<D>, IPackingBin, IRegularPackingShape
+      where I : PackingShape<D>, IPackingItem, IRegularPackingShape {
+
+
+    public static ObservableDictionary<int, D> ExtremePointBasedPacking(IItem solution, B binMeasures, ItemList<I> itemMeasures) {
+      var actualSolutionMCV = solution as MultiComponentVectorEncoding;
+      var actualSolutionGV = solution as GroupingVectorEncoding;    
+      var actualSolutionPS = solution as PackingSequenceEncoding;
+      if (actualSolutionMCV != null)
+        return ExtremePointBasedPacking(actualSolutionMCV, binMeasures, itemMeasures);
+      else if (actualSolutionGV != null)
+        return ExtremePointBasedPacking(actualSolutionGV, binMeasures, itemMeasures);
+      else  if (actualSolutionPS != null)
+        return ExtremePointBasedPacking(actualSolutionPS, binMeasures, itemMeasures);
+      else
+        return new ObservableDictionary<int,D>();
+    }
+
+    public static ObservableDictionary<int, D> ExtremePointBasedPacking(MultiComponentVectorEncoding solution, B binMeasures, ItemList<I> itemMeasures) {
+
+    }
+
+    public static ObservableDictionary<int, D> ExtremePointBasedPacking(GroupingVectorEncoding solution, B binMeasures, ItemList<I> itemMeasures) {
+
+    }
+
+    public static ObservableDictionary<int, D> ExtremePointBasedPacking(PackingSequenceEncoding solution, B binMeasures, ItemList<I> itemMeasures) {
+
+    }
+    
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/PackingSolutionDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/PackingSolutionDecoder.cs	(revision 9495)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/PackingSolutionDecoder.cs	(revision 9495)
@@ -0,0 +1,85 @@
+﻿#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 System.Linq;
+using System.Text;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.BinPacking.Shapes;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+
+  [Item("Packing-Solution Decoder", "An operator to create a concrete bin packing solution from a given encoding-instance.")]
+  [StorableClass]
+  public abstract class PackingSolutionDecoder<D, B, I> : SingleSuccessorOperator, IPackingSolutionDecoder
+    where D : class, IPackingDimensions
+    where B : PackingShape<D>, IPackingBin
+    where I : PackingShape<D>, IPackingItem {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemList<I>> PackingItemMeasuresParameter {
+      get { return (LookupParameter<ItemList<I>>)Parameters["PackingItemMeasures"]; }
+    }
+    public ILookupParameter<B> PackingBinMeasuresParameter {
+      get { return (LookupParameter<B>)Parameters["PackingBinMeasures"]; }
+    }
+    public ILookupParameter<IPackingSolutionEncoding> EncodedSolutionParameter {
+      get { return (ILookupParameter<IPackingSolutionEncoding>)Parameters["EncodedSolution"]; }
+    }
+    public ILookupParameter<PackingPlan<D,B,I>> PackingPlanParameter {
+      get { return (ILookupParameter<PackingPlan<D, B, I>>)Parameters["PackingPlan"]; }
+    }
+
+
+    public PackingSolutionDecoder() : base() {
+      Parameters.Add(new LookupParameter<IPackingSolutionEncoding>("EncodedSolution", "The new bin-packing solution represented as encoding."));
+      Parameters.Add(new LookupParameter<PackingPlan<D, B, I>>("PackingPlan", "The decoded bin-packing solution represented as generalized packing plan."));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new LookupParameter<ItemList<I>>("PackingItemMeasures", "Packing-item data taken from the bin-packing problem-instance."));
+      Parameters.Add(new LookupParameter<B>("PackingBinMeasures", "Packing-bin data taken from the bin-packing problem-instance."));
+    }
+
+    [StorableConstructor]
+    protected PackingSolutionDecoder(bool deserializing) : base(deserializing) { }
+    protected PackingSolutionDecoder(PackingSolutionDecoder<D,B,I> original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public abstract PackingPlan<D, B, I> CreatePackingPlanFromEncoding(IPackingSolutionEncoding solution, B binMeasures, ItemList<I> itemMeasures);
+
+    public override IOperation Apply() {
+      PackingPlan<D, B, I> result = CreatePackingPlanFromEncoding(EncodedSolutionParameter.ActualValue, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      PackingPlanParameter.ActualValue = result;
+      return base.Apply();
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMove.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMove.cs	(revision 9495)
@@ -22,10 +22,12 @@
 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("Single Grouping Move", "A move on a grouping vector that is specified by a single group-assignment-index.")]
   [StorableClass]
-  public class SingleGroupingMove : Item {
+  public class SingleGroupingMove : Item, IPackingMove{
     [Storable]
     public int Index { get; protected set; }
@@ -53,4 +55,11 @@
       return new SingleGroupingMove(this, cloner);
     }
+
+    public IPackingSolutionEncoding GetSolutionAfterMove() {
+      GroupingVectorEncoding newSolution = new GroupingVectorEncoding();
+      newSolution.GroupingVector = new IntegerVector(GroupingVector.GroupingVector);
+      newSolution.GroupingVector[Index] = NewGroup;
+      return newSolution;
+    }
   }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveGenerator.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveGenerator.cs	(revision 9495)
@@ -38,6 +38,6 @@
       get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
     }
-    public ILookupParameter<SingleGroupingMove> SingleGroupingMoveParameter {
-      get { return (LookupParameter<SingleGroupingMove>)Parameters["SingleGroupingMove"]; }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (LookupParameter<IPackingMove>)Parameters["PackingMove"]; }
     }
     protected ScopeParameter CurrentScopeParameter {
@@ -51,5 +51,5 @@
       : base() {
       Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The grouping vector for which moves should be generated."));
-      Parameters.Add(new LookupParameter<SingleGroupingMove>("SingleGroupingMove", "The moves that should be generated in subscopes."));
+      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."));
     }
@@ -61,5 +61,5 @@
       for (int i = 0; i < moveScopes.Length; i++) {
         moveScopes[i] = new Scope(i.ToString());
-        moveScopes[i].Variables.Add(new Variable(SingleGroupingMoveParameter.ActualName, moves[i]));
+        moveScopes[i].Variables.Add(new Variable(PackingMoveParameter.ActualName, moves[i]));
       }
       CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveHardTabuCriterion.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveHardTabuCriterion.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveHardTabuCriterion.cs	(revision 9495)
@@ -38,6 +38,6 @@
       get { return false; }
     }
-    public ILookupParameter<SingleGroupingMove> SingleGroupingMoveParameter {
-      get { return (ILookupParameter<SingleGroupingMove>)Parameters["SingleGroupingMove"]; }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
     }
     public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
@@ -65,5 +65,5 @@
     public SingleGroupingMoveHardTabuCriterion()
       : base() {
-      Parameters.Add(new LookupParameter<SingleGroupingMove>("SingleGroupingMove", "The move to evaluate."));
+      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."));
@@ -80,5 +80,5 @@
     public override IOperation Apply() {
       ItemList<IItem> tabuList = TabuListParameter.ActualValue;
-      SingleGroupingMove move = SingleGroupingMoveParameter.ActualValue;
+      SingleGroupingMove move = PackingMoveParameter.ActualValue as SingleGroupingMove;
       GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue;
       int length = groupingVector.GroupingVector.Length;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveMaker.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveMaker.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveMaker.cs	(revision 9495)
@@ -42,9 +42,15 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
     }
-    public ILookupParameter<SingleGroupingMove> SingleGroupingMoveParameter {
-      get { return (ILookupParameter<SingleGroupingMove>)Parameters["SingleGroupingMove"]; }
+    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"]; }
     }
 
@@ -55,7 +61,9 @@
       : base() {
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
-      Parameters.Add(new LookupParameter<SingleGroupingMove>("SingleGroupingMove", "The move to evaluate."));
+      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."));
     }
 
@@ -65,10 +73,11 @@
 
     public override IOperation Apply() {
-      SingleGroupingMove move = SingleGroupingMoveParameter.ActualValue;
+      IPackingMove move = PackingMoveParameter.ActualValue;
       GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue;
       DoubleValue moveQuality = MoveQualityParameter.ActualValue;
       DoubleValue quality = QualityParameter.ActualValue;
 
-      groupingVector.GroupingVector[move.Index] = move.NewGroup;
+      groupingVector.GroupingVector = (move.GetSolutionAfterMove() as GroupingVectorEncoding).GroupingVector;
+      PackingPlanParameter.ActualValue = PackingPlanAfterMoveParameter.ActualValue;
 
       quality.Value = moveQuality.Value;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveSoftTabuCriterion.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveSoftTabuCriterion.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveSoftTabuCriterion.cs	(revision 9495)
@@ -38,6 +38,6 @@
       get { return false; }
     }
-    public ILookupParameter<SingleGroupingMove> SingleGroupingMoveParameter {
-      get { return (ILookupParameter<SingleGroupingMove>)Parameters["SingleGroupingMove"]; }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
     }
     public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
@@ -65,5 +65,5 @@
     public SingleGroupingMoveSoftTabuCriterion()
       : base() {
-      Parameters.Add(new LookupParameter<SingleGroupingMove>("SingleGroupingMove", "The move to evaluate."));
+      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."));
@@ -80,5 +80,5 @@
     public override IOperation Apply() {
       ItemList<IItem> tabuList = TabuListParameter.ActualValue;
-      SingleGroupingMove move = SingleGroupingMoveParameter.ActualValue;
+      SingleGroupingMove move = PackingMoveParameter.ActualValue as SingleGroupingMove;
       GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue;
       int length = groupingVector.GroupingVector.Length;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingTabuMaker.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingTabuMaker.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingTabuMaker.cs	(revision 9495)
@@ -32,6 +32,6 @@
   [StorableClass]
   public class SingleGroupingTabuMaker : TabuMaker, IGroupingVectorMoveOperator{
-    public ILookupParameter<SingleGroupingMove> SingleGroupingMoveParameter {
-      get { return (ILookupParameter<SingleGroupingMove>)Parameters["SingleGroupingMove"]; }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
     }
     public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
@@ -44,5 +44,5 @@
     public SingleGroupingTabuMaker()
       : base() {
-      Parameters.Add(new LookupParameter<SingleGroupingMove>("SingleGroupingMove", "The move to evaluate."));
+        Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
       Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution to evaluate."));
     }
@@ -53,11 +53,15 @@
 
     protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) {
-      SingleGroupingMove move = SingleGroupingMoveParameter.ActualValue;
+      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
-            
-      return new SingleGroupingMoveAttribute (move.Index, move.NewGroup, baseQuality);
+
+      var sgMove = move as SingleGroupingMove;
+      if (sgMove != null)
+        return new SingleGroupingMoveAttribute(sgMove.Index, sgMove.NewGroup, baseQuality);
+      else
+        return move.GetSolutionAfterMove();
     }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/StochasticSingleGroupingMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/StochasticSingleGroupingMoveGenerator.cs	(revision 9495)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/StochasticSingleGroupingMoveGenerator.cs	(revision 9495)
@@ -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 SingleGrouping Move Generator", "Generates a number of possible grouping moves from a given grouping vector.")]
+  [StorableClass]
+  public class StochasticSingleGroupingMoveGenerator : SingleGroupingMoveGenerator, 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 StochasticSingleGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticSingleGroupingMoveGenerator(StochasticSingleGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticSingleGroupingMoveGenerator()
+      : 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 StochasticSingleGroupingMoveGenerator(this, cloner);
+    }
+
+    public static SingleGroupingMove[] 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<SingleGroupingMove>();
+      var moves = new List<SingleGroupingMove>(ExhaustiveSingleGroupingMoveGenerator.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 SingleGroupingMove[] GenerateMoves(GroupingVectorEncoding SingleGrouping) {
+      IRandom random = RandomParameter.ActualValue;
+      return Apply(SingleGrouping, random, SampleSizeParameter.ActualValue.Value);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/ChangePositionMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/ChangePositionMoveAttribute.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/ChangePositionMoveAttribute.cs	(revision 9495)
@@ -29,9 +29,11 @@
   public class ChangePositionMoveAttribute : MultiComponentVectorMoveAttribute {
     [Storable]
-    public int Index { get; protected set; }
+    public int AffectedGroup { get; protected set; }
+    [Storable]
+    public int Index { get; protected set; }      
+    [Storable]
+    public int ItemID { get; protected set; }
     [Storable]
     public int TargetIndex { get; protected set; }
-    [Storable]
-    public int ItemIndex { get; protected set; }
 
     [StorableConstructor]
@@ -41,12 +43,13 @@
         this.Index = original.Index;
         this.TargetIndex = original.TargetIndex;      
-      this.ItemIndex = original.ItemIndex;
+      this.ItemID = original.ItemID;
     }
-    public ChangePositionMoveAttribute() : this(-1, -1, -1, -1) { }
-    public ChangePositionMoveAttribute(int index, int targetIndex, int itemIndex, double moveQuality)
+    public ChangePositionMoveAttribute() : this(-1, -1, -1, -1, -1) { }
+    public ChangePositionMoveAttribute(int affectedGroup, int index, int itemID, int targetIndex, double moveQuality)
       : base(moveQuality) {
+        AffectedGroup = affectedGroup;
         Index = index;
         TargetIndex = targetIndex;
-        ItemIndex = itemIndex;
+        ItemID = itemID;
     }
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/MCVTripleMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/MCVTripleMoveAttribute.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/MCVTripleMoveAttribute.cs	(revision 9495)
@@ -31,11 +31,9 @@
     public int Index { get; protected set; } 
     [Storable]
-    public int ItemIndex { get; protected set; }  
+    public int ItemID { get; protected set; }  
     [Storable]
     public int TargetIndex { get; protected set; }
     [Storable]
-    public bool RotationBefore { get; protected set; }
-    [Storable]
-    public bool RotationAfter { get; protected set; }
+    public bool Rotation { get; protected set; }
     [Storable]
     public int GroupBefore { get; protected set; }
@@ -49,18 +47,16 @@
         this.Index = original.Index;
         this.TargetIndex = original.TargetIndex;      
-      this.ItemIndex = original.ItemIndex;
-      this.RotationAfter = original.RotationAfter;
-      this.RotationBefore = original.RotationBefore;
+      this.ItemID = original.ItemID;
+      this.Rotation = original.Rotation;
       this.GroupBefore = original.GroupBefore;
       this.GroupAfter = original.GroupAfter;
     }
-    public MCVTripleMoveAttribute() : this(-1, -1, -1, false, false, -1, -1, -1) { }
-    public MCVTripleMoveAttribute(int index, int targetIndex, int itemIndex, bool rotationBefore, bool rotationAfter, int groupBefore, int groupAfter, double moveQuality)
+    public MCVTripleMoveAttribute() : this(-1, -1, -1, false, -1, -1, -1) { }
+    public MCVTripleMoveAttribute(int index, int targetIndex, int itemID, bool rotation, int groupBefore, int groupAfter, double moveQuality)
       : base(moveQuality) {
         Index = index;
         TargetIndex = targetIndex;
-        ItemIndex = itemIndex;
-        RotationBefore = rotationBefore;
-        RotationAfter = rotationAfter;
+        ItemID = itemID;
+        Rotation = rotation;
         GroupBefore = groupBefore;
         GroupAfter = groupAfter;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SingleGroupingMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SingleGroupingMoveAttribute.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SingleGroupingMoveAttribute.cs	(revision 9495)
@@ -27,22 +27,30 @@
   [Item("SingleGroupingMoveAttribute", "Specifies the tabu attributes for a single grouping move on an multi component vector.")]
   [StorableClass]
-  public class SingleGroupingMoveAttribute : MultiComponentVectorMoveAttribute {
+  public class SingleGroupingMoveAttribute : MultiComponentVectorMoveAttribute { 
+    [Storable]
+    public int OldGroup { get; protected set; }
     [Storable]
     public int Index { get; protected set; }
     [Storable]
-    public int AssignedBin { get; protected set; }
+    public int ItemID { get; protected set; }
+    [Storable]
+    public int NewGroup { get; protected set; }
 
     [StorableConstructor]
     protected SingleGroupingMoveAttribute(bool deserializing) : base(deserializing) { }
     protected SingleGroupingMoveAttribute(SingleGroupingMoveAttribute original, Cloner cloner)
-      : base(original, cloner) {
+      : base(original, cloner) {   
+      this.OldGroup = original.OldGroup;
       this.Index = original.Index;
-      this.AssignedBin = original.AssignedBin;
+      this.ItemID = original.ItemID;
+      this.NewGroup = original.NewGroup;
     }
-    public SingleGroupingMoveAttribute() : this(-1, -1, -1) { }
-    public SingleGroupingMoveAttribute(int index, int assignedBin, double moveQuality)
+    public SingleGroupingMoveAttribute() : this(-1, -1, -1, -1, -1) { }
+    public SingleGroupingMoveAttribute(int oldGroup, int index, int itemID, int newGroup, double moveQuality)
       : base(moveQuality) {
+        OldGroup = oldGroup;
       Index = index;
-      AssignedBin = assignedBin;
+      ItemID = itemID;
+      NewGroup = newGroup;
     }
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SingleItemRotationMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SingleItemRotationMoveAttribute.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SingleItemRotationMoveAttribute.cs	(revision 9495)
@@ -29,4 +29,8 @@
   public class SingleItemRotationMoveAttribute : MultiComponentVectorMoveAttribute {
     [Storable]
+    public int AffectedGroup { get; protected set; }
+    [Storable]
+    public int Index { get; protected set; }
+    [Storable]
     public int ItemIndex { get; protected set; }
     [Storable]
@@ -37,10 +41,14 @@
     protected SingleItemRotationMoveAttribute(SingleItemRotationMoveAttribute original, Cloner cloner)
       : base(original, cloner) {
+      this.AffectedGroup = original.AffectedGroup;
+      this.Index = original.Index;
       this.ItemIndex = original.ItemIndex;
       this.ItemRotation = original.ItemRotation;
     }
-    public SingleItemRotationMoveAttribute() : this(-1, false, -1) { }
-    public SingleItemRotationMoveAttribute(int itemIndex, bool itemRotation, double moveQuality)
+    public SingleItemRotationMoveAttribute() : this(-1, -1, -1, false, -1) { }
+    public SingleItemRotationMoveAttribute(int affectedGroup, int index, int itemIndex, bool itemRotation, double moveQuality)
       : base(moveQuality) {
+        AffectedGroup = affectedGroup;
+        Index = index;
       ItemIndex = itemIndex;
       ItemRotation = itemRotation;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SwapPositionMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SwapPositionMoveAttribute.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SwapPositionMoveAttribute.cs	(revision 9495)
@@ -29,11 +29,13 @@
   public class SwapPositionMoveAttribute : MultiComponentVectorMoveAttribute {
     [Storable]
+    public int AffectedGroup { get; protected set; }
+    [Storable]
     public int Index1 { get; protected set; }
     [Storable]
     public int Index2 { get; protected set; }
     [Storable]
-    public int ItemIndex1 { get; protected set; }
+    public int ItemID1 { get; protected set; }
     [Storable]
-    public int ItemIndex2 { get; protected set; }
+    public int ItemID2 { get; protected set; }
 
     [StorableConstructor]
@@ -41,16 +43,18 @@
     protected SwapPositionMoveAttribute(SwapPositionMoveAttribute original, Cloner cloner)
       : base(original, cloner) {
+        this.AffectedGroup = original.AffectedGroup;
         this.Index1 = original.Index1;
         this.Index2 = original.Index2;
-      this.ItemIndex1 = original.ItemIndex1;
-      this.ItemIndex2 = original.ItemIndex2;
+      this.ItemID1 = original.ItemID1;
+      this.ItemID2 = original.ItemID2;
     }
-    public SwapPositionMoveAttribute() : this(-1, -1, -1, -1, -1) { }
-    public SwapPositionMoveAttribute(int index1, int index2, int itemIndex1, int itemIndex2, double moveQuality)
+    public SwapPositionMoveAttribute() : this(-1, -1, -1, -1, -1, -1) { }
+    public SwapPositionMoveAttribute(int affectedGroup, int index1, int index2, int itemID1, int itemID2, double moveQuality)
       : base(moveQuality) {
+        AffectedGroup = affectedGroup;
         Index1 = index1;
         Index2 = index2;
-        ItemIndex1 = itemIndex1;
-        ItemIndex2 = itemIndex2;
+        ItemID1 = itemID1;
+        ItemID2 = itemID2;
     }
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/ExhaustiveMCVTripleMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/ExhaustiveMCVTripleMoveGenerator.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/ExhaustiveMCVTripleMoveGenerator.cs	(revision 9495)
@@ -40,27 +40,12 @@
     }
 
-    public static IEnumerable<MultiComponentVectorMove> GenerateMCVTripleMoves(MultiComponentVectorEncoding mcv) {
-      int nrOfBins = 0;
-      foreach (var pi in mcv.PackingInformations) {
-        if (pi.AssignedBin > nrOfBins)
-          nrOfBins = pi.AssignedBin;
-      }
-      nrOfBins++;
-      Dictionary<int, List<int>> indexesPerBin = new Dictionary<int, List<int>>();
-      for (int i = 0; i < mcv.PackingInformations.Count; i++) {
-        int currentBin = mcv.PackingInformations[i].AssignedBin;
-        if (!indexesPerBin.ContainsKey(currentBin))
-          indexesPerBin[currentBin] = new List<int>();
-        indexesPerBin[currentBin].Add(i);
-      }
-                                                        
-      for (int index = 0; index < mcv.PackingInformations.Count; index++) { 
-        for (int group = 0; group < nrOfBins; group++) {
-          foreach (int targetIndex in indexesPerBin[group]) {
-            yield return new MCVTripleMove(index, false, group, targetIndex, mcv);
-            yield return new MCVTripleMove(index, true, group, targetIndex, mcv);
-          }
-        }
-      }
+    public static IEnumerable<MultiComponentVectorMove> GenerateMCVTripleMoves(MultiComponentVectorEncoding mcv) {  
+      foreach (var oldGroup in mcv.PackingInformations) 
+        for (int sourceIndex = 0; sourceIndex < oldGroup.Value.Count; sourceIndex++) 
+          foreach (var newGroup in mcv.PackingInformations) 
+            for (int targetIndex = 0; targetIndex < newGroup.Value.Count; targetIndex++) {
+              yield return new MCVTripleMove(oldGroup.Key, newGroup.Key, sourceIndex, targetIndex, false, mcv);
+              yield return new MCVTripleMove(oldGroup.Key, newGroup.Key, sourceIndex, targetIndex, true, mcv);
+            }
     }
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/ChangePositionMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/ChangePositionMove.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/ChangePositionMove.cs	(revision 9495)
@@ -24,4 +24,5 @@
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
 
 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
@@ -29,4 +30,6 @@
   [StorableClass]
   public class ChangePositionMove : MultiComponentVectorMove {
+    [Storable]
+    public int AffectedGroup { get; protected set; }
     [Storable]
     public int Index { get; protected set; }
@@ -38,9 +41,11 @@
     protected ChangePositionMove(ChangePositionMove original, Cloner cloner)
       : base(original, cloner) {
+      this.AffectedGroup = original.AffectedGroup;
       this.Index = original.Index;
       this.TargetIndex = original.TargetIndex;
     }
-    public ChangePositionMove(int index, int targetIndex, MultiComponentVectorEncoding multiComponentVector)
+    public ChangePositionMove(int affectedBin, int index, int targetIndex, MultiComponentVectorEncoding multiComponentVector)
       : base(multiComponentVector) {
+        AffectedGroup = affectedBin;
         Index = index;
         TargetIndex = targetIndex;
@@ -51,12 +56,12 @@
     }
 
-    public override MultiComponentVectorEncoding GetVectorAfterMove() {
-      return GetVectorAfterMove(MultiComponentVector, Index, TargetIndex);
+    public override IPackingSolutionEncoding GetSolutionAfterMove() {
+      return GetVectorAfterMove(MultiComponentVector, AffectedGroup, Index, TargetIndex);
     }
-    public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int index, int targetIndex) {
+    public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int affectedBin, int index, int targetIndex) {
       var result = multiComponentVector.Clone(new Cloner()) as MultiComponentVectorEncoding;
-      var aux = result.PackingInformations[index];
-      result.PackingInformations.RemoveAt(index);
-      result.PackingInformations.Insert(targetIndex, aux);
+      var aux = result.PackingInformations[affectedBin][index];
+      result.PackingInformations[affectedBin].Remove(aux);
+      result.PackingInformations[affectedBin].Insert(targetIndex, aux);
       return result;
     }
@@ -67,5 +72,30 @@
 
     public override string ToString() {
-      return "PM(i=" + Index + ",ti=" + TargetIndex + ")";
+      return "PM(g=" + AffectedGroup  + ",i=" + Index + ",ti=" + TargetIndex + ")";
+    }
+
+    public override MultiComponentVectorMoveAttribute GetAttribute(double quality) {
+      return new ChangePositionMoveAttribute(AffectedGroup, Index,
+        MultiComponentVector.PackingInformations[AffectedGroup][Index].ItemID,
+        TargetIndex, quality);
+    }
+
+    public override bool BelongsToAttribute(MultiComponentVectorMoveAttribute attribute, bool hardCriterion) {
+      ChangePositionMoveAttribute actualAttribute = attribute as ChangePositionMoveAttribute;
+      if (actualAttribute != null) {
+        if (hardCriterion) {
+          if (Index == actualAttribute.Index
+          || TargetIndex == actualAttribute.TargetIndex
+          || MultiComponentVector.PackingInformations[AffectedGroup][Index].ItemID == actualAttribute.ItemID)
+            return true;
+        } else {
+          if (Index == actualAttribute.Index
+          && TargetIndex == actualAttribute.TargetIndex
+          && MultiComponentVector.PackingInformations[AffectedGroup][Index].ItemID == actualAttribute.ItemID)
+            return true;
+        }
+      }
+
+      return false;
     }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/MCVTripleMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/MCVTripleMove.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/MCVTripleMove.cs	(revision 9495)
@@ -24,33 +24,38 @@
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
 
 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
   [Item("MCVTripleMove", "A move on a multi component vector that is specified by a rotation-value, two indexes and a groupNr.")]
   [StorableClass]
-  public class MCVTripleMove : MultiComponentVectorMove {
+  public class MCVTripleMove : MultiComponentVectorMove {   
     [Storable]
-    public int Index { get; protected set; }
+    public int OldGroup { get; protected set; }
+    [Storable]
+    public int NewGroup { get; protected set; }
+    [Storable]
+    public int Index { get; protected set; }    
+    [Storable]
+    public int TargetIndex { get; protected set; }
     [Storable]
     public bool Rotation { get; protected set; }
-    [Storable]
-    public int Group { get; protected set; }
-    [Storable]
-    public int TargetIndex { get; protected set; }
 
     [StorableConstructor]
     protected MCVTripleMove(bool deserializing) : base(deserializing) { }
     protected MCVTripleMove(MCVTripleMove original, Cloner cloner)
-      : base(original, cloner) {
-      this.Index = original.Index;
+      : base(original, cloner) {     
+      this.OldGroup = original.OldGroup;
+      this.NewGroup = original.NewGroup;
+      this.Index = original.Index;       
+      this.TargetIndex = original.TargetIndex;
       this.Rotation = original.Rotation;
-      this.Group = original.Group;
-      this.TargetIndex = original.TargetIndex;
     }
-    public MCVTripleMove(int index, bool rotation, int group, int targetIndex, MultiComponentVectorEncoding multiComponentVector)
-      : base(multiComponentVector) {
-        Index = index;
+    public MCVTripleMove(int oldGroup, int newGroup, int index, int targetIndex, bool rotation, MultiComponentVectorEncoding multiComponentVector)
+      : base(multiComponentVector) { 
+        OldGroup = oldGroup;
+        NewGroup = newGroup;
+        Index = index;        
+        TargetIndex = targetIndex;
         Rotation = rotation;
-        Group = group;
-        TargetIndex = targetIndex;
     }
 
@@ -59,12 +64,15 @@
     }
 
-    public override MultiComponentVectorEncoding GetVectorAfterMove() {
-      var result = MultiComponentVector;
+    public override IPackingSolutionEncoding GetSolutionAfterMove() {
+      var result = MultiComponentVector.Clone(new Cloner()) as MultiComponentVectorEncoding;
       if (Rotation)
-        result = SingleItemRotationMove.GetVectorAfterMove(MultiComponentVector, Index);
-      if (!MultiComponentVector.PackingInformations[Index].AssignedBin.Equals(Group))
-        result = SingleGroupingMove.GetVectorAfterMove(result, Index, Group);
-      if (!Index.Equals(TargetIndex))
-        result = ChangePositionMove.GetVectorAfterMove(result, Index, TargetIndex);
+        result = SingleItemRotationMove.GetVectorAfterMove(result, OldGroup, Index);
+      if (!OldGroup.Equals(NewGroup)) {
+        result = SingleGroupingMove.GetVectorAfterMove(result, OldGroup, Index, NewGroup);
+        int newIndex = result.PackingInformations[NewGroup].Count - 1;
+        if (!newIndex.Equals(TargetIndex))
+          result = ChangePositionMove.GetVectorAfterMove(result, NewGroup, newIndex, TargetIndex);
+      } else if (!Index.Equals(TargetIndex))
+          result = ChangePositionMove.GetVectorAfterMove(result, NewGroup, Index, TargetIndex);
       return result;
     }
@@ -75,5 +83,30 @@
 
     public override string ToString() {
-      return "TM(i=" + Index + ",r=" + Rotation + ",g=" + Group + ",ti=" + TargetIndex + ")";
+      return "TM(og=" + OldGroup + ",ng=" + NewGroup + ",i=" + Index + ",ti=" + TargetIndex + ",r=" + Rotation + ")";
+    }
+
+
+    public override MultiComponentVectorMoveAttribute GetAttribute(double quality) {
+      return new MCVTripleMoveAttribute(Index, TargetIndex, MultiComponentVector.PackingInformations[OldGroup][Index].ItemID,
+        Rotation, OldGroup, NewGroup, quality);
+    }
+
+    public override bool BelongsToAttribute(MultiComponentVectorMoveAttribute attribute, bool hardCriterion) {
+      MCVTripleMoveAttribute actualAttribute = attribute as MCVTripleMoveAttribute;
+      if (actualAttribute != null) {
+        if (hardCriterion) {
+          if ((Index == actualAttribute.Index && TargetIndex == actualAttribute.TargetIndex)
+                  || MultiComponentVector.PackingInformations[OldGroup][Index].ItemID == actualAttribute.ItemID
+                  || (OldGroup == actualAttribute.GroupBefore && NewGroup == actualAttribute.GroupAfter))
+            return true;
+        } else {
+          if ((Index == actualAttribute.Index && TargetIndex == actualAttribute.TargetIndex)
+                  && MultiComponentVector.PackingInformations[OldGroup][Index].ItemID == actualAttribute.ItemID
+                  && Rotation == actualAttribute.Rotation
+                  && (OldGroup == actualAttribute.GroupBefore && NewGroup == actualAttribute.GroupAfter))
+            return true;
+        }
+      }
+      return false;
     }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/MultiComponentVectorMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/MultiComponentVectorMove.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/MultiComponentVectorMove.cs	(revision 9495)
@@ -25,9 +25,10 @@
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
 
 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
   [Item("MultiComponentVectorMove", "An abstract move for a multi component vector encoded solution.")]
   [StorableClass]
-  public abstract class MultiComponentVectorMove : Item {
+  public abstract class MultiComponentVectorMove : Item, IPackingMove {
     [Storable]
     public MultiComponentVectorEncoding MultiComponentVector { get; protected set; }
@@ -45,6 +46,8 @@
     }
 
-    public abstract MultiComponentVectorEncoding GetVectorAfterMove();
+    public abstract IPackingSolutionEncoding GetSolutionAfterMove();
     public abstract Type GetMoveAttributeType();
+    public abstract MultiComponentVectorMoveAttribute GetAttribute(double quality);
+    public abstract bool BelongsToAttribute (MultiComponentVectorMoveAttribute attribute, bool hardCriterion);
   }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SingleGroupingMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SingleGroupingMove.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SingleGroupingMove.cs	(revision 9495)
@@ -24,9 +24,12 @@
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
 
 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
   [Item("SingleGroupingMove", "A move on a multi component vector that is specified by a single index and a new grouping-value. The grouping of the item on the specified index is changed to the new value.")]
   [StorableClass]
-  public class SingleGroupingMove : MultiComponentVectorMove {
+  public class SingleGroupingMove : MultiComponentVectorMove {       
+    [Storable]
+    public int OldGroup { get; protected set; }
     [Storable]
     public int Index { get; protected set; }
@@ -38,11 +41,13 @@
     protected SingleGroupingMove(SingleGroupingMove original, Cloner cloner)
       : base(original, cloner) {
+      this.OldGroup = original.OldGroup;
       this.Index = original.Index;
       this.NewGroup = original.NewGroup;
     }
-    public SingleGroupingMove(int index, int newGroup, MultiComponentVectorEncoding multiComponentVector)
+    public SingleGroupingMove(int oldGroup, int index, int newGroup, MultiComponentVectorEncoding multiComponentVector)
       : base(multiComponentVector) {
-      Index = index;
-      NewGroup = newGroup;
+        OldGroup = oldGroup;
+        Index = index;
+        NewGroup = newGroup;
     }
 
@@ -51,15 +56,12 @@
     }
 
-    public override MultiComponentVectorEncoding GetVectorAfterMove() {
-      return GetVectorAfterMove(MultiComponentVector, Index, NewGroup);
+    public override IPackingSolutionEncoding GetSolutionAfterMove() {
+      return GetVectorAfterMove(MultiComponentVector, OldGroup, Index, NewGroup);
     }
-    public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding originalSolution, int itemIndex, int binNr) {
+    public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding originalSolution, int oldBin, int index, int newBin) {
       var solution = originalSolution.Clone (new Cloner()) as MultiComponentVectorEncoding;
-      var itemgene = solution.PackingInformations[itemIndex];
-      solution.PackingInformations.Remove(itemgene);
-      itemgene.AssignedBin = binNr;
-      int targetIndex = solution.PackingInformations.FindLastIndex(pi => pi.AssignedBin == binNr);
-      solution.PackingInformations.Insert(targetIndex + 1, itemgene);
-      //solution.PackingInformations[itemIndex].AssignedBin = binNr;
+      var itemgene = solution.PackingInformations[oldBin][index];
+      solution.PackingInformations[oldBin].Remove(itemgene);
+      solution.PackingInformations[newBin].Add(itemgene);
       return solution;
     }
@@ -70,5 +72,26 @@
 
     public override string ToString() {
-      return "GM(i="+Index+",g="+NewGroup+")";
+      return "GM(og"+OldGroup+",i="+Index+",ng="+NewGroup+")";
+    }
+
+    public override MultiComponentVectorMoveAttribute GetAttribute(double quality) {
+      return new SingleGroupingMoveAttribute(OldGroup, Index,
+        MultiComponentVector.PackingInformations[OldGroup][Index].ItemID, NewGroup, quality);
+    }
+
+    public override bool BelongsToAttribute(MultiComponentVectorMoveAttribute attribute, bool hardCriterion) {
+      SingleGroupingMoveAttribute actualAttribute = attribute as SingleGroupingMoveAttribute;
+      if (actualAttribute != null) {
+        if (hardCriterion) {
+          if (MultiComponentVector.PackingInformations[OldGroup][Index].ItemID == actualAttribute.ItemID
+                || NewGroup == actualAttribute.NewGroup)
+            return true;
+        } else {
+          if (MultiComponentVector.PackingInformations[OldGroup][Index].ItemID == actualAttribute.ItemID
+                && NewGroup == actualAttribute.NewGroup)
+            return true;
+        }
+      }
+      return false;
     }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SingleItemRotationMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SingleItemRotationMove.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SingleItemRotationMove.cs	(revision 9495)
@@ -24,4 +24,5 @@
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
 
 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
@@ -30,5 +31,7 @@
   public class SingleItemRotationMove : MultiComponentVectorMove {
     [Storable]
-    public int ItemIndex { get; protected set; }
+    public int AffectedGroup { get; protected set; }
+    [Storable]
+    public int Index { get; protected set; }
 
     [StorableConstructor]
@@ -36,9 +39,11 @@
     protected SingleItemRotationMove(SingleItemRotationMove original, Cloner cloner)
       : base(original, cloner) {
-        this.ItemIndex = original.ItemIndex;
+        this.AffectedGroup = original.AffectedGroup;
+        this.Index = original.Index;
     }
-    public SingleItemRotationMove(int index, MultiComponentVectorEncoding multiComponentVector)
+    public SingleItemRotationMove(int affectedBin, int index, MultiComponentVectorEncoding multiComponentVector)
       : base(multiComponentVector) {
-        ItemIndex = index;
+        AffectedGroup = affectedBin;
+        Index = index;
     }
 
@@ -47,10 +52,10 @@
     }
 
-    public override MultiComponentVectorEncoding GetVectorAfterMove() {
-      return GetVectorAfterMove (MultiComponentVector, ItemIndex);
+    public override IPackingSolutionEncoding GetSolutionAfterMove() {
+      return GetVectorAfterMove (MultiComponentVector, AffectedGroup, Index);
     }
-    public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int itemIndex) {
+    public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int affectedGroup, int index) {
       var result = multiComponentVector.Clone(new Cloner()) as MultiComponentVectorEncoding;
-      result.PackingInformations[itemIndex].Rotated = !result.PackingInformations[itemIndex].Rotated;
+      result.PackingInformations[affectedGroup][index].Rotated = !result.PackingInformations[affectedGroup][index].Rotated;
       return result;
     }
@@ -61,5 +66,25 @@
 
     public override string ToString() {
-      return "RM(i=" + ItemIndex+")";
+      return "RM(g=" + AffectedGroup + ",i=" + Index + ")";
+    }
+
+    public override MultiComponentVectorMoveAttribute GetAttribute(double quality) {
+        return new SingleItemRotationMoveAttribute(AffectedGroup, Index, 
+          MultiComponentVector.PackingInformations[AffectedGroup][Index].ItemID, 
+          MultiComponentVector.PackingInformations[AffectedGroup][Index].Rotated, quality);
+    }
+
+    public override bool BelongsToAttribute(MultiComponentVectorMoveAttribute attribute, bool hardCriterion) {
+      SingleItemRotationMoveAttribute actualAttribute = attribute as SingleItemRotationMoveAttribute;
+      if (actualAttribute != null) {
+        if (hardCriterion) {
+          if (AffectedGroup == actualAttribute.AffectedGroup || MultiComponentVector.PackingInformations[AffectedGroup][Index].Rotated == actualAttribute.ItemRotation)
+            return true;
+        } else {
+          if (AffectedGroup == actualAttribute.AffectedGroup && MultiComponentVector.PackingInformations[AffectedGroup][Index].Rotated == actualAttribute.ItemRotation)
+            return true;
+        }
+      }
+      return false;
     }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SwapPositionMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SwapPositionMove.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SwapPositionMove.cs	(revision 9495)
@@ -24,4 +24,5 @@
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
 
 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
@@ -29,4 +30,6 @@
   [StorableClass]
   public class SwapPositionMove : MultiComponentVectorMove {
+    [Storable]
+    public int AffectedGroup { get; protected set; }
     [Storable]
     public int Index1 { get; protected set; }
@@ -38,9 +41,11 @@
     protected SwapPositionMove(SwapPositionMove original, Cloner cloner)
       : base(original, cloner) {
-      this.Index1 = original.Index1;
-      this.Index2 = original.Index2;
+        this.AffectedGroup = original.AffectedGroup;
+        this.Index1 = original.Index1;
+        this.Index2 = original.Index2;
     }
-    public SwapPositionMove(int index1, int index2, MultiComponentVectorEncoding multiComponentVector)
+    public SwapPositionMove(int affectedGroup, int index1, int index2, MultiComponentVectorEncoding multiComponentVector)
       : base(multiComponentVector) {
+        AffectedGroup = affectedGroup;
         Index1 = index1;
         Index2 = index2;
@@ -51,12 +56,12 @@
     }
 
-    public override MultiComponentVectorEncoding GetVectorAfterMove() {
-      return GetVectorAfterMove(MultiComponentVector, Index1, Index2);
+    public override IPackingSolutionEncoding GetSolutionAfterMove() {
+      return GetVectorAfterMove(MultiComponentVector, AffectedGroup, Index1, Index2);
     }
-    public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int index1, int index2) {
+    public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int affectedGroup, int index1, int index2) {
       var result = multiComponentVector.Clone(new Cloner()) as MultiComponentVectorEncoding;
-      var aux = result.PackingInformations[index1];
-      result.PackingInformations[index1] = result.PackingInformations[index2];
-      result.PackingInformations[index2] = aux;
+      var aux = result.PackingInformations[affectedGroup][index1];
+      result.PackingInformations[affectedGroup][index1] = result.PackingInformations[affectedGroup][index2];
+      result.PackingInformations[affectedGroup][index2] = aux;
       return result;
     }
@@ -67,5 +72,31 @@
 
     public override string ToString() {
-      return "SM(i1=" + Index1 + ",i2=" + Index2 + ")";
+      return "SPM(g=" + AffectedGroup + ",i1=" + Index1 + ",i2=" + Index2 + ")";
+    }
+
+    public override MultiComponentVectorMoveAttribute GetAttribute(double quality) {
+      return new SwapPositionMoveAttribute(AffectedGroup, Index1, Index2,
+        MultiComponentVector.PackingInformations[AffectedGroup][Index1].ItemID,
+        MultiComponentVector.PackingInformations[AffectedGroup][Index2].ItemID, quality);
+    }
+
+    public override bool BelongsToAttribute(MultiComponentVectorMoveAttribute attribute, bool hardCriterion) {
+      SwapPositionMoveAttribute actualAttribute = attribute as SwapPositionMoveAttribute;
+      if (actualAttribute != null) {
+        if (hardCriterion) {
+          if (Index1 == actualAttribute.Index1
+            || Index2 == actualAttribute.Index2
+            || MultiComponentVector.PackingInformations[AffectedGroup][Index1].ItemID == actualAttribute.ItemID1
+            || MultiComponentVector.PackingInformations[AffectedGroup][Index2].ItemID == actualAttribute.ItemID2)
+            return true;
+        } else {
+          if (Index1 == actualAttribute.Index1
+            && Index2 == actualAttribute.Index2
+            && MultiComponentVector.PackingInformations[AffectedGroup][Index1].ItemID == actualAttribute.ItemID1
+            && MultiComponentVector.PackingInformations[AffectedGroup][Index2].ItemID == actualAttribute.ItemID2)
+            return true;
+        }
+      }
+      return false;
     }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveGenerator.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveGenerator.cs	(revision 9495)
@@ -42,6 +42,6 @@
       get { return (ILookupParameter<MultiComponentVectorEncoding>)Parameters["MultiComponentVector"]; }
     }
-    public ILookupParameter<MultiComponentVectorMove> MultiComponentVectorMoveParameter {
-      get { return (LookupParameter<MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (LookupParameter<IPackingMove>)Parameters["PackingMove"]; }
     }
     protected ScopeParameter CurrentScopeParameter {
@@ -56,5 +56,5 @@
       : base() {
         Parameters.Add(new LookupParameter<MultiComponentVectorEncoding>("MultiComponentVector", "The multi component vector for which moves should be generated."));
-      Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "The moves that should be generated in subscopes."));
+        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."));
     }
@@ -62,96 +62,49 @@
 
     public static int NrOfRotationMoves(MultiComponentVectorEncoding mcv) {
-      return mcv.PackingInformations.Count;
+      return mcv.NrOfItems;
     }
     public static IEnumerable<MultiComponentVectorMove> GenerateRotationMoves(MultiComponentVectorEncoding multiComponentVector) {
-      for (int i = 0; i < multiComponentVector.PackingInformations.Count; i++)
-        yield return new SingleItemRotationMove(i, multiComponentVector);
+      for (int binNr = 0; binNr < multiComponentVector.PackingInformations.Count; binNr++)
+        for (int index = 0; index < multiComponentVector.PackingInformations[binNr].Count; index++)
+          yield return new SingleItemRotationMove(binNr, index, multiComponentVector);
     }
 
     public static int NrOfSingleGroupingMoves(MultiComponentVectorEncoding mcv) {
-      int nrOfBins = 0;
-      foreach (var pi in mcv.PackingInformations) {
-        if (pi.AssignedBin > nrOfBins)
-          nrOfBins = pi.AssignedBin;
-      }
-      nrOfBins++;
-      return mcv.PackingInformations.Count * (nrOfBins - 1);
+      return mcv.NrOfItems * (mcv.NrOfBins - 1);
     }
     public static IEnumerable<MultiComponentVectorMove> GenerateSingleGroupingMoves(MultiComponentVectorEncoding multiComponentVector) {
-      int nrOfBins = 0;
-      foreach (var pi in multiComponentVector.PackingInformations) {
-        if (pi.AssignedBin > nrOfBins)
-          nrOfBins = pi.AssignedBin;
-      }
-      nrOfBins++;
-      for (int i = 0; i < multiComponentVector.PackingInformations.Count; i++)
-        for (int j = 0; j < nrOfBins; j++) {
-          if (j != multiComponentVector.PackingInformations[i].AssignedBin)
-            yield return new SingleGroupingMove(i, j, multiComponentVector);
-        }
+      for (int oldBin = 0; oldBin < multiComponentVector.PackingInformations.Count; oldBin++)
+        for (int index = 0; index < multiComponentVector.PackingInformations[oldBin].Count; index++)
+          for (int newBin = 0; newBin < multiComponentVector.NrOfBins; newBin++) 
+            if (newBin != oldBin)
+              yield return new SingleGroupingMove(oldBin, index, newBin, multiComponentVector);
     }
 
     public static int NrOfSwapPositionMoves(MultiComponentVectorEncoding mcv) {
-      int nrOfBins = 0;
-      foreach (var pi in mcv.PackingInformations) {
-        if (pi.AssignedBin > nrOfBins)
-          nrOfBins = pi.AssignedBin;
-      }
-      nrOfBins++;
-      int[] itemsPerBin = new int[nrOfBins];
-      foreach (var pi in mcv.PackingInformations) {
-        itemsPerBin[pi.AssignedBin]++;
-      }
       int nrOfSwapPositionMoves = 0;
-      foreach (int items in itemsPerBin) {
-        nrOfSwapPositionMoves += (items * (items - 1)) / 2;
+      foreach (var groupInformations in mcv.PackingInformations) {
+        nrOfSwapPositionMoves += (groupInformations.Value.Count * (groupInformations.Value.Count - 1)) / 2;
       }
       return nrOfSwapPositionMoves;
     }
     public static IEnumerable<MultiComponentVectorMove> GenerateSwapPositionMoves(MultiComponentVectorEncoding multiComponentVector) {
-      Dictionary<int, List<int>> indexesPerBin = new Dictionary<int, List<int>>();
-      for (int i = 0; i < multiComponentVector.PackingInformations.Count; i++) {
-        int currentBin = multiComponentVector.PackingInformations[i].AssignedBin;
-        if (!indexesPerBin.ContainsKey(currentBin))
-          indexesPerBin[currentBin] = new List<int>();
-        indexesPerBin[currentBin].Add(i);
-      }
-      foreach (var entry in indexesPerBin) {
-        for (int i = 0; i < entry.Value.Count - 1; i++)
-          for (int j = i + 1; j < entry.Value.Count; j++)
-            yield return new SwapPositionMove(entry.Value[i], entry.Value[j], multiComponentVector);
-      }
+      for (int bin = 0; bin < multiComponentVector.PackingInformations.Count; bin++)
+        for (int oldIndex = 0; oldIndex < multiComponentVector.PackingInformations[bin].Count - 1; oldIndex++) 
+          for (int newIndex = oldIndex + 1; newIndex < multiComponentVector.PackingInformations[bin].Count; newIndex++)
+            yield return new SwapPositionMove(bin, oldIndex, newIndex, multiComponentVector);
     }
 
     public static int NrOfChangePositionMoves(MultiComponentVectorEncoding mcv) {
-      int nrOfBins = 0;
-      foreach (var pi in mcv.PackingInformations) {
-        if (pi.AssignedBin > nrOfBins)
-          nrOfBins = pi.AssignedBin;
+      int nrOfChangePositionMoves = 0;
+      foreach (var groupInformations in mcv.PackingInformations) {
+        nrOfChangePositionMoves += (groupInformations.Value.Count * (groupInformations.Value.Count - 1)) / 2;
       }
-      nrOfBins++;
-      int[] itemsPerBin = new int[nrOfBins];
-      foreach (var pi in mcv.PackingInformations) {
-        itemsPerBin[pi.AssignedBin]++;
-      }
-      int nrOfSwapPositionMoves = 0;
-      foreach (int items in itemsPerBin) {
-        nrOfSwapPositionMoves += (items * (items - 1)) / 2;
-      }
-      return nrOfSwapPositionMoves;
+      return nrOfChangePositionMoves;
     }
     public static IEnumerable<MultiComponentVectorMove> GenerateChangePositionMoves(MultiComponentVectorEncoding multiComponentVector) {
-      Dictionary<int, List<int>> indexesPerBin = new Dictionary<int, List<int>>();
-      for (int i = 0; i < multiComponentVector.PackingInformations.Count; i++) {
-        int currentBin = multiComponentVector.PackingInformations[i].AssignedBin;
-        if (!indexesPerBin.ContainsKey(currentBin))
-          indexesPerBin[currentBin] = new List<int>();
-        indexesPerBin[currentBin].Add(i);
-      }
-      foreach (var entry in indexesPerBin) {
-        for (int i = 0; i < entry.Value.Count - 1; i++)
-          for (int j = i + 1; j < entry.Value.Count; j++)
-            yield return new ChangePositionMove(entry.Value[i], entry.Value[j], multiComponentVector);
-      }
+      for (int bin = 0; bin < multiComponentVector.PackingInformations.Count; bin++)
+        for (int oldIndex = 0; oldIndex < multiComponentVector.PackingInformations[bin].Count - 1; oldIndex++) 
+          for (int newIndex = oldIndex + 1; newIndex < multiComponentVector.PackingInformations[bin].Count; newIndex++)
+            yield return new ChangePositionMove(bin, oldIndex, newIndex, multiComponentVector);
     }
 
@@ -162,5 +115,5 @@
       for (int i = 0; i < moveScopes.Length; i++) {
         moveScopes[i] = new Scope(i.ToString());
-        moveScopes[i].Variables.Add(new Variable(MultiComponentVectorMoveParameter.ActualName, moves[i]));
+        moveScopes[i].Variables.Add(new Variable(PackingMoveParameter.ActualName, moves[i]));
       }
       CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveHardTabuCriterion.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveHardTabuCriterion.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveHardTabuCriterion.cs	(revision 9495)
@@ -38,6 +38,6 @@
       get { return false; }
     }
-    public ILookupParameter<MultiComponentVectorMove> MultiComponentVectorMoveParameter {
-      get { return (ILookupParameter<MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
     }
     public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter {
@@ -65,5 +65,5 @@
     public MultiComponentVectorMoveHardTabuCriterion()
       : base() {
-        Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
       Parameters.Add(new LookupParameter<MultiComponentVectorEncoding>("MultiComponentVector", "The solution to evaluate."));
       Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
@@ -80,5 +80,5 @@
     public override IOperation Apply() {
       ItemList<IItem> tabuList = TabuListParameter.ActualValue;
-      MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;
+      MultiComponentVectorMove move = PackingMoveParameter.ActualValue as MultiComponentVectorMove;
       MultiComponentVectorEncoding multiComponentVector = MultiComponentVectorParameter.ActualValue;
       int length = multiComponentVector.PackingInformations.Count;
@@ -94,93 +94,17 @@
     private bool IsMoveTabu(ItemList<IItem> tabuList, MultiComponentVectorMove move, MultiComponentVectorEncoding multiComponentVector, double moveQuality, bool maximization, bool useAspiration) {
       bool isTabu = false;
-      SingleItemRotationMove sirm = move as SingleItemRotationMove;
-      SingleGroupingMove sgm = move as SingleGroupingMove;
-      SwapPositionMove spm = move as SwapPositionMove;
-      ChangePositionMove cpm = move as ChangePositionMove;
-      MCVTripleMove tm = move as MCVTripleMove;
       var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType()));
 
-      if (sirm != null) {
-        foreach (IItem tabuMove in attributes) {
-          SingleItemRotationMoveAttribute sirmAttr = (tabuMove as SingleItemRotationMoveAttribute);
-          if (sirmAttr.MoveQuality.Equals(moveQuality))
-            return true;
-          if (sirmAttr != null
-            && (!useAspiration
-                || maximization && moveQuality <= sirmAttr.MoveQuality
-                || !maximization && moveQuality >= sirmAttr.MoveQuality)) {
-                  if (sirm.ItemIndex == sirmAttr.ItemIndex || multiComponentVector.PackingInformations[sirm.ItemIndex].Rotated == sirmAttr.ItemRotation)
-                    isTabu = true;
-          }
-          if (isTabu) break;
+      foreach (IItem attr in attributes) {
+        MultiComponentVectorMoveAttribute mcvAttr = attr as MultiComponentVectorMoveAttribute;
+        if (mcvAttr != null
+          && (!useAspiration
+              || maximization && moveQuality <= mcvAttr.MoveQuality
+              || !maximization && moveQuality >= mcvAttr.MoveQuality)) {
+
+          isTabu = move.BelongsToAttribute(mcvAttr, true);
         }
-      } else if (sgm != null) {
-        foreach (IItem tabuMove in attributes) {
-          SingleGroupingMoveAttribute sgmAttr = (tabuMove as SingleGroupingMoveAttribute);
-          if (sgmAttr.MoveQuality.Equals(moveQuality))
-            return true;
-          if (sgmAttr != null
-            && (!useAspiration
-                || maximization && moveQuality <= sgmAttr.MoveQuality
-                || !maximization && moveQuality >= sgmAttr.MoveQuality)) {
-                  if ( multiComponentVector.PackingInformations[sgm.Index].ItemIndex ==  multiComponentVector.PackingInformations[sgmAttr.Index].ItemIndex
-                    || multiComponentVector.PackingInformations[sgm.Index].AssignedBin == sgmAttr.AssignedBin)
-                    isTabu = true;
-          }
-          if (isTabu) break;
-        }
-      } else if (spm != null) {
-        foreach (IItem tabuMove in attributes) {
-          SwapPositionMoveAttribute spmAttr = (tabuMove as SwapPositionMoveAttribute);
-          if (spmAttr.MoveQuality.Equals(moveQuality))
-            return true;
-          if (spmAttr != null
-            && (!useAspiration
-                || maximization && moveQuality <= spmAttr.MoveQuality
-                || !maximization && moveQuality >= spmAttr.MoveQuality)) {
-            if (spm.Index1 == spmAttr.Index1
-              || spm.Index2 == spmAttr.Index2
-              || multiComponentVector.PackingInformations[spm.Index1].ItemIndex == spmAttr.ItemIndex1
-              || multiComponentVector.PackingInformations[spm.Index2].ItemIndex == spmAttr.ItemIndex2)
-              isTabu = true;
-          }
-          if (isTabu) break;
-        }
-      } else if (cpm != null) {
-        foreach (IItem tabuMove in attributes) {
-          ChangePositionMoveAttribute cpmAttr = (tabuMove as ChangePositionMoveAttribute);
-          if (cpmAttr.MoveQuality.Equals(moveQuality))
-            return true;
-          if (cpmAttr != null
-            && (!useAspiration
-                || maximization && moveQuality <= cpmAttr.MoveQuality
-                || !maximization && moveQuality >= cpmAttr.MoveQuality)) {
-            if (cpm.Index == cpmAttr.Index
-        || cpm.TargetIndex == cpmAttr.TargetIndex
-        || multiComponentVector.PackingInformations[cpm.Index].ItemIndex == cpmAttr.ItemIndex)
-              isTabu = true;
-          }
-          if (isTabu) break;
-        }
-      } else if (tm != null) {
-        foreach (IItem tabuMove in attributes) {
-          MCVTripleMoveAttribute tmAttr = (tabuMove as MCVTripleMoveAttribute);
-          if (tmAttr.MoveQuality.Equals(moveQuality))
-            return true;
-          if (tmAttr != null
-            && (!useAspiration
-                || maximization && moveQuality <= tmAttr.MoveQuality
-                || !maximization && moveQuality >= tmAttr.MoveQuality)) {
-                  if ((tm.Index == tmAttr.Index && tm.TargetIndex == tmAttr.TargetIndex)
-                      || tm.Index == tmAttr.Index
-                      || multiComponentVector.PackingInformations[tm.Index].ItemIndex == tmAttr.ItemIndex
-                    )
-              isTabu = true;
-          }
-          if (isTabu) break;
-        }
-      } 
-
-      
+        if (isTabu) break;
+      }
 
       return isTabu;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveMaker.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveMaker.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveMaker.cs	(revision 9495)
@@ -42,9 +42,15 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
     }
-    public ILookupParameter<MultiComponentVectorMove> MultiComponentVectorMoveParameter {
-      get { return (ILookupParameter<MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
     }
     public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter {
       get { return (ILookupParameter<MultiComponentVectorEncoding>)Parameters["MultiComponentVector"]; }
+    }
+    public ILookupParameter<IPackingPlan> PackingPlanParameter {
+      get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlan"]; }
+    }
+    public ILookupParameter<IPackingPlan> PackingPlanAfterMoveParameter {
+      get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlanAfterMove"]; }
     }
 
@@ -55,7 +61,9 @@
       : base() {
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
-      Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "The move to evaluate."));
+      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<MultiComponentVectorEncoding>("MultiComponentVector", "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."));
     }
 
@@ -65,10 +73,11 @@
 
     public override IOperation Apply() {
-      MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;
+      IPackingMove move = PackingMoveParameter.ActualValue;
       MultiComponentVectorEncoding multiComponentVector = MultiComponentVectorParameter.ActualValue;
       DoubleValue moveQuality = MoveQualityParameter.ActualValue;
       DoubleValue quality = QualityParameter.ActualValue;
 
-      multiComponentVector.PackingInformations = move.GetVectorAfterMove().PackingInformations;
+      multiComponentVector.PackingInformations = (move.GetSolutionAfterMove() as MultiComponentVectorEncoding).PackingInformations;
+      PackingPlanParameter.ActualValue = PackingPlanAfterMoveParameter.ActualValue;
 
       quality.Value = moveQuality.Value;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveSoftTabuCriterion.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveSoftTabuCriterion.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveSoftTabuCriterion.cs	(revision 9495)
@@ -38,6 +38,6 @@
       get { return false; }
     }
-    public ILookupParameter<MultiComponentVectorMove> MultiComponentVectorMoveParameter {
-      get { return (ILookupParameter<MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
     }
     public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter {
@@ -65,5 +65,5 @@
     public MultiComponentVectorMoveSoftTabuCriterion()
       : base() {
-      Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
       Parameters.Add(new LookupParameter<MultiComponentVectorEncoding>("MultiComponentVector", "The solution to evaluate."));
       Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
@@ -80,5 +80,5 @@
     public override IOperation Apply() {
       ItemList<IItem> tabuList = TabuListParameter.ActualValue;
-      MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;
+      MultiComponentVectorMove move = PackingMoveParameter.ActualValue as MultiComponentVectorMove;
       MultiComponentVectorEncoding multiComponentVector = MultiComponentVectorParameter.ActualValue;
       int length = multiComponentVector.PackingInformations.Count;
@@ -94,85 +94,17 @@
     private bool IsMoveTabu(ItemList<IItem> tabuList, MultiComponentVectorMove move, MultiComponentVectorEncoding multiComponentVector, double moveQuality, bool maximization, bool useAspiration) {
       bool isTabu = false;
-
-      SingleItemRotationMove sirm = move as SingleItemRotationMove;
-      SingleGroupingMove sgm = move as SingleGroupingMove;
-      SwapPositionMove spm = move as SwapPositionMove;
-      ChangePositionMove cpm = move as ChangePositionMove;
-      MCVTripleMove tm = move as MCVTripleMove;
       var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType()));
 
-      if (sirm != null) {
-        foreach (IItem tabuMove in attributes) {
-          SingleItemRotationMoveAttribute sirmAttr = (tabuMove as SingleItemRotationMoveAttribute);
-          if (sirmAttr != null
-            && (!useAspiration
-                || maximization && moveQuality <= sirmAttr.MoveQuality
-                || !maximization && moveQuality >= sirmAttr.MoveQuality)) {
-            if (sirm.ItemIndex == sirmAttr.ItemIndex && multiComponentVector.PackingInformations[sirm.ItemIndex].Rotated == sirmAttr.ItemRotation)
-              isTabu = true;
-          }
-          if (isTabu) break;
+      foreach (IItem attr in attributes) {
+        MultiComponentVectorMoveAttribute mcvAttr = attr as MultiComponentVectorMoveAttribute;
+        if (mcvAttr != null
+          && (!useAspiration
+              || maximization && moveQuality <= mcvAttr.MoveQuality
+              || !maximization && moveQuality >= mcvAttr.MoveQuality)) {
+
+                isTabu = move.BelongsToAttribute(mcvAttr, false);
         }
-      } else if (sgm != null) {
-        foreach (IItem tabuMove in attributes) {
-          SingleGroupingMoveAttribute sgmAttr = (tabuMove as SingleGroupingMoveAttribute);
-          if (sgmAttr != null
-            && (!useAspiration
-                || maximization && moveQuality <= sgmAttr.MoveQuality
-                || !maximization && moveQuality >= sgmAttr.MoveQuality)) {
-                  if (multiComponentVector.PackingInformations[sgm.Index].ItemIndex == multiComponentVector.PackingInformations[sgmAttr.Index].ItemIndex 
-              && multiComponentVector.PackingInformations[sgm.Index].AssignedBin == sgmAttr.AssignedBin)
-              isTabu = true;
-          }
-          if (isTabu) break;
-        }
-      } else if (spm != null) {
-        foreach (IItem tabuMove in attributes) {
-          SwapPositionMoveAttribute spmAttr = (tabuMove as SwapPositionMoveAttribute);
-          if (spmAttr != null
-            && (!useAspiration
-                || maximization && moveQuality <= spmAttr.MoveQuality
-                || !maximization && moveQuality >= spmAttr.MoveQuality)) {
-            if (spm.Index1 == spmAttr.Index1
-              && spm.Index2 == spmAttr.Index2
-              && multiComponentVector.PackingInformations[spm.Index1].ItemIndex == spmAttr.ItemIndex1
-              && multiComponentVector.PackingInformations[spm.Index2].ItemIndex == spmAttr.ItemIndex2)
-              isTabu = true;
-          }
-          if (isTabu) break;
-        }
-      } else if (cpm != null) {
-        foreach (IItem tabuMove in attributes) {
-          ChangePositionMoveAttribute cpmAttr = (tabuMove as ChangePositionMoveAttribute);
-          if (cpmAttr != null
-            && (!useAspiration
-                || maximization && moveQuality <= cpmAttr.MoveQuality
-                || !maximization && moveQuality >= cpmAttr.MoveQuality)) {
-            if (cpm.Index == cpmAttr.Index
-        && cpm.TargetIndex == cpmAttr.TargetIndex
-        && multiComponentVector.PackingInformations[cpm.Index].ItemIndex == cpmAttr.ItemIndex)
-              isTabu = true;
-          }
-          if (isTabu) break;
-        }
-      } else if (tm != null) {
-        foreach (IItem tabuMove in attributes) {
-          MCVTripleMoveAttribute tmAttr = (tabuMove as MCVTripleMoveAttribute);
-          if (tmAttr != null
-            && (!useAspiration
-                || maximization && moveQuality <= tmAttr.MoveQuality
-                || !maximization && moveQuality >= tmAttr.MoveQuality)) {
-            if ((tm.Index == tmAttr.Index && tm.TargetIndex == tmAttr.TargetIndex)
-                && multiComponentVector.PackingInformations[tm.Index].ItemIndex == tmAttr.ItemIndex
-                && tm.Rotation == !(tmAttr.RotationAfter.Equals(tmAttr.RotationBefore))
-                && (tm.Group == tmAttr.GroupAfter && multiComponentVector.PackingInformations[tm.Index].AssignedBin == tmAttr.GroupBefore)
-              )
-              isTabu = true;
-          }
-          if (isTabu) break;
-        }
-      } 
-
-
+        if (isTabu) break;
+      }
 
       return isTabu;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorTabuMaker.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorTabuMaker.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorTabuMaker.cs	(revision 9495)
@@ -32,6 +32,6 @@
   [StorableClass]
   public class MultiComponentVectorTabuMaker : TabuMaker, IMultiComponentVectorMoveOperator{
-    public ILookupParameter<MultiComponentVectorMove> MultiComponentVectorMoveParameter {
-      get { return (ILookupParameter<MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
     }
     public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter {
@@ -44,5 +44,5 @@
     public MultiComponentVectorTabuMaker()
       : base() {
-      Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "The move to evaluate."));
+        Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
       Parameters.Add(new LookupParameter<MultiComponentVectorEncoding>("MultiComponentVector", "The solution to evaluate."));
     }
@@ -53,5 +53,5 @@
 
     protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) {
-      MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;
+      IPackingMove move = PackingMoveParameter.ActualValue;
       MultiComponentVectorEncoding solution = MultiComponentVectorParameter.ActualValue;
       double baseQuality = moveQuality;
@@ -59,28 +59,7 @@
         baseQuality = quality; // we make an uphill move, the lower bound is the solution quality
                               
-      SingleItemRotationMove sirm = move as SingleItemRotationMove;
-      if (sirm != null)
-        return new SingleItemRotationMoveAttribute(sirm.ItemIndex, solution.PackingInformations[sirm.ItemIndex].Rotated, baseQuality);
-      SingleGroupingMove sgm = move as SingleGroupingMove;
-      if (sgm != null)
-        return new SingleGroupingMoveAttribute(sgm.Index, solution.PackingInformations[sgm.Index].AssignedBin, baseQuality);
-      SwapPositionMove spm = move as SwapPositionMove;
-      if (spm != null)
-        return new SwapPositionMoveAttribute(spm.Index1, spm.Index2, solution.PackingInformations[spm.Index1].ItemIndex, solution.PackingInformations[spm.Index2].ItemIndex, baseQuality);
-      ChangePositionMove cpm = move as ChangePositionMove;
-      if (cpm != null)
-        return new ChangePositionMoveAttribute(cpm.Index, cpm.TargetIndex, solution.PackingInformations[cpm.Index].ItemIndex, baseQuality);
-      MCVTripleMove tm = move as MCVTripleMove;
-      if (tm != null)
-        return new MCVTripleMoveAttribute(
-          tm.Index, 
-          tm.TargetIndex,
-          solution.PackingInformations[tm.Index].ItemIndex,
-          solution.PackingInformations[tm.Index].Rotated,
-          tm.Rotation ^ solution.PackingInformations[tm.Index].Rotated,
-          solution.PackingInformations[tm.Index].AssignedBin,
-          tm.Group,
-          baseQuality);
-
+      MultiComponentVectorMove mcvMove = move as MultiComponentVectorMove;
+      if (mcvMove != null)
+        return mcvMove.GetAttribute(baseQuality);
       else return solution;
     }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/StochasticMultiComponentVectorMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/StochasticMultiComponentVectorMoveGenerator.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/StochasticMultiComponentVectorMoveGenerator.cs	(revision 9495)
@@ -29,5 +29,5 @@
 
 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
-  [Item("StochasticMultiComponentVectorMoveGenerator", "Generates all possible multi component moves from a given multiComponentVector.")]
+  [Item("Stochastic MultiComponentVector Move Generator", "Generates all possible multi component moves from a given multiComponentVector.")]
   [StorableClass]
   public class StochasticMultiComponentVectorMoveGenerator : MultiComponentVectorMoveGenerator, IMultiMoveGenerator, IStochasticOperator {
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorEncoding.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorEncoding.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorEncoding.cs	(revision 9495)
@@ -37,5 +37,14 @@
 
     [Storable]
-    public ItemList<PackingInformation> PackingInformations {get;set;}   
+    public ObservableDictionary<int, ItemList<PackingInformation>> PackingInformations {get;set;}
+
+    public int NrOfBins { get { return PackingInformations.Count; } }
+    public int NrOfItems { 
+      get {
+        int nrOfItems = 0;
+        foreach (var entry in PackingInformations) { nrOfItems += entry.Value.Count; }
+        return nrOfItems;
+      } 
+    }
 
     [StorableConstructor]
@@ -43,5 +52,8 @@
     protected MultiComponentVectorEncoding(MultiComponentVectorEncoding original, Cloner cloner)
       : base(original, cloner) {
-        this.PackingInformations = cloner.Clone(original.PackingInformations);
+        this.PackingInformations = new ObservableDictionary<int,ItemList<PackingInformation>>();
+      foreach (var entry in original.PackingInformations) {
+        this.PackingInformations[entry.Key] = cloner.Clone(entry.Value);
+      }
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -51,5 +63,5 @@
     public MultiComponentVectorEncoding()
       : base() {
-        PackingInformations = new ItemList<PackingInformation>();
+        PackingInformations = new ObservableDictionary<int, ItemList<PackingInformation>>();
     }
 
@@ -57,6 +69,10 @@
       StringBuilder sb = new StringBuilder();
       sb.Append("[ ");
-      foreach (var pi in PackingInformations) {
-        sb.Append(pi.ToString() + " ");        
+      foreach (var gi in PackingInformations) {
+        sb.Append("g#" + gi.Key.ToString() + "{ ");
+        foreach (var pi in gi.Value) {
+          sb.Append(pi.ToString() + " ");
+        }
+        sb.Append("} ");
       }
       sb.Append("]");
@@ -85,18 +101,14 @@
   public class PackingInformation : Item {
     [Storable]
-    public int ItemIndex { get; set; }
-    [Storable]
-    public int AssignedBin { get; set; }
+    public int ItemID { get; set; }
     [Storable]
     public bool Rotated { get; set; }
 
-    public PackingInformation(int itemIndex, int assignedBin, bool rotated) {
-      this.AssignedBin  = assignedBin;
-      this.ItemIndex   = itemIndex;
+    public PackingInformation(int itemID, bool rotated) {
+      this.ItemID   = itemID;
       this.Rotated      = rotated;
     }     
     public PackingInformation(PackingInformation original) {
-      this.AssignedBin = original.AssignedBin;
-      this.ItemIndex = original.ItemIndex;
+      this.ItemID = original.ItemID;
       this.Rotated = original.Rotated;
     }
@@ -106,6 +118,5 @@
     protected PackingInformation(PackingInformation original, Cloner cloner)
       : base(original, cloner) {
-        this.AssignedBin  = original.AssignedBin;
-        this.ItemIndex   = original.ItemIndex;
+        this.ItemID   = original.ItemID;
         this.Rotated      = original.Rotated;
     }
@@ -115,5 +126,6 @@
 
     public override string ToString() {
-      return String.Format("({0}, {1}, {2}) ", ItemIndex, AssignedBin, Rotated);
+      return String.Format("{0}", ItemID.ToString());
+      //return String.Format("({0}, {1}) ", ItemID, Rotated ? "t" : "f");
     }
 
@@ -121,5 +133,5 @@
       PackingInformation pi = obj as PackingInformation;
       if (pi != null)
-        return this.ItemIndex.Equals(pi.ItemIndex) && this.AssignedBin.Equals(pi.AssignedBin) && this.Rotated.Equals(pi.Rotated);
+        return this.ItemID.Equals(pi.ItemID) && this.Rotated.Equals(pi.Rotated);
 
       return false;
@@ -130,18 +142,23 @@
     }
 
-    public static ItemList<PackingInformation> CreateListRandomly(int items, int lowerBound, IRandom random) {
-      Permutation permutation = new Permutation(PermutationTypes.Absolute, items, random);
-      var result = new ItemList<PackingInformation>();
-      foreach (int itemIndex in permutation) {
-        result.Add(new PackingInformation(itemIndex, random.Next(0, lowerBound + 1), random.Next(0, 100) > 60 ? true : false));
+    public static ObservableDictionary<int, ItemList<PackingInformation>> CreateDictionaryRandomly(int items, int nrOfBins, IRandom random) {
+      var result = new ObservableDictionary<int, ItemList<PackingInformation>>();
+      for (int i = 0; i < nrOfBins; i++)
+        result[i] = new ItemList<PackingInformation>();
+
+      Permutation randomItemSequence = new Permutation(PermutationTypes.Absolute, items, random);
+      foreach (int i in randomItemSequence) {
+        result[random.Next(nrOfBins)].Add(new PackingInformation(i, random.Next(100) > 60 ? true : false));
       }
       return result;
     }
 
-    public static ItemList<PackingInformation> CreateListRandomlyWithSortedSequence(int items, int lowerBound, IRandom random) {
-      Permutation permutation = new Permutation(PermutationTypes.Absolute, items);
-      var result = new ItemList<PackingInformation>();
-      foreach (int itemIndex in permutation) {
-        result.Add(new PackingInformation(itemIndex, random.Next(0, lowerBound + 1), false));
+    public static ObservableDictionary<int, ItemList<PackingInformation>> CreateDictionaryRandomlyWithSortedSequence(int items, int nrOfBins, IRandom random) {
+      var result = new ObservableDictionary<int, ItemList<PackingInformation>>();
+      for (int i = 0; i < nrOfBins; i++)
+        result[i] = new ItemList<PackingInformation>();
+
+      for (int i = 0; i < items; i++) {
+        result[random.Next(nrOfBins)].Add(new PackingInformation(i, false));
       }
       return result;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorRandomCreator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorRandomCreator.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorRandomCreator.cs	(revision 9495)
@@ -70,7 +70,7 @@
 			var solution = new MultiComponentVectorEncoding();
 			if (sortedSequence)
-				solution.PackingInformations = PackingInformation.CreateListRandomlyWithSortedSequence(items, lowerBound, random);
+				solution.PackingInformations = PackingInformation.CreateDictionaryRandomlyWithSortedSequence(items, lowerBound, random);
 			else
-				solution.PackingInformations = PackingInformation.CreateListRandomly(items, lowerBound, random);
+				solution.PackingInformations = PackingInformation.CreateDictionaryRandomly(items, lowerBound, random);
 			return solution;
 		}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/PartiallyMatchedMultiComponentVectorCrossover.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/PartiallyMatchedMultiComponentVectorCrossover.cs	(revision 9494)
+++ 	(revision )
@@ -1,82 +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.MultiComponentVector {
-  [Item("Partially Matched Multi Component Vector Crossover", "An operator which crosses two MultiComponentVector representations.")]
-  [StorableClass]
-  public class PartiallyMatchedMultiComponentVectorCrossover :  MultiComponentVectorCrossover {
-    [StorableConstructor]
-    protected PartiallyMatchedMultiComponentVectorCrossover(bool deserializing) : base(deserializing) { }
-    protected PartiallyMatchedMultiComponentVectorCrossover(PartiallyMatchedMultiComponentVectorCrossover original, Cloner cloner) : base(original, cloner) { }
-    public PartiallyMatchedMultiComponentVectorCrossover()
-      : base() {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PartiallyMatchedMultiComponentVectorCrossover(this, cloner);
-    }
-
-    public override MultiComponentVectorEncoding Cross(IRandom random, MultiComponentVectorEncoding parent1, MultiComponentVectorEncoding parent2) {
-      if (parent1.PackingInformations.Count != parent2.PackingInformations.Count) throw new ArgumentException("PartiallyMatchedCrossover: The parent permutations are of unequal length.");
-      if (parent1.PackingInformations.Count < 4) throw new ArgumentException("PartiallyMatchedCrossover: The parent permutation must be at least of size 4.");
-      int length = parent1.PackingInformations.Count;
-      PackingInformation[] result = new PackingInformation[length];
-      int[] invResult = new int[length];
-
-      int breakPoint1, breakPoint2;
-      do {
-        breakPoint1 = random.Next(length - 1);
-        breakPoint2 = random.Next(breakPoint1 + 1, length);
-      } while (breakPoint2 - breakPoint1 >= length - 2); // prevent the case [0,length-1) -> clone of parent1
-
-      // clone parent2 and calculate inverse permutation (number -> index)
-      try {
-        for (int j = 0; j < length; j++) {
-          result[j] = parent2.PackingInformations[j];
-          invResult[result[j].ItemIndex] = j;
-        }
-      }
-      catch (IndexOutOfRangeException) {
-        throw new InvalidOperationException("PartiallyMatchedCrossover: The permutation must consist of consecutive numbers from 0 to N-1 with N = length of the permutation.");
-      }
-
-      for (int j = breakPoint1; j <= breakPoint2; j++) {
-        PackingInformation orig = new PackingInformation (result[j]); // save the former value
-        result[j] = parent1.PackingInformations[j]; // overwrite the former value with the new value
-        int index = invResult[result[j].ItemIndex]; // look where the new value is in the offspring
-        result[index] = orig; // write the former value to this position
-        invResult[orig.ItemIndex] = index; // update the inverse mapping
-        // it's not necessary to do 'invResult[result[j]] = j' as this will not be needed again
-      }
-
-      var childSolution = new MultiComponentVectorEncoding();
-      childSolution.PackingInformations = new ItemList<PackingInformation> (result);
-      return childSolution; //new Permutation(parent1.PermutationType, result);
-    }
-
-  }
-}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/SequencePreservingMultiComponentVectorCrossover.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/SequencePreservingMultiComponentVectorCrossover.cs	(revision 9495)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/SequencePreservingMultiComponentVectorCrossover.cs	(revision 9495)
@@ -0,0 +1,96 @@
+﻿#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.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("Sequence Preserving Multi Component Vector Crossover", "An operator which crosses two MultiComponentVector representations.")]
+  [StorableClass]
+  public class SequencePreservingMultiComponentVectorCrossover :  MultiComponentVectorCrossover {
+    [StorableConstructor]
+    protected SequencePreservingMultiComponentVectorCrossover(bool deserializing) : base(deserializing) { }
+    protected SequencePreservingMultiComponentVectorCrossover(SequencePreservingMultiComponentVectorCrossover original, Cloner cloner) : base(original, cloner) { }
+    public SequencePreservingMultiComponentVectorCrossover()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SequencePreservingMultiComponentVectorCrossover(this, cloner);
+    }
+
+    public override MultiComponentVectorEncoding Cross(IRandom random, MultiComponentVectorEncoding parent1, MultiComponentVectorEncoding parent2) {
+      MultiComponentVectorEncoding child = new MultiComponentVectorEncoding ();
+      int nrOfItems = parent1.NrOfItems;
+      bool[] itemAlreadyAssigned = new bool[nrOfItems];
+
+      bool useParent2 = false;
+      int nrOfBins = parent1.NrOfBins > parent2.NrOfBins ? parent2.NrOfBins : parent1.NrOfBins;
+      for (int binNr = 0; binNr < nrOfBins; binNr++) { 
+        MultiComponentVectorEncoding currentParent1 = useParent2 ? parent2 : parent1;
+        MultiComponentVectorEncoding currentParent2 = useParent2 ? parent1 : parent2;
+
+                  
+        var newBin = new ItemList<PackingInformation>();
+        double crossPointPercent = 0;
+
+        int nrOfItems1 = currentParent1.PackingInformations[binNr].Count;
+        if (nrOfItems1 > 0) {
+          double crossPoint1 = random.Next(nrOfItems1);
+          crossPointPercent = crossPoint1 / nrOfItems1; 
+          for (int i = 0; i < crossPoint1; i++) {
+            PackingInformation pi = new PackingInformation(currentParent1.PackingInformations[binNr][i]);
+            if (!itemAlreadyAssigned[pi.ItemID]) {
+              itemAlreadyAssigned[pi.ItemID] = true;
+              newBin.Add(new PackingInformation(pi));
+            }
+          }
+        }
+
+        int nrOfItems2 = currentParent2.PackingInformations[binNr].Count;
+        if (nrOfItems2 > 0) {
+          int crossPoint2 = Convert.ToInt32(nrOfItems2 * crossPointPercent);
+          for (int i = crossPoint2; i < nrOfItems2; i++) {
+            PackingInformation pi = new PackingInformation(currentParent2.PackingInformations[binNr][i]);
+            if (!itemAlreadyAssigned[pi.ItemID]) {
+              itemAlreadyAssigned[pi.ItemID] = true;
+              newBin.Add(new PackingInformation(pi));
+            }
+          }
+        }
+
+        child.PackingInformations[binNr] = newBin;    
+        useParent2 = !useParent2;
+      }
+
+      for (int itemID = 0; itemID < nrOfItems; itemID++) {
+        if (!itemAlreadyAssigned[itemID])
+          child.PackingInformations[random.Next(nrOfBins)].Add(new PackingInformation(itemID, random.Next(2) == 0 ? true : false));
+      }
+
+      return child;
+    }       
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/ThreeWayMultiComponentVectorManipulator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/ThreeWayMultiComponentVectorManipulator.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/ThreeWayMultiComponentVectorManipulator.cs	(revision 9495)
@@ -28,5 +28,5 @@
 
 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
-  [Item("Uniform Multi Component Vector Manipulator", "An operator which manipulates a PackingSequence representation.")]
+  [Item("ThreeWayMultiComponentVectorManipulator", "An operator which manipulates a PackingSequence representation.")]
   [StorableClass]
   public class ThreeWayMultiComponentVectorManipulator :  MultiComponentVectorManipulator {
@@ -43,34 +43,30 @@
     protected override void Manipulate(IRandom random, MultiComponentVectorEncoding individual) {
       int manipulatorDecision = random.Next(0, 3);
+      int affectedBin = 0;
+      do {  
+        affectedBin = random.Next(individual.NrOfBins);
+      } while (individual.PackingInformations[affectedBin].Count <= 0);
+      int affectedIndex = random.Next (individual.PackingInformations[affectedBin].Count);
 
       //Randomly rotate one item
       if (manipulatorDecision == 0) {
-        bool r = individual.PackingInformations[random.Next(individual.PackingInformations.Count - 1)].Rotated;
-        individual.PackingInformations[random.Next(individual.PackingInformations.Count - 1)].Rotated = !r;
+        individual.PackingInformations = SingleItemRotationMove.GetVectorAfterMove(individual, affectedBin, affectedIndex).PackingInformations;
       } 
       //Randomly change the bin-assignment for one item
       else if (manipulatorDecision == 1) {
-        individual.PackingInformations[random.Next(individual.PackingInformations.Count - 1)].AssignedBin = 0;
+        int targetBin = 0;
+        if (individual.NrOfBins > 1)
+          do { targetBin = random.Next(individual.NrOfBins); }
+          while (targetBin != affectedBin);
+        individual.PackingInformations = SingleGroupingMove.GetVectorAfterMove(individual, affectedBin, affectedIndex, targetBin).PackingInformations;
       }
       //Swap the sequence of two items assigned to the same bin
       else if (manipulatorDecision == 2) {
-        int length = individual.PackingInformations.Count;
-
-        int counter = 0;
-        int swappedIndex1 = random.Next(length); 
-        int swappedIndex2 = random.Next(length);
-        while ((swappedIndex1 == swappedIndex2 || individual.PackingInformations[swappedIndex1].AssignedBin != individual.PackingInformations[swappedIndex2].AssignedBin) && counter < 10)
-        {
-          swappedIndex1 = random.Next(length); 
-          swappedIndex2 = random.Next(length);
-          counter++;
-        }
-
-        if (swappedIndex1 != swappedIndex2 && individual.PackingInformations[swappedIndex1].AssignedBin == individual.PackingInformations[swappedIndex2].AssignedBin) {
-          int temp = individual.PackingInformations[swappedIndex1].ItemIndex;
-          individual.PackingInformations[swappedIndex1].ItemIndex = individual.PackingInformations[swappedIndex2].ItemIndex;
-          individual.PackingInformations[swappedIndex2].ItemIndex = temp;
-        }
-
+        int targetIndex = 0;
+        int nrOfItems = individual.PackingInformations[affectedBin].Count;
+        if (nrOfItems > 1)
+          do { targetIndex = random.Next(nrOfItems); }
+          while (targetIndex != affectedIndex);
+        individual.PackingInformations = ChangePositionMove.GetVectorAfterMove(individual, affectedBin, affectedIndex, targetIndex).PackingInformations;
       }
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs	(revision 9495)
@@ -60,13 +60,7 @@
     [Storable]
     public ObservableDictionary<int, D> PackingItemPositions { get; set; }
+    [Storable]
+    public ObservableDictionary<int, B> PackingBinMeasures { get; set; }
 
-    //[Storable]
-    //public ItemList<BoolValue> PackingItemsRotated { get; set; }
-
-    [Storable]
-    public B PackingBinMeasures {
-      get;
-      set;
-    }
     [Storable]
     public ItemList<I> PackingItemMeasures {
@@ -89,7 +83,14 @@
     #endregion
 
-    public PackingPlan(B binMeasures, ItemList<I> itemMeasures) : base() {
+    public PackingPlan(B binMeasures, ItemList<I> itemMeasures)
+      : base() {
+      this.PackingItemMeasures = itemMeasures;
+      this.PackingBinMeasures = new ObservableDictionary<int, B>();
+      this.PackingBinMeasures[0] = binMeasures;
+    }
+    public PackingPlan(ObservableDictionary<int, B> binMeasures, ItemList<I> itemMeasures)
+      : base() {
+      this.PackingItemMeasures = itemMeasures;
       this.PackingBinMeasures = binMeasures;
-      this.PackingItemMeasures = itemMeasures;
     }
 
@@ -98,12 +99,17 @@
     protected PackingPlan(PackingPlan<D,B,I> original, Cloner cloner)
       : base(original, cloner) {
-        PackingItemPositions = new ObservableDictionary<int, D>(original.PackingItemPositions);
-      PackingBinMeasures = original.PackingBinMeasures;
+      PackingItemPositions = new ObservableDictionary<int, D>(original.PackingItemPositions);
+      PackingBinMeasures = new ObservableDictionary<int, B>(original.PackingBinMeasures);
       PackingItemMeasures = original.PackingItemMeasures;
-      //PackingItemsRotated = cloner.Clone(original.PackingItemsRotated);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingPlan<D,B,I>(this, cloner);
     }
 
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingPlan<D,B,I>(this, cloner);
+    public B GetPackingBinMeasuresForBinNr(int binNr) {
+      if (PackingBinMeasures.ContainsKey(binNr))
+        return PackingBinMeasures[binNr];
+      else
+        return PackingBinMeasures[0];
     }
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/BinUtilizationRegularIdenticalBinEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/BinUtilizationRegularIdenticalBinEvaluator.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/BinUtilizationRegularIdenticalBinEvaluator.cs	(revision 9495)
@@ -66,10 +66,10 @@
 
       //if (itemPositionsAreValid)
-      return CalculateBinUtilization(plan as PackingPlan<D, B, I>, binMeasure, itemMeasures);
+      return CalculateBinUtilization(plan as SingleBinSizePackingPlan<D, B, I>, binMeasure, itemMeasures);
 
       //return quality;
     }
 
-    public static DoubleValue CalculateBinUtilization(PackingPlan<D, B, I> plan, B binMeasure, ItemList<I> itemMeasures) {
+    public static DoubleValue CalculateBinUtilization(SingleBinSizePackingPlan<D, B, I> plan, B binMeasure, ItemList<I> itemMeasures) {
       int nrOfBins = plan.NrOfBins;
       double result = 0;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingPlanEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingPlanEvaluator.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingPlanEvaluator.cs	(revision 9495)
@@ -72,6 +72,5 @@
 
 
-    protected abstract DoubleValue Evaluate();
-
+    protected abstract DoubleValue Evaluate();                                                                        
     public override IOperation Apply() {
       QualityParameter.ActualValue = Evaluate();
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 9495)
@@ -176,7 +176,4 @@
     <Compile Include="Decoders\3D\DBL\DeepestBottomLeftMultiComponentVectorDecoder.cs" />
     <Compile Include="Decoders\3D\DBL\DeepestBottomLeftFunctions.cs" />
-    <Compile Include="Decoders\3D\EP\ExtremePointPotvinDecoder3D.cs">
-      <SubType>Code</SubType>
-    </Compile>
     <Compile Include="Decoders\3D\EP\ExtremePointsFunctions3D.cs" />
     <Compile Include="Decoders\3D\DBL\DeepestBottomLeftGroupingVectorDecoder.cs" />
@@ -184,7 +181,6 @@
     <Compile Include="Decoders\3D\DBL\DeepestBottomLeftPackingSequenceDecoder.cs" />
     <Compile Include="Decoders\2D\BL\BottomLeftPackingSequenceDecoder.cs" />
-    <Compile Include="Decoders\IdenticalBinPackingSolutionDecoder.cs" />
+    <Compile Include="Decoders\PackingSolutionDecoder.cs" />
     <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMoveSoftTabuCriterion.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\ExhaustiveTargetBinSingleGroupingMoveGenerator.cs" />
     <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\ExhaustiveSingleGroupingMoveGenerator.cs" />
     <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMove.cs" />
@@ -194,4 +190,5 @@
     <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingTabuMaker.cs" />
     <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMoveHardTabuCriterion.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\StochasticSingleGroupingMoveGenerator.cs" />
     <Compile Include="Encodings\GroupingVector\UniformGroupingVectorManipulator.cs" />
     <Compile Include="Encodings\GroupingVector\GroupingVectorCrossover.cs" />
@@ -199,4 +196,5 @@
     <Compile Include="Encodings\GroupingVector\GroupingVectorManipulator.cs" />
     <Compile Include="Encodings\GroupingVector\GroupingVectorRandomCreator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\SequencePreservingMultiComponentVectorCrossover.cs" />
     <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\ChangePositionMoveAttribute.cs" />
     <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\MCVTripleMoveAttribute.cs" />
@@ -223,5 +221,4 @@
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="Encodings\MultiComponentVector\PartiallyMatchedMultiComponentVectorCrossover.cs" />
     <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorCrossover.cs" />
     <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorManipulator.cs" />
@@ -236,15 +233,6 @@
     <Compile Include="Encodings\PackingSolutionCrossover.cs" />
     <Compile Include="Encodings\PackingSolutionManipulator.cs" />
-    <Compile Include="Encodings\Potvin\PotvinEncoding.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Encodings\Potvin\PotvinRandomCreator.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Evaluators\2D\BinUtilizationRectangularIdenticalBinEvaluator.cs" />
     <Compile Include="Evaluators\2D\PackingRatioRectangularIdenticalBinEvaluator.cs" />
-    <Compile Include="Evaluators\3D\BinUtilizationCuboiddenticalBinEvaluator.cs" />
     <Compile Include="Evaluators\3D\PackingRatioCuboidIdenticalBinEvaluator.cs" />
-    <Compile Include="Evaluators\Abstract\BinUtilizationRegularIdenticalBinEvaluator.cs" />
     <Compile Include="Evaluators\Abstract\PackingRatioRegularIdenticalBinEvaluator.cs" />
     <Compile Include="Evaluators\Abstract\RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs" />
@@ -257,4 +245,7 @@
     <Compile Include="Instances\BPPORLIBParser.cs" />
     <Compile Include="Instances\BPPORLIBDataDescriptor.cs" />
+    <Compile Include="Interfaces\I3DOperator.cs" />
+    <Compile Include="Interfaces\I2DOperator.cs" />
+    <Compile Include="Interfaces\IPackingMove.cs" />
     <Compile Include="Interfaces\IPotvinOperator.cs" />
     <Compile Include="Interfaces\IMultiComponentVectorMoveOperator.cs" />
@@ -274,8 +265,19 @@
     <Compile Include="Interfaces\IPackingShape.cs" />
     <Compile Include="Interfaces\IPackingDimensions.cs" />
-    <Compile Include="MoveEvaluators\MultiComponentVectorMoveEvaluator.cs" />
     <Compile Include="MoveEvaluators\PackingMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\GroupingVectorMoveEvaluator.cs" />
+    <Compile Include="MoveEvaluators\PackingMoveEvaluator2DGV.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="MoveEvaluators\PackingMoveEvaluator2DMCV.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="MoveEvaluators\PackingMoveEvaluator3DGV.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="MoveEvaluators\PackingMoveEvaluator3DMCV.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Problem\BinPackingProblem.cs" />
+    <Compile Include="Problem\ISOContainerBinPackingProblem.cs" />
     <Compile Include="Problem\CuboidIdenticalBinPackingProblem.cs" />
     <Compile Include="Problem\RegularIdenticalBinPackingProblem.cs" />
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/I2DOperator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/I2DOperator.cs	(revision 9495)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/I2DOperator.cs	(revision 9495)
@@ -0,0 +1,31 @@
+﻿#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 System.Linq;
+using System.Text;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.BinPacking.Interfaces {
+  public interface I2DOperator {
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/I3DOperator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/I3DOperator.cs	(revision 9495)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/I3DOperator.cs	(revision 9495)
@@ -0,0 +1,31 @@
+﻿#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 System.Linq;
+using System.Text;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.BinPacking.Interfaces {
+  public interface I3DOperator {
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingMove.cs	(revision 9495)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingMove.cs	(revision 9495)
@@ -0,0 +1,30 @@
+﻿#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.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.BinPacking.Interfaces  {
+  public interface IPackingMove : IItem {
+    IPackingSolutionEncoding GetSolutionAfterMove();
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/GroupingVectorMoveEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/GroupingVectorMoveEvaluator.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/GroupingVectorMoveEvaluator.cs	(revision 9495)
@@ -68,4 +68,6 @@
 
       var packingPlan = ExtremePointGroupingVectorDecoder3D.Decode(newSolution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      CurrentScopeParameter.ActualValue.Variables.Add(new Variable("PackingPlanAfterMove", packingPlan));
+
       DoubleValue quality = PackingRatioRegularIdenticalBinEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.CalculatePackingRatio(
         packingPlan, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/MultiComponentVectorMoveEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/MultiComponentVectorMoveEvaluator.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/MultiComponentVectorMoveEvaluator.cs	(revision 9495)
@@ -39,6 +39,6 @@
   [StorableClass]
   public class MultiComponentVectorMoveEvaluator : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator{
-    public ILookupParameter<MultiComponentVectorMove> MultiComponentVectorMoveParameter {
-      get { return (ILookupParameter<MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }  
+    public ILookupParameter<IPackingMove> MultiComponentVectorMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }  
     }                
     public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter {
@@ -51,5 +51,5 @@
     public MultiComponentVectorMoveEvaluator()
       : base() {
-      Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "The move to evaluate."));
+        //Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
       Parameters.Add(new LookupParameter<MultiComponentVectorEncoding>("MultiComponentVector", "The solution to evaluate."));
     }
@@ -60,18 +60,21 @@
 
     public override IOperation Apply() {
-      MultiComponentVectorEncoding MultiComponentVector = MultiComponentVectorParameter.ActualValue;
-      MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;
+      //MultiComponentVectorEncoding MultiComponentVector = MultiComponentVectorParameter.ActualValue;
+      //MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue as MultiComponentVectorMove;
 
-      MultiComponentVectorEncoding newSolution = new MultiComponentVectorEncoding();
-      newSolution = move.GetVectorAfterMove();
+      //MultiComponentVectorEncoding newSolution = new MultiComponentVectorEncoding();
+      //newSolution = move.GetSolutionAfterMove() as MultiComponentVectorEncoding;
+      //CurrentScopeParameter.ActualValue.Variables.Add(new Variable("MovedSolution", newSolution));
 
-      var packingPlan = ExtremePointMultiComponentVectorDecoder3D.Decode(newSolution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
-      DoubleValue quality = PackingRatioRegularIdenticalBinEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.CalculatePackingRatio(
-        packingPlan, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      //var packingPlan = ExtremePointMultiComponentVectorDecoder3D.Decode(newSolution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      //CurrentScopeParameter.ActualValue.Variables.Add(new Variable("PackingPlanAfterMove", packingPlan));
 
-      double moveQuality = quality.Value;
+      //DoubleValue quality = PackingRatioRegularIdenticalBinEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.CalculatePackingRatio(
+      //  packingPlan, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
 
-      if (MoveQualityParameter.ActualValue == null) MoveQualityParameter.ActualValue = new DoubleValue(moveQuality);
-      else MoveQualityParameter.ActualValue.Value = moveQuality;
+      //double moveQuality = quality.Value;
+
+      //if (MoveQualityParameter.ActualValue == null) MoveQualityParameter.ActualValue = new DoubleValue(moveQuality);
+      //else MoveQualityParameter.ActualValue.Value = moveQuality;
       return base.Apply();
     }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator.cs	(revision 9495)
@@ -24,8 +24,11 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Decoders;
+using HeuristicLab.Problems.BinPacking.Evaluators;
 using HeuristicLab.Problems.BinPacking.Interfaces;
 using HeuristicLab.Problems.BinPacking.Shapes;
@@ -36,6 +39,6 @@
   public abstract class PackingMoveEvaluator<D, B, I> : SingleSuccessorOperator, IPackingMoveEvaluator, IMoveOperator
     where D : class, IPackingDimensions
-    where B : PackingShape<D>, IPackingBin
-    where I : PackingShape<D>, IPackingItem {     
+    where B : PackingShape<D>, IPackingBin, IRegularPackingShape
+    where I : PackingShape<D>, IPackingItem, IRegularPackingShape {     
     public override bool CanChangeName {
       get { return false; }
@@ -60,4 +63,10 @@
       get { return (IValueLookupParameter<IPackingPlanEvaluator>)Parameters["PackingPlanEvaluator"]; }
     }
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }  
     
     [StorableConstructor]
@@ -72,4 +81,29 @@
       Parameters.Add(new ValueLookupParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The decoding operator that is used to calculate a packing plan from the used representation."));
       Parameters.Add(new ValueLookupParameter<IPackingPlanEvaluator>("PackingPlanEvaluator", "The actual packing plan evaluation operator."));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the decoded solution should be added to."));
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+    }
+
+
+
+    public override IOperation Apply() {
+      IPackingMove move = PackingMoveParameter.ActualValue;
+      IPackingSolutionEncoding newSolution = move.GetSolutionAfterMove();
+      CurrentScopeParameter.ActualValue.Variables.Add(new Variable("MovedSolution", newSolution));
+
+      PackingPlan<D, B, I> packingPlan = (PackingSolutionDecoderParameter.ActualValue as PackingSolutionDecoder<D, B, I>).
+        CreatePackingPlanFromEncoding(newSolution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+
+
+      CurrentScopeParameter.ActualValue.Variables.Add(new Variable("PackingPlanAfterMove", packingPlan));
+
+      DoubleValue quality = PackingRatioRegularIdenticalBinEvaluator<D, B, I>.CalculatePackingRatio(
+        packingPlan, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+
+      double moveQuality = quality.Value;
+
+      if (MoveQualityParameter.ActualValue == null) MoveQualityParameter.ActualValue = new DoubleValue(moveQuality);
+      else MoveQualityParameter.ActualValue.Value = moveQuality;
+      return base.Apply();
     }
   }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs	(revision 9495)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator2DGV.cs	(revision 9495)
@@ -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.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Decoders;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.Evaluators;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+
+namespace HeuristicLab.Problems.BinPacking {
+  [Item("GroupingVectorMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
+  [StorableClass]
+  public class PackingMoveEvaluator2DGV : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I2DOperator {
+    [StorableConstructor]
+    protected PackingMoveEvaluator2DGV(bool deserializing) : base(deserializing) { }
+    protected PackingMoveEvaluator2DGV(PackingMoveEvaluator2DGV original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingMoveEvaluator2DGV(this, cloner);
+    }
+    public PackingMoveEvaluator2DGV()
+      : base() {
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs	(revision 9495)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator2DMCV.cs	(revision 9495)
@@ -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.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Decoders;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.Evaluators;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+
+namespace HeuristicLab.Problems.BinPacking {
+  [Item("MultiComponentVectorMoveEvaluator2D", "Class for evaluating packing moves for 2dimensional problems.")]
+  [StorableClass]
+  public class PackingMoveEvaluator2DMCV : PackingMoveEvaluator<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I2DOperator {
+    [StorableConstructor]
+    protected PackingMoveEvaluator2DMCV(bool deserializing) : base(deserializing) { }
+    protected PackingMoveEvaluator2DMCV(PackingMoveEvaluator2DMCV original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingMoveEvaluator2DMCV(this, cloner);
+    }
+    public PackingMoveEvaluator2DMCV()
+      : base() {
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs	(revision 9495)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs	(revision 9495)
@@ -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.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Decoders;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.Evaluators;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+
+namespace HeuristicLab.Problems.BinPacking {
+  [Item("GroupingVectorMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
+  [StorableClass]
+  public class PackingMoveEvaluator3DGV : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I3DOperator {
+    [StorableConstructor]
+    protected PackingMoveEvaluator3DGV(bool deserializing) : base(deserializing) { }
+    protected PackingMoveEvaluator3DGV(PackingMoveEvaluator3DGV original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingMoveEvaluator3DGV(this, cloner);
+    }
+    public PackingMoveEvaluator3DGV()
+      : base() {
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs	(revision 9495)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs	(revision 9495)
@@ -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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Decoders;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.Evaluators;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+
+namespace HeuristicLab.Problems.BinPacking {
+  [Item("MultiComponentVectorMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
+  [StorableClass]
+  public class PackingMoveEvaluator3DMCV : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I3DOperator {
+    [StorableConstructor]
+    protected PackingMoveEvaluator3DMCV(bool deserializing) : base(deserializing) { }
+    protected PackingMoveEvaluator3DMCV(PackingMoveEvaluator3DMCV original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingMoveEvaluator3DMCV(this, cloner);
+    }
+    public PackingMoveEvaluator3DMCV()
+      : base() {
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Plugin.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Plugin.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Plugin.cs	(revision 9495)
@@ -26,5 +26,5 @@
   /// Plugin class for HeuristicLab.Problems.BinPacking plugin.
   /// </summary>
-  [Plugin("HeuristicLab.Problems.BinPacking", "3.3.7.9440")]
+  [Plugin("HeuristicLab.Problems.BinPacking", "3.3.7.9473")]
   [PluginFile("HeuristicLab.Problems.BinPacking-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Common", "3.3")]
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/CuboidIdenticalBinPackingProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/CuboidIdenticalBinPackingProblem.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/CuboidIdenticalBinPackingProblem.cs	(revision 9495)
@@ -44,5 +44,4 @@
 using HeuristicLab.Problems.Instances;
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
-using HeuristicLab.Encodings.PackingEncoding.Potvin;
 
 namespace HeuristicLab.Problems.BinPacking.Problem {
@@ -120,4 +119,6 @@
     #region Helpers
     protected override void InitializeDecoder() {
+      Operators.RemoveAll(op => typeof(I2DOperator).IsAssignableFrom(op.GetType()));
+
       if (SolutionCreator is PackingSequenceRandomCreator) {
         PackingSolutionDecoder = new ExtremePointPackingSequenceDecoder3D();
@@ -126,6 +127,4 @@
       } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
         PackingSolutionDecoder = new ExtremePointMultiComponentVectorDecoder3D();
-      } else if (SolutionCreator is PotvinRandomCreator) {
-        PackingSolutionDecoder = new ExtremePointPotvinDecoder3D();
       } else {
         string error = "The given problem does not support the selected solution-creator.";
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/ISOContainerBinPackingProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/ISOContainerBinPackingProblem.cs	(revision 9495)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/ISOContainerBinPackingProblem.cs	(revision 9495)
@@ -0,0 +1,142 @@
+﻿#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 System.Linq;
+using System.Text;
+using HeuristicLab.Problems.BinPacking.Dimensions;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.Shapes;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Optimization;
+using HeuristicLab.Problems.BinPacking.Evaluators;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.BinPacking.Decoders;
+using System.Reflection;
+using System.IO;
+using HeuristicLab.Parameters;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Problems.Instances;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+
+namespace HeuristicLab.Problems.BinPacking.Problem {
+  [Item("ISOContainerBinPackingProblem", "Represents a three-dimensional bin-packing problem using two different bin sizes.")]
+  [StorableClass]
+  [Creatable("Problems")]
+  public class ISOContainerBinPackingProblem : RegularIdenticalBinPackingProblem<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> {
+
+    #region Default Instance
+    private static readonly BPPData DefaultInstance = new BPPData() {  
+      Name = "3D BPP Default Instance", 
+      Description = "The default instance for 3D Bin Packing.",
+      BinMeasures = new int[] {25,25,35},
+      ItemMeasures = new int[][] {
+        new int[] {12,5,10},
+        new int[] {10,18,20},
+        new int[] {9,7,7},
+        new int[] {21,12,4},
+        new int[] {8,8,12},
+        new int[] {3,6,14},
+        new int[] {20,4,9},
+        new int[] {5,9,8},
+        new int[] {7,17,3},
+        new int[] {13,20,15},
+        new int[] {9,11,9},
+        new int[] {10,18,20},
+        new int[] {9,7,7},
+        new int[] {21,12,4},
+        new int[] {8,8,12},
+        new int[] {3,6,14},
+        new int[] {20,4,9},
+        new int[] {5,9,8},
+        new int[] {7,17,3},
+        new int[] {13,20,15},
+        new int[] {9,11,9},
+        new int[] {10,18,20},
+        new int[] {9,7,7},
+        new int[] {21,12,4},
+        new int[] {8,8,12},
+        new int[] {3,6,14},
+        new int[] {20,4,9},
+        new int[] {5,9,8},
+        new int[] {7,17,3},
+        new int[] {13,20,15},
+        new int[] {9,11,9},
+        new int[] {10,18,20},
+        new int[] {9,7,7},
+        new int[] {21,12,4},
+        new int[] {8,8,12},
+        new int[] {3,6,14},
+        new int[] {20,4,9},
+        new int[] {5,9,8},
+        new int[] {7,17,3},
+        new int[] {13,20,15},
+        new int[] {9,11,9}
+      },
+      Items = 30
+    };
+    #endregion
+    
+    [StorableConstructor]
+    protected ISOContainerBinPackingProblem(bool deserializing) : base(deserializing) { }
+    protected ISOContainerBinPackingProblem(ISOContainerBinPackingProblem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ISOContainerBinPackingProblem(this, cloner);
+    }
+    public ISOContainerBinPackingProblem() : base(
+      new PackingPlanEvaluationAlgorithm<PackingSequenceEncoding, ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>()) {
+    }
+
+
+
+    #region Helpers
+    protected override void InitializeDecoder() {
+      if (SolutionCreator is PackingSequenceRandomCreator) {
+        PackingSolutionDecoder = new ExtremePointPackingSequenceDecoder3D();
+      } else if (SolutionCreator is GroupingVectorRandomCreator) {
+        PackingSolutionDecoder = new ExtremePointGroupingVectorDecoder3D();
+      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
+        PackingSolutionDecoder = new ExtremePointMultiComponentVectorDecoder3D();
+      } else {
+        string error = "The given problem does not support the selected solution-creator.";
+        PluginInfrastructure.ErrorHandling.ShowErrorDialog(error, null);
+      }
+    }
+
+    protected override IPackingPlanEvaluator CreateDefaultEvaluator() {
+      return new PackingRatioCuboidIdenticalBinEvaluator();
+    }
+
+    protected override void InitializeProblemData() {
+      Load(DefaultInstance);
+    }
+    #endregion
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RectangularIdenticalBinPackingProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RectangularIdenticalBinPackingProblem.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RectangularIdenticalBinPackingProblem.cs	(revision 9495)
@@ -114,4 +114,6 @@
     #region Helpers
     protected override void InitializeDecoder() {
+      Operators.RemoveAll(op => typeof(I3DOperator).IsAssignableFrom(op.GetType()));
+
       if (SolutionCreator is PackingSequenceRandomCreator) {
         PackingSolutionDecoder = new ExtremePointPackingSequenceDecoder2D();
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RegularIdenticalBinPackingProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RegularIdenticalBinPackingProblem.cs	(revision 9494)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RegularIdenticalBinPackingProblem.cs	(revision 9495)
@@ -43,5 +43,4 @@
 using HeuristicLab.Problems.Instances;
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
-using HeuristicLab.Encodings.PackingEncoding.Potvin;
 
 namespace HeuristicLab.Problems.BinPacking.Problem {
@@ -67,6 +66,6 @@
       set { PackingBinMeasuresParameter.Value = value; } 
     }
-    public IdenticalBinPackingSolutionDecoder<D,B,I, PackingPlan<D,B,I>> PackingSolutionDecoder {
-      get { return PackingSolutionDecoderParameter.Value as IdenticalBinPackingSolutionDecoder<D, B, I, PackingPlan<D, B, I>>; }
+    public PackingSolutionDecoder<D,B,I> PackingSolutionDecoder {
+      get { return PackingSolutionDecoderParameter.Value as PackingSolutionDecoder<D, B, I>; }
       set { PackingSolutionDecoderParameter.Value = value; }
     }
@@ -139,7 +138,4 @@
         Operators.AddRange(ApplicationManager.Manager.GetInstances<IMultiComponentVectorOperator>());
         InitializeDecoder();
-      } else if (SolutionCreator.GetType() == typeof(PotvinRandomCreator)) {
-        Operators.AddRange(ApplicationManager.Manager.GetInstances<IPotvinOperator>());
-        InitializeDecoder();
       } 
     }
