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 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlans/PackingPlan2DView.cs	(revision 9440)
@@ -3,5 +3,5 @@
 using HeuristicLab.Core.Views;
 using HeuristicLab.MainForm;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Interfaces;
 using HeuristicLab.Problems.BinPacking.PackingItem;
@@ -13,5 +13,5 @@
 namespace HeuristicLab.Problems.BinPacking.Views {
   [View("2-dimensional packing plan View")]
-  [Content(typeof(RegularSimpleRotationPackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>), true)]
+  [Content(typeof(PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>), true)]
   public partial class PackingPlan2DView : NamedItemView {
 
@@ -21,6 +21,6 @@
 
 
-    public new RegularSimpleRotationPackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> Content {
-      get { return (RegularSimpleRotationPackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>)base.Content; }
+    public new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> Content {
+      get { return (PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>)base.Content; }
       set { base.Content = value; }
     }
@@ -44,5 +44,5 @@
     }
 
-    private void Redraw(RegularSimpleRotationPackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> plan) {     
+    private void Redraw(PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> plan) {     
       int currentBin = (binSelection != null && binSelection.SelectedItem != null) ? (int)(binSelection.SelectedItem) : 0;
       var bin = plan.PackingBinMeasures;
@@ -52,5 +52,8 @@
         var position = plan.PackingItemPositions[i++];
         if (position.AssignedBin == currentBin)
-          packingPlan2D.AddItemToContainer(item.Width, item.Height, position.X, position.Y, i.ToString());
+          packingPlan2D.AddItemToContainer(
+            position.Rotated ? item.Height : item.Width,
+            position.Rotated ? item.Width : item.Height, 
+            position.X, position.Y, i.ToString());
       }
     }
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 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlans/PackingPlan3DView.cs	(revision 9440)
@@ -3,5 +3,5 @@
 using HeuristicLab.Core.Views;
 using HeuristicLab.MainForm;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Interfaces;
 using HeuristicLab.Problems.BinPacking.PackingItem;
@@ -13,5 +13,5 @@
 namespace HeuristicLab.Problems.BinPacking.Views {
   [View("3-dimensional packing plan View")]
-  [Content(typeof(RegularSimpleRotationPackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>), true)]
+  [Content(typeof(PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>), true)]
   public partial class PackingPlan3DView : NamedItemView {
 
@@ -22,6 +22,6 @@
 
 
-    public new RegularSimpleRotationPackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Content {
-      get { return (RegularSimpleRotationPackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>)base.Content; }
+    public new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Content {
+      get { return (PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>)base.Content; }
       set { base.Content = value; }
     }
@@ -51,5 +51,9 @@
         var position = Content.PackingItemPositions[i];
         if (position.AssignedBin == currentBin) 
-          packingPlan3D.AddItemToContainer(item.Width, item.Height, item.Depth, position.X, position.Y, position.Z, i);
+          packingPlan3D.AddItemToContainer(
+            position.Rotated ? item.Depth : item.Width, 
+            item.Height, 
+            position.Rotated ? item.Width : item.Depth, 
+            position.X, position.Y, position.Z, i);
         i++;
       }
@@ -76,5 +80,5 @@
           itemSelection.Items.Add(i);
       }
-      itemSelection.Items.Add("enum");
+      //itemSelection.Items.Add("enum");
 
       packingPlan3D.Invalidate();
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Plugin.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Plugin.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Plugin.cs	(revision 9440)
@@ -26,5 +26,5 @@
   /// Plugin class for HeuristicLab.Problems.BinPacking.Views plugin.
   /// </summary>
-  [Plugin("HeuristicLab.Problems.BinPacking.Views", "3.3.7.0")]
+  [Plugin("HeuristicLab.Problems.BinPacking.Views", "3.3.7.9348")]
   [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 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Properties/AssemblyInfo.cs	(revision 9440)
@@ -54,3 +54,3 @@
 // by using the '*' as shown below:
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.7.0")]
+[assembly: AssemblyFileVersion("3.3.7.9348")]
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Shapes/CuboidPackingItemView.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Shapes/CuboidPackingItemView.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Shapes/CuboidPackingItemView.cs	(revision 9440)
@@ -3,5 +3,5 @@
 using HeuristicLab.Core.Views;
 using HeuristicLab.MainForm;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Interfaces;
 using HeuristicLab.Problems.BinPacking.Shapes;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Shapes/CuboidPackingShapeView.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Shapes/CuboidPackingShapeView.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Shapes/CuboidPackingShapeView.cs	(revision 9440)
@@ -3,5 +3,5 @@
 using HeuristicLab.Core.Views;
 using HeuristicLab.MainForm;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Interfaces;
 using HeuristicLab.Problems.BinPacking.Shapes;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Shapes/RectangularPackingItemView.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Shapes/RectangularPackingItemView.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Shapes/RectangularPackingItemView.cs	(revision 9440)
@@ -3,5 +3,5 @@
 using HeuristicLab.Core.Views;
 using HeuristicLab.MainForm;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Interfaces;
 using HeuristicLab.Problems.BinPacking.PackingItem;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Shapes/RectangularPackingShapeView.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Shapes/RectangularPackingShapeView.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Shapes/RectangularPackingShapeView.cs	(revision 9440)
@@ -3,5 +3,5 @@
 using HeuristicLab.Core.Views;
 using HeuristicLab.MainForm;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Interfaces;
 using HeuristicLab.Problems.BinPacking.Shapes;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BestBinPackingSolutionAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BestBinPackingSolutionAnalyzer.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BestBinPackingSolutionAnalyzer.cs	(revision 9440)
@@ -32,5 +32,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Shapes;
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BinPackingAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BinPackingAnalyzer.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BinPackingAnalyzer.cs	(revision 9440)
@@ -32,5 +32,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Shapes;
 
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftFunctions.cs	(revision 9440)
@@ -0,0 +1,66 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Collections;
+using HeuristicLab.Core;
+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 BottomLeftFunctions {
+    
+
+
+    public 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) {      
+      TwoDimensionalPacking currentPosition = new TwoDimensionalPacking(binNr, 
+        binMeasures.Width - (rotated ? currentItem.Height : currentItem.Width), 
+        binMeasures.Height - (rotated ? currentItem.Width : currentItem.Height), rotated);
+      //Slide the item as far as possible to the left
+      while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
+        || IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)) {
+        //Slide the item as far as possible to the bottom
+          while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)) {
+          currentPosition = MoveDown(currentPosition);
+        }
+          if (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures))
+          currentPosition = MoveLeft(currentPosition);
+      }
+
+      return IsPositionFeasible(binMeasures, binNr, currentItem, currentPosition, itemPositions, itemMeasures) ? currentPosition : null;
+    }
+
+    public static bool IsPositionFeasible(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem,
+      TwoDimensionalPacking currentPosition, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
+      //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the item does not collide with another already packed item
+      if (!binMeasures.Encloses(currentPosition, currentItem))
+        return false;
+      var itemsWithPositions = itemMeasures.
+        Select((Value, Index) => new { Value, Index }).
+        Where(s => itemPositions.ContainsKey(s.Index)).
+        Select((s) => new { Measures = itemMeasures[s.Index], Position = itemPositions[s.Index] });
+
+      foreach (var itemWithPosition in itemsWithPositions) {
+        if (itemWithPosition.Position.AssignedBin == binNr && itemWithPosition.Measures.Overlaps(itemWithPosition.Position, currentPosition, currentItem))
+          return false;
+      }
+
+      return true;
+    }
+
+    private static TwoDimensionalPacking MoveLeft(TwoDimensionalPacking original) {
+      return new TwoDimensionalPacking(original.AssignedBin, original.X - 1, original.Y, original.Rotated);
+    }
+    private static TwoDimensionalPacking MoveDown(TwoDimensionalPacking original) {
+      return new TwoDimensionalPacking(original.AssignedBin, original.X, original.Y - 1, original.Rotated);
+    }
+
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftGroupingVectorDecoder.cs	(revision 9440)
@@ -0,0 +1,146 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin two dimensional grouping vector decoder", "<Description missing...>")]
+  [StorableClass]
+  public class BottomLeftGroupingVectorDecoder : IdenticalBinPackingSolutionDecoder<
+      TwoDimensionalPacking,
+      RectangularPackingBin,
+      RectangularPackingItem,
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+
+    public BottomLeftGroupingVectorDecoder()
+      : base() {
+        //EncodedSolutionParameter.ActualName = "EncodedSolution";
+    }
+    [StorableConstructor]
+    protected BottomLeftGroupingVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected BottomLeftGroupingVectorDecoder(BottomLeftGroupingVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BottomLeftGroupingVectorDecoder(this, cloner);
+    }
+
+
+    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
+
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = 
+        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;
+
+
+      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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftMultiComponentVectorDecoder.cs	(revision 9440)
@@ -0,0 +1,139 @@
+﻿#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.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin two dimensional multi component vector decoder", "<Description missing...>")]
+  [StorableClass]
+  public class BottomLeftMultiComponentVectorDecoder : IdenticalBinPackingSolutionDecoder<
+      TwoDimensionalPacking,
+      RectangularPackingBin,
+      RectangularPackingItem,
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+
+    public BottomLeftMultiComponentVectorDecoder()
+      : base() {
+      //EncodedSolutionParameter.ActualName = "EncodedSolution";
+    }
+    [StorableConstructor]
+    protected BottomLeftMultiComponentVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected BottomLeftMultiComponentVectorDecoder(BottomLeftMultiComponentVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BottomLeftMultiComponentVectorDecoder(this, cloner);
+    }
+
+
+    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponent Vector");
+
+      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;
+
+      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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftPackingSequenceDecoder.cs	(revision 9440)
@@ -0,0 +1,98 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, two dimensional, direct permutation decoder", "<Description missing...>")]
+  [StorableClass]
+  public class BottomLeftPackingSequenceDecoder : IdenticalBinPackingSolutionDecoder<
+      TwoDimensionalPacking,
+      RectangularPackingBin,
+      RectangularPackingItem,
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+
+    public BottomLeftPackingSequenceDecoder()
+      : base() {
+        //EncodedSolutionParameter.ActualName = "EncodedSolution";
+    }
+    [StorableConstructor]
+    protected BottomLeftPackingSequenceDecoder(bool deserializing) : base(deserializing) { }
+    protected BottomLeftPackingSequenceDecoder(BottomLeftPackingSequenceDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BottomLeftPackingSequenceDecoder(this, cloner);
+    }
+
+
+    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as PackingSequenceEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = 
+        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;
+
+      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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointGroupingVectorDecoder2D.cs	(revision 9440)
@@ -0,0 +1,78 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, two dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointGroupingVectorDecoder2D : IdenticalBinPackingSolutionDecoder<
+      TwoDimensionalPacking,
+      RectangularPackingBin,
+      RectangularPackingItem,
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+
+    public ExtremePointGroupingVectorDecoder2D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ExtremePointGroupingVectorDecoder2D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointGroupingVectorDecoder2D(ExtremePointGroupingVectorDecoder2D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointGroupingVectorDecoder2D(this, cloner);
+    }
+
+    public static PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> Decode(GroupingVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures, itemMeasures);
+
+      result.PackingItemPositions = ExtremPointsFunctions2D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
+
+      return result;
+    }
+
+    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+                      
+      var solution = encodedSolution as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
+
+      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointMultiComponentVectorDecoder2D.cs	(revision 9440)
@@ -0,0 +1,79 @@
+﻿#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, two dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointMultiComponentVectorDecoder2D : IdenticalBinPackingSolutionDecoder<
+      TwoDimensionalPacking,
+      RectangularPackingBin,
+      RectangularPackingItem,
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+
+    public ExtremePointMultiComponentVectorDecoder2D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ExtremePointMultiComponentVectorDecoder2D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointMultiComponentVectorDecoder2D(ExtremePointMultiComponentVectorDecoder2D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointMultiComponentVectorDecoder2D(this, cloner);
+    }
+
+    public static PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> Decode(MultiComponentVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) {
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(binMeasures, itemMeasures);
+
+      result.PackingItemPositions = ExtremPointsFunctions2D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
+
+      return result;
+    }
+
+    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> 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/2D/EP/ExtremePointPackingSequenceDecoder2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 9440)
@@ -0,0 +1,74 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, two dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointPackingSequenceDecoder2D : IdenticalBinPackingSolutionDecoder<
+      TwoDimensionalPacking,
+      RectangularPackingBin,
+      RectangularPackingItem,
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+
+    public ExtremePointPackingSequenceDecoder2D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ExtremePointPackingSequenceDecoder2D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointPackingSequenceDecoder2D(ExtremePointPackingSequenceDecoder2D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointPackingSequenceDecoder2D(this, cloner);
+    }
+
+
+    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as PackingSequenceEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = 
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+
+      result.PackingItemPositions = ExtremPointsFunctions2D.ExtremePointBasedPacking(solution, PackingItemMeasuresParameter.ActualValue, PackingBinMeasuresParameter.ActualValue);
+
+      return result;
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointsFunctions2D.cs	(revision 9440)
@@ -0,0 +1,317 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+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;
+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 ExtremPointsFunctions2D {
+
+
+
+
+    public static ObservableDictionary<int, TwoDimensionalPacking> ExtremePointBasedPacking(MultiComponentVectorEncoding solution, 
+        ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures) {
+
+      #region Preperations
+      int nrOfBins = solution.PackingInformations.Max(x => x.AssignedBin) + 1;
+
+      //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<TwoDimensionalPacking>> extremePointsForBin = new Dictionary<int, HashSet<TwoDimensionalPacking>>();
+      var occupiedPoints = new List<int[,]>();
+
+      for (int i = 0; i < nrOfBins; i++) {        
+        unpackedItemIndexesPerBin[i] = solution.PackingInformations
+          .Where(pi => pi.AssignedBin == i)
+          .ToList();
+
+        extremePointsForBin[i] = new HashSet<TwoDimensionalPacking>();
+        extremePointsForBin[i].Add(new TwoDimensionalPacking(i, 0, 0, false));
+        occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+      }
+
+      ObservableDictionary<int, TwoDimensionalPacking> itemPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
+      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].ItemIndex;
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          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(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].ItemIndex;
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          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);
+            remainingItems.Remove(unpackedItems[i]);
+          }
+        }
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          extremePointsForBin[nrOfBins] = new HashSet<TwoDimensionalPacking>();
+          extremePointsForBin[nrOfBins].Add(new TwoDimensionalPacking(nrOfBins, 0, 0, false));
+          occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+          nrOfBins++;
+        }
+      }
+
+      return itemPositions;
+    }
+
+
+    public static ObservableDictionary<int, TwoDimensionalPacking> ExtremePointBasedPacking(GroupingVectorEncoding solution,
+        ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures) {
+
+      #region Preperations
+      int nrOfBins = solution.GroupingVector.Max() + 1;
+
+      //Get all indexes of items for every bin according to grouping-vector
+      Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>();   
+      Dictionary<int, HashSet<TwoDimensionalPacking>> extremePointsForBin = new Dictionary<int, HashSet<TwoDimensionalPacking>>(); 
+      var occupiedPoints = new 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();
+
+        extremePointsForBin[i] = new HashSet<TwoDimensionalPacking>();
+        extremePointsForBin[i].Add(new TwoDimensionalPacking(i, 0, 0, false));    
+        occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+      }
+
+      ObservableDictionary<int, TwoDimensionalPacking> itemPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
+      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] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, 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] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, 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);        
+            remainingItems.Remove(itemIndex);
+          } 
+        }
+        if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+          extremePointsForBin[nrOfBins] = new HashSet<TwoDimensionalPacking>();
+          extremePointsForBin[nrOfBins].Add(new TwoDimensionalPacking(nrOfBins, 0, 0, false));
+          occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+          nrOfBins++;
+        }
+      }
+
+      return itemPositions;
+    }
+
+
+    public static ObservableDictionary<int, TwoDimensionalPacking> ExtremePointBasedPacking(PackingSequenceEncoding solution, 
+        ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures) {
+
+      #region Preperations 
+      var itemPositions = new ObservableDictionary<int, TwoDimensionalPacking>();  
+      int nrOfBins = 1;
+
+      var occupiedPoints = new List<int[,]>();
+      occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+
+      HashSet<TwoDimensionalPacking> extremePoints = new HashSet<TwoDimensionalPacking>();
+      extremePoints.Add(new TwoDimensionalPacking(0, 0, 0, false));
+      #endregion
+
+      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)));
+        var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions);
+        if (positionFound != null) {
+          extremePoints.Remove(positionFound); 
+        }
+        else {
+          positionFound = new TwoDimensionalPacking(nrOfBins, 0, 0);
+          occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+          nrOfBins++;
+        }
+        itemPositions[itemIndex] = positionFound;
+        occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+        extremePoints = GenerateNewExtremePointsForNewItem(extremePoints, occupiedPoints, item, positionFound, binMeasures);
+      }
+
+      return itemPositions;
+    }
+
+
+    private static TwoDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures,
+        HashSet<TwoDimensionalPacking> extremePoints, List<int[,]> occupiedPoints, ObservableDictionary<int, TwoDimensionalPacking> itemPositions) {
+          return FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions, false);
+    }
+    private static TwoDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<RectangularPackingItem> itemMeasures, RectangularPackingBin binMeasures, 
+        HashSet<TwoDimensionalPacking> extremePoints, List<int[,]> occupiedPoints, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, bool rotated) {
+
+      var itemFromList = itemMeasures[itemIndex];
+      RectangularPackingItem item = new RectangularPackingItem(
+        rotated ? itemFromList.Height : itemFromList.Width, 
+        rotated ? itemFromList.Width : itemFromList.Height, 
+        itemFromList.TargetBin);
+
+      int epIndex = 0;
+      while (epIndex < extremePoints.Count &&
+        (!BottomLeftFunctions.IsPositionFeasible(binMeasures, extremePoints.ElementAt(epIndex).AssignedBin, item, extremePoints.ElementAt(epIndex), itemPositions, itemMeasures))) 
+      { epIndex++; }
+
+      if (epIndex < extremePoints.Count) {
+        var result = extremePoints.ElementAt(epIndex);
+        result.Rotated = rotated;
+        return result;
+      } 
+      return null;
+    }
+    private static List<int[,]> IncreaseBinCountForOccupiedPoints(List<int[,]> occupiedPoints, RectangularPackingBin binMeasures) {
+      occupiedPoints.Add(new int[binMeasures.Width, binMeasures.Height]);
+      int lastIndex = occupiedPoints.Count - 1;
+      for (int w = 0; w < binMeasures.Width; w++) {
+        for (int h = 0; h < binMeasures.Height; h++) {
+            occupiedPoints[lastIndex][w, h] = -1;
+        }
+      }
+      return occupiedPoints;
+    }
+    private static List<int[,]>  OccupyPointsForNewItem(List<int[,]> occupiedPoints, RectangularPackingItem newItem, TwoDimensionalPacking position, int itemIndex) {
+      int width = position.Rotated ? newItem.Height : newItem.Width; 
+      int height = position.Rotated ? newItem.Width : newItem.Height;
+      for (int w = position.X; w < position.X + width; w++) {
+        for (int h = position.Y; h < position.Y + height; h++) {
+            occupiedPoints[position.AssignedBin][w,h] = itemIndex;
+        }
+      }
+      return occupiedPoints;
+    }
+    private static HashSet<TwoDimensionalPacking> GenerateNewExtremePointsForNewItem(HashSet<TwoDimensionalPacking> extremePoints, List<int[,]> occupiedPoints, 
+        RectangularPackingItem newItem, TwoDimensionalPacking position, RectangularPackingBin binMeasures) {
+      int currentBin = position.AssignedBin;
+
+      int newWidth = position.Rotated ? newItem.Height : newItem.Width;
+      int newHeight = position.Rotated ? newItem.Width : newItem.Height;
+
+      //Find ExtremePoints beginning from sourcepointX
+      var sourcePointX = new TwoDimensionalPacking(currentBin, position.X + newWidth, position.Y);
+      if (sourcePointX.X < binMeasures.Width && sourcePointX.Y < binMeasures.Height) {
+        //Traversing down the y-axis                                                                            
+        int currentYValue = sourcePointX.Y;
+        while (currentYValue > 0 && occupiedPoints[currentBin][sourcePointX.X, currentYValue] == -1) {
+          currentYValue--;
+        }
+        extremePoints.Add(new TwoDimensionalPacking(currentBin, sourcePointX.X, currentYValue));
+      }
+
+
+
+
+      //Find ExtremePoints beginning from sourcepointY
+      var sourcePointY = new TwoDimensionalPacking(currentBin, position.X, position.Y + newItem.Height);
+      if (sourcePointY.X < binMeasures.Width && sourcePointY.Y < binMeasures.Height) {
+        //Traversing down the x-axis  
+        int currentXValue = sourcePointY.X;
+        while (currentXValue > 0 && occupiedPoints[currentBin][currentXValue - 1, sourcePointY.Y] == -1) {
+          currentXValue--;
+        }
+        extremePoints.Add(new TwoDimensionalPacking(currentBin, currentXValue, sourcePointY.Y));
+      }
+
+
+      return extremePoints;
+    }
+    private static int ShortestPossibleSideFromEP(TwoDimensionalPacking ep, List<int[,]> occupiedPoints, RectangularPackingBin binMeasures) {
+      int shortestSide = int.MaxValue;
+
+      if (ep.X >= binMeasures.Width || ep.Y >= binMeasures.Height)
+        return shortestSide;
+
+      int currentX = ep.X;
+      while (currentX < binMeasures.Width && occupiedPoints[ep.AssignedBin][currentX, ep.Y] == -1) { currentX++; }   
+      if (currentX - ep.X < shortestSide)
+        shortestSide = currentX - ep.X;
+
+      int currentY = ep.Y;
+      while (currentY < binMeasures.Height && occupiedPoints[ep.AssignedBin][ep.X, currentY] == -1) { currentY++;  }
+      if (currentY - ep.Y < shortestSide)
+        shortestSide = currentY - ep.Y;
+
+      return shortestSide;
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftFunctions.cs	(revision 9440)
@@ -0,0 +1,143 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Collections;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+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 DeepestBottomLeftFunctions {
+
+    public static ObservableDictionary<int, ThreeDimensionalPacking> DeepestLeftBottomPacking(GroupingVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> 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, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
+      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];
+          ThreeDimensionalPacking position = null;
+
+          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures);
+
+          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];
+          ThreeDimensionalPacking position = null;
+
+          //Look for space in current bin
+          position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(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 ThreeDimensionalPacking DeepestLeftBottomPosition(CuboidPackingBin binMeasures, int binNr, CuboidPackingItem currentItem, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures) {
+      return DeepestLeftBottomPosition(binMeasures, binNr, currentItem, itemPositions, itemMeasures, false);
+    }
+    public static ThreeDimensionalPacking DeepestLeftBottomPosition(CuboidPackingBin binMeasures, int binNr, CuboidPackingItem currentItem, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures, bool rotated) {
+      //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
+      ThreeDimensionalPacking currentPosition = new ThreeDimensionalPacking(binNr, 
+        binMeasures.Width - (rotated ? currentItem.Depth : currentItem.Width), 
+        binMeasures.Height - currentItem.Height, 
+        binMeasures.Depth - (rotated ? currentItem.Width : currentItem.Depth), rotated);
+      //Slide the item as far as possible to the bottom
+      while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)
+        || IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
+        || IsPositionFeasible(binMeasures, binNr, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
+        //Slide the item as far as possible to the left
+          while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
+          || IsPositionFeasible(binMeasures, binNr, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
+          //Slide the item as far as possible to the back
+            while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
+            currentPosition = MoveBack(currentPosition);
+          }
+            if (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures))
+            currentPosition = MoveLeft(currentPosition);
+        }
+          if (IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures))
+          currentPosition = MoveDown(currentPosition);
+      }
+
+      return IsPositionFeasible(binMeasures, binNr, currentItem, currentPosition, itemPositions, itemMeasures) ? currentPosition : null;
+    }
+
+    public static bool IsPositionFeasible(CuboidPackingBin binMeasures, int binNr, CuboidPackingItem currentItem,
+      ThreeDimensionalPacking currentPosition, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures) {
+      //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the item does not collide with another already packed item
+      if (!binMeasures.Encloses(currentPosition, currentItem))
+        return false;
+
+      var itemsWithPositions = itemMeasures.
+        Select((Value, Index) => new { Value, Index }).
+        Where(s => itemPositions.ContainsKey(s.Index)).
+        Select((s) => new { Measures = itemMeasures[s.Index], Position = itemPositions[s.Index] });
+
+      foreach (var itemWithPosition in itemsWithPositions) {
+        if (itemWithPosition.Position.AssignedBin == binNr && itemWithPosition.Measures.Overlaps(itemWithPosition.Position, currentPosition, currentItem))
+          return false;
+      }
+
+      return true;
+    }
+
+    private static ThreeDimensionalPacking MoveLeft(ThreeDimensionalPacking original) {
+      return new ThreeDimensionalPacking(original.AssignedBin, original.X - 1, original.Y, original.Z, original.Rotated);
+    }
+    private static ThreeDimensionalPacking MoveDown(ThreeDimensionalPacking original) {
+      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y - 1, original.Z, original.Rotated);
+    }
+    private static ThreeDimensionalPacking MoveBack(ThreeDimensionalPacking original) {
+      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y, original.Z - 1, original.Rotated);
+    }
+
+
+  
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftGroupingVectorDecoder.cs	(revision 9440)
@@ -0,0 +1,81 @@
+﻿#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.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin three dimensional direct grouping vector decoder", "<Description missing...>")]
+  [StorableClass]
+  public class DeepestBottomLeftGroupingVectorDecoder : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public DeepestBottomLeftGroupingVectorDecoder()
+      : base() {
+        //EncodedSolutionParameter.ActualName = "EncodedSolution";
+    }
+    [StorableConstructor]
+    protected DeepestBottomLeftGroupingVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected DeepestBottomLeftGroupingVectorDecoder(DeepestBottomLeftGroupingVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DeepestBottomLeftGroupingVectorDecoder(this, cloner);
+    }
+
+
+    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
+
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(
+        PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+
+      ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = DeepestBottomLeftFunctions.DeepestLeftBottomPacking(
+        solution, 
+        PackingBinMeasuresParameter.ActualValue, 
+        PackingItemMeasuresParameter.ActualValue);
+
+
+      result.PackingItemPositions = packingPositions;
+
+      return result;
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs	(revision 9440)
@@ -0,0 +1,139 @@
+﻿#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.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin three dimensional multi component vector decoder", "<Description missing...>")]
+  [StorableClass]
+  public class DeepestBottomLeftMultiComponentVectorDecoder : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public DeepestBottomLeftMultiComponentVectorDecoder()
+      : base() {
+        //EncodedSolutionParameter.ActualName = "EncodedSolution";
+    }
+    [StorableConstructor]
+    protected DeepestBottomLeftMultiComponentVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected DeepestBottomLeftMultiComponentVectorDecoder(DeepestBottomLeftMultiComponentVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DeepestBottomLeftMultiComponentVectorDecoder(this, cloner);
+    }
+
+
+    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponent Vector");
+
+      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;
+
+      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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftPackingSequenceDecoder.cs	(revision 9440)
@@ -0,0 +1,98 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, three dimensional, direct permutation decoder", "<Description missing...>")]
+  [StorableClass]
+  public class DeepestBottomLeftPackingSequenceDecoder : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public DeepestBottomLeftPackingSequenceDecoder()
+      : base() {
+        //EncodedSolutionParameter.ActualName = "EncodedSolution";
+    }
+    [StorableConstructor]
+    protected DeepestBottomLeftPackingSequenceDecoder(bool deserializing) : base(deserializing) { }
+    protected DeepestBottomLeftPackingSequenceDecoder(DeepestBottomLeftPackingSequenceDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DeepestBottomLeftPackingSequenceDecoder(this, cloner);
+    }
+
+
+    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as PackingSequenceEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = 
+        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;
+
+      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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointGroupingVectorDecoder3D.cs	(revision 9440)
@@ -0,0 +1,78 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, three dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointGroupingVectorDecoder3D : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public ExtremePointGroupingVectorDecoder3D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ExtremePointGroupingVectorDecoder3D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointGroupingVectorDecoder3D(ExtremePointGroupingVectorDecoder3D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointGroupingVectorDecoder3D(this, cloner);
+    }
+
+    public static PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Decode(GroupingVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result =
+        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures, itemMeasures);
+
+      result.PackingItemPositions = ExtremePointsFunctions3D.ExtremePointBasedPacking(solution, itemMeasures, binMeasures);
+
+      return result;
+    }
+
+    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+                      
+      var solution = encodedSolution as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
+
+      return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointMultiComponentVectorDecoder3D.cs	(revision 9440)
@@ -0,0 +1,79 @@
+﻿#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 ExtremePointMultiComponentVectorDecoder3D : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public ExtremePointMultiComponentVectorDecoder3D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ExtremePointMultiComponentVectorDecoder3D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointMultiComponentVectorDecoder3D(ExtremePointMultiComponentVectorDecoder3D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointMultiComponentVectorDecoder3D(this, cloner);
+    }
+
+    public static PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Decode(MultiComponentVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) {
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result =
+        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(binMeasures, itemMeasures);
+
+      result.PackingItemPositions = ExtremePointsFunctions3D.ExtremePointBasedPacking(ref solution, itemMeasures, binMeasures);
+
+      return result;
+    }
+
+    protected override PackingPlan<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/3D/EP/ExtremePointPackingSequenceDecoder3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 9440)
@@ -0,0 +1,74 @@
+﻿#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;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, three dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointPackingSequenceDecoder3D : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public ExtremePointPackingSequenceDecoder3D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ExtremePointPackingSequenceDecoder3D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointPackingSequenceDecoder3D(ExtremePointPackingSequenceDecoder3D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointPackingSequenceDecoder3D(this, cloner);
+    }
+
+
+    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as PackingSequenceEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = 
+        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+
+      result.PackingItemPositions = ExtremePointsFunctions3D.ExtremePointBasedPacking(solution, PackingItemMeasuresParameter.ActualValue, PackingBinMeasuresParameter.ActualValue);
+
+      return result;
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointsFunctions3D.cs	(revision 9440)
@@ -0,0 +1,399 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+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;
+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 ExtremePointsFunctions3D {
+
+
+
+
+    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;
+
+      //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] = solution.PackingInformations
+          .Where(pi => pi.AssignedBin == i)
+          .ToList();
+
+        extremePointsForBin[i] = new HashSet<ThreeDimensionalPacking>();
+        extremePointsForBin[i].Add(new ThreeDimensionalPacking(i, 0, 0, 0, false));
+        occupiedPoints = 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].ItemIndex;
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = new HashSet<ThreeDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          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(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].ItemIndex;
+          var item = itemMeasures[itemIndex];
+
+          extremePointsForBin[binNr] = new HashSet<ThreeDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
+          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);
+            remainingItems.Remove(unpackedItems[i]);
+            if (binNr <= lowerBound) {
+              InsertItemgeneAfterLastItemgeneOfUsedBin(ref solution, itemIndex, binNr);
+            }
+          }
+        }
+        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 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);
+    }
+
+
+    public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(GroupingVectorEncoding solution,
+        ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) {
+
+      #region Preperations
+      int nrOfBins = solution.GroupingVector.Max() + 1;
+
+      //Get all indexes of items for every bin according to grouping-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[, ,]>();
+
+      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();
+
+        extremePointsForBin[i] = new HashSet<ThreeDimensionalPacking>();
+        extremePointsForBin[i].Add(new ThreeDimensionalPacking(i, 0, 0, 0, false));    
+        occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+      }
+
+      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] = new HashSet<ThreeDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, 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] = new HashSet<ThreeDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, 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);        
+            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;
+    }
+
+
+    public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(PackingSequenceEncoding solution, 
+        ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) {
+
+      #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
+
+      foreach (int itemIndex in solution.PackingSequence) {
+        var item = itemMeasures[itemIndex];
+        extremePoints = new HashSet<ThreeDimensionalPacking>(extremePoints.OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, 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);
+          nrOfBins++;
+        }
+        itemPositions[itemIndex] = positionFound;
+        occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+        extremePoints = GenerateNewExtremePointsForNewItem(extremePoints, occupiedPoints, item, positionFound, binMeasures);
+      }
+
+      return itemPositions;
+    }
+
+
+    private 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, 
+        HashSet<ThreeDimensionalPacking> extremePoints, List<int[,,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, bool rotated) {
+
+      var itemFromList = itemMeasures[itemIndex];
+      CuboidPackingItem item = new CuboidPackingItem(
+        rotated ? itemFromList.Depth : itemFromList.Width, 
+        itemFromList.Height, 
+        rotated ? itemFromList.Width : itemFromList.Depth, 
+        itemFromList.TargetBin);
+
+      int epIndex = 0;
+      while (epIndex < extremePoints.Count &&
+        (!DeepestBottomLeftFunctions.IsPositionFeasible(binMeasures, extremePoints.ElementAt(epIndex).AssignedBin, item, extremePoints.ElementAt(epIndex), itemPositions, itemMeasures) ||
+        !IsStaticStable(occupiedPoints[extremePoints.ElementAt(epIndex).AssignedBin], item, extremePoints.ElementAt(epIndex)))) 
+      { epIndex++; }
+
+      if (epIndex < extremePoints.Count) {
+        var result = extremePoints.ElementAt(epIndex);
+        result.Rotated = rotated;
+        return result;
+      } 
+      return null;
+    }
+    private static List<int[, ,]> IncreaseBinCountForOccupiedPoints(List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
+      occupiedPoints.Add(new int[binMeasures.Width, binMeasures.Height, binMeasures.Depth]);
+      int lastIndex = occupiedPoints.Count - 1;
+      for (int w = 0; w < binMeasures.Width; w++) {
+        for (int h = 0; h < binMeasures.Height; h++) {
+          for (int d = 0; d < binMeasures.Depth; d++) {
+            occupiedPoints[lastIndex][w, h, d] = -1;
+          }
+        }
+      }
+      return occupiedPoints;
+    }
+    private static bool IsStaticStable(int[, ,] occupiedPoints, CuboidPackingItem item, ThreeDimensionalPacking ep) {
+      //Static stability is given, if item is placed on the ground
+      if (ep.Y == 0)
+        return true;
+
+      if (occupiedPoints[ep.X, ep.Y - 1, ep.Z] != -1 
+        && occupiedPoints[ep.X + item.Width - 1, ep.Y - 1, ep.Z] != -1 
+        && occupiedPoints[ep.X, ep.Y - 1, ep.Z + item.Depth - 1] != -1 
+        && occupiedPoints[ep.X + item.Width - 1, ep.Y - 1, ep.Z + item.Depth - 1] != -1)
+        return true;
+
+      //int groundCount = 0;
+      //for (int x = ep.X; x < ep.X + item.Width - 1; x++) {
+      //  for (int z = ep.Z; z < ep.Z + item.Depth - 1; z++) {
+      //    if (occupiedPoints[x,ep.Y-1, z] != -1)                                                     
+      //      groundCount++;
+      //  }
+      //}
+      //double stableGround = (double)(groundCount) / (double)(item.Width * item.Depth);
+      //if (stableGround > 0.75)
+      //  return true;
+
+      return false;
+    }
+    private 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;
+      for (int w = position.X; w < position.X + width; w++) {
+        for (int h = position.Y; h < position.Y + newItem.Height; h++) {
+          for (int d = position.Z; d < position.Z + depth; d++) {
+            occupiedPoints[position.AssignedBin][w,h,d] = itemIndex;
+          }
+        }
+      }
+      return occupiedPoints;
+    }
+    private static HashSet<ThreeDimensionalPacking> GenerateNewExtremePointsForNewItem(HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, 
+        CuboidPackingItem newItem, ThreeDimensionalPacking position, CuboidPackingBin binMeasures) {
+      int currentBin = position.AssignedBin;
+
+      int newWidth = position.Rotated ? newItem.Depth : newItem.Width;
+      int newDepth = position.Rotated ? newItem.Width : newItem.Depth;
+
+      //Find ExtremePoints beginning from sourcepointX
+      var sourcePointX = new ThreeDimensionalPacking(currentBin, position.X + newWidth, position.Y, position.Z);
+      if (sourcePointX.X < binMeasures.Width && sourcePointX.Y < binMeasures.Height && sourcePointX.Z < binMeasures.Depth) {
+        //Traversing down the y-axis                                                                            
+        int currentYValue = sourcePointX.Y;
+        while (currentYValue > 0 && occupiedPoints[currentBin][sourcePointX.X, currentYValue, sourcePointX.Z] == -1) {
+          currentYValue--;
+        }
+        extremePoints.Add(new ThreeDimensionalPacking(currentBin, sourcePointX.X, currentYValue, sourcePointX.Z));
+
+        //Traversing down the z-axis
+        int currentZValue = sourcePointX.Z;
+        while (currentZValue > 0 && occupiedPoints[currentBin][sourcePointX.X, sourcePointX.Y, currentZValue - 1] == -1) {
+          currentZValue--;
+        }
+        extremePoints.Add(new ThreeDimensionalPacking(currentBin, sourcePointX.X, sourcePointX.Y, currentZValue));
+      }
+
+
+
+
+      //Find ExtremePoints beginning from sourcepointY
+      var sourcePointY = new ThreeDimensionalPacking(currentBin, position.X, position.Y + newItem.Height, position.Z);
+      if (sourcePointY.X < binMeasures.Width && sourcePointY.Y < binMeasures.Height && sourcePointY.Z < binMeasures.Depth) {
+        //Traversing down the x-axis  
+        int currentXValue = sourcePointY.X;
+        while (currentXValue > 0 && occupiedPoints[currentBin][currentXValue - 1, sourcePointY.Y, sourcePointY.Z] == -1) {
+          currentXValue--;
+        }
+        extremePoints.Add(new ThreeDimensionalPacking(currentBin, currentXValue, sourcePointY.Y, sourcePointY.Z));
+
+        //Traversing down the z-axis
+        int currentZValue = sourcePointY.Z;
+        while (currentZValue > 0 && occupiedPoints[currentBin][sourcePointY.X, sourcePointY.Y, currentZValue - 1] == -1) {
+          currentZValue--;
+        }
+        extremePoints.Add(new ThreeDimensionalPacking(currentBin, sourcePointY.X, sourcePointY.Y, currentZValue));
+      }
+
+
+
+
+
+      //Find ExtremePoints beginning from sourcepointZ
+      var sourcePointZ = new ThreeDimensionalPacking(currentBin, position.X, position.Y, position.Z + newDepth);
+      if (sourcePointZ.X < binMeasures.Width && sourcePointZ.Y < binMeasures.Height && sourcePointZ.Z < binMeasures.Depth) {
+        //Traversing down the x-axis  
+        int currentXValue = sourcePointZ.X;
+        while (currentXValue > 0 && occupiedPoints[currentBin][currentXValue - 1, sourcePointZ.Y, sourcePointZ.Z] == -1) {
+          currentXValue--;
+        }
+        extremePoints.Add(new ThreeDimensionalPacking(currentBin, currentXValue, sourcePointZ.Y, sourcePointZ.Z));
+
+        //Traversing down the y-axis                                                                            
+        int currentYValue = sourcePointZ.Y;
+        while (currentYValue > 0 && occupiedPoints[currentBin][sourcePointZ.X, currentYValue, sourcePointZ.Z] == -1) {
+          currentYValue--;
+        }
+        extremePoints.Add(new ThreeDimensionalPacking(currentBin, sourcePointZ.X, currentYValue, sourcePointZ.Z));
+      }
+
+
+      return extremePoints;
+    }
+    private static int ShortestPossibleSideFromEP(ThreeDimensionalPacking ep, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
+      int shortestSide = int.MaxValue;
+
+      if (ep.X >= binMeasures.Width || ep.Y >= binMeasures.Height || ep.Z >= binMeasures.Depth)
+        return shortestSide;
+
+      int currentX = ep.X;
+      while (currentX < binMeasures.Width && occupiedPoints[ep.AssignedBin][currentX, ep.Y, ep.Z] == -1) { currentX++; }   
+      if (currentX - ep.X < shortestSide)
+        shortestSide = currentX - ep.X;
+
+      int currentY = ep.Y;
+      while (currentY < binMeasures.Height && occupiedPoints[ep.AssignedBin][ep.X, currentY, ep.Z] == -1) { currentY++;  }
+      if (currentY - ep.Y < shortestSide)
+        shortestSide = currentY - ep.Y;
+
+      int currentZ = ep.Z;
+      while (currentZ < binMeasures.Depth && occupiedPoints[ep.AssignedBin][ep.X, ep.Y, currentZ] == -1) { currentZ++; }
+      if (currentZ - ep.Z < shortestSide)
+        shortestSide = currentZ - ep.Z;
+
+      return shortestSide;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/IB2DLowestGapFillGroupingVectorDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/IB2DLowestGapFillGroupingVectorDecoder.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/IB2DLowestGapFillGroupingVectorDecoder.cs	(revision 9440)
@@ -0,0 +1,160 @@
+﻿#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.Problems.BinPacking.Interfaces;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Lowest Gap Fill Grouping-Vector Decoder", "<Description missing...>")]
+  [StorableClass]
+  public class IB2DLowestGapFillGroupingVectorDecoder : IdenticalBinPackingSolutionDecoder<
+      TwoDimensionalPacking,
+      RectangularPackingBin,
+      RectangularPackingItem,
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
+
+    public IB2DLowestGapFillGroupingVectorDecoder()
+      : base() {
+        //EncodedSolutionParameter.ActualName = "EncodedSolution";
+    }
+    [StorableConstructor]
+    protected IB2DLowestGapFillGroupingVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected IB2DLowestGapFillGroupingVectorDecoder(IB2DLowestGapFillGroupingVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IB2DLowestGapFillGroupingVectorDecoder(this, cloner);
+    }
+
+
+    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as IntegerVector;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+
+      var binMeasures = PackingBinMeasuresParameter.ActualValue;
+      var itemMeasures = PackingItemMeasuresParameter.ActualValue;
+
+      ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
+
+      int nrOfBins = solution.Max();
+
+      //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
+          .Select((Value, Index) => new { Value, Index })
+          .Where (temp => temp.Value == i)
+          .Select (temp => temp.Index).ToList();  
+      }
+
+
+
+      //Steps 1-6
+      //2
+      int currentBin = 0;    
+      
+      //3
+      //Take the first position from the first bin
+      TwoDimensionalPacking currentPoint = new TwoDimensionalPacking(currentBin, 0, 0);
+   
+      //4
+      //Assuming that Height is always the shorter edge due to normalizing..
+      int currentGap = binMeasures.Height;
+
+      //5
+      //Take the first (and largest) item for the first bin
+      int currentItemIndex = unpackedItemIndexesPerBin[currentBin][0];
+      RectangularPackingItem currentItem = itemMeasures[currentItemIndex];
+      packingPositions[currentItemIndex] = currentPoint;
+      //6
+      unpackedItemIndexesPerBin[currentBin].RemoveAt(0);
+
+
+      //Steps 7-13          
+
+      //TODO: the first parameter (bin-list) is not finished yet.. it should resemble the used bins in the packing plan..
+      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result =
+        new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(
+          binMeasures, 
+          itemMeasures);
+
+      result.PackingItemPositions = packingPositions;
+      return result;
+    }
+
+    //protected override TwoDimensionalPacking FindFeasiblePositionForItem(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
+    //  //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
+    //  TwoDimensionalPacking currentPosition = new TwoDimensionalPacking(binNr, binMeasures.Width - currentItem.Width, binMeasures.Height - currentItem.Height);           
+    //  //Slide the item as far as possible to the bottom
+    //  while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)) {
+    //    currentPosition = MoveDown(currentPosition);
+    //  }
+    //  //Slide the item as far as possible to the left
+    //  while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)) {
+    //    currentPosition = MoveLeft(currentPosition);
+    //  }
+
+    //  return IsPositionFeasible(binMeasures, binNr, currentItem, currentPosition, itemPositions, itemMeasures) ? currentPosition : null;
+    //}
+
+    //private bool IsPositionFeasible(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem,
+    //  TwoDimensionalPacking currentPosition, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
+    //  //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the item does not collide with another already packed item
+    //  if (!binMeasures.Encloses(currentPosition, currentItem))
+    //    return false;
+    //  var itemsWithPositions = itemMeasures.
+    //    Select((Value, Index) => new { Value, Index }).
+    //    Where(s => itemPositions.ContainsKey(s.Index)).
+    //    Select((s) => new { Measures = itemMeasures[s.Index], Position = itemPositions[s.Index]});
+
+    //  foreach (var itemWithPosition in itemsWithPositions) {
+    //    if (itemWithPosition.Position.AssignedBin == binNr && itemWithPosition.Measures.Overlaps(itemWithPosition.Position, currentPosition, currentItem))
+    //      return false;
+    //  }
+    //  return true;
+    //}
+
+    //private TwoDimensionalPacking MoveLeft(TwoDimensionalPacking original) {
+    //  return new TwoDimensionalPacking(original.AssignedBin, original.X - 1, original.Y);
+    //}
+    //private TwoDimensionalPacking MoveDown(TwoDimensionalPacking original) {
+    //  return new TwoDimensionalPacking(original.AssignedBin, original.X, original.Y - 1);
+    //}
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/IdenticalBinPackingSolutionDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/IdenticalBinPackingSolutionDecoder.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/IdenticalBinPackingSolutionDecoder.cs	(revision 9440)
@@ -31,5 +31,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Problems.BinPacking.Shapes;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Data;
 using HeuristicLab.Collections;
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/PackingHeuristics.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/PackingHeuristics.cs	(revision 9439)
+++ 	(revision )
@@ -1,114 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.Collections;
-using HeuristicLab.Core;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-
-namespace HeuristicLab.Problems.BinPacking.Decoders {
-  public static class PackingHeuristics {
-    public static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
-      //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
-      TwoDimensionalPacking currentPosition = new TwoDimensionalPacking(binNr, binMeasures.Width - currentItem.Width, binMeasures.Height - currentItem.Height);
-      //Slide the item as far as possible to the left
-      while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
-        || IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)) {
-        //Slide the item as far as possible to the bottom
-        while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)) {
-          currentPosition = MoveDown(currentPosition);
-        }
-        if (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures))
-          currentPosition = MoveLeft(currentPosition);
-      }
-
-      return IsPositionFeasible(binMeasures, binNr, currentItem, currentPosition, itemPositions, itemMeasures) ? currentPosition : null;
-    }
-
-    private static bool IsPositionFeasible(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem,
-      TwoDimensionalPacking currentPosition, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) {
-      //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the item does not collide with another already packed item
-      if (!binMeasures.Encloses(currentPosition, currentItem))
-        return false;
-      var itemsWithPositions = itemMeasures.
-        Select((Value, Index) => new { Value, Index }).
-        Where(s => itemPositions.ContainsKey(s.Index)).
-        Select((s) => new { Measures = itemMeasures[s.Index], Position = itemPositions[s.Index] });
-
-      foreach (var itemWithPosition in itemsWithPositions) {
-        if (itemWithPosition.Position.AssignedBin == binNr && itemWithPosition.Measures.Overlaps(itemWithPosition.Position, currentPosition, currentItem))
-          return false;
-      }
-
-      return true;
-    }
-
-    private static TwoDimensionalPacking MoveLeft(TwoDimensionalPacking original) {
-      return new TwoDimensionalPacking(original.AssignedBin, original.X - 1, original.Y);
-    }
-    private static TwoDimensionalPacking MoveDown(TwoDimensionalPacking original) {
-      return new TwoDimensionalPacking(original.AssignedBin, original.X, original.Y - 1);
-    }
-
-
-
-
-
-
-    public static ThreeDimensionalPacking DeepestLeftBottomPosition(CuboidPackingBin binMeasures, int binNr, CuboidPackingItem currentItem, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures) {
-      //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
-      ThreeDimensionalPacking currentPosition = new ThreeDimensionalPacking(binNr, binMeasures.Width - currentItem.Width, binMeasures.Height - currentItem.Height, binMeasures.Depth - currentItem.Depth);
-
-      //Slide the item as far as possible to the bottom
-      while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures)
-        || IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
-        || IsPositionFeasible(binMeasures, binNr, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
-        //Slide the item as far as possible to the left
-        while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures)
-          || IsPositionFeasible(binMeasures, binNr, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
-          //Slide the item as far as possible to the back
-          while (IsPositionFeasible(binMeasures, binNr, currentItem, MoveBack(currentPosition), itemPositions, itemMeasures)) {
-            currentPosition = MoveBack(currentPosition);
-          }
-          if (IsPositionFeasible(binMeasures, binNr, currentItem, MoveLeft(currentPosition), itemPositions, itemMeasures))
-            currentPosition = MoveLeft(currentPosition);
-        }
-        if (IsPositionFeasible(binMeasures, binNr, currentItem, MoveDown(currentPosition), itemPositions, itemMeasures))
-          currentPosition = MoveDown(currentPosition);
-      }
-
-      return IsPositionFeasible(binMeasures, binNr, currentItem, currentPosition, itemPositions, itemMeasures) ? currentPosition : null;
-    }
-
-    private static bool IsPositionFeasible(CuboidPackingBin binMeasures, int binNr, CuboidPackingItem currentItem,
-      ThreeDimensionalPacking currentPosition, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures) {
-      //In this case feasability is defined as following: 1. the item fits into the bin-borders; 2. the item does not collide with another already packed item
-      if (!binMeasures.Encloses(currentPosition, currentItem))
-        return false;
-
-      var itemsWithPositions = itemMeasures.
-        Select((Value, Index) => new { Value, Index }).
-        Where(s => itemPositions.ContainsKey(s.Index)).
-        Select((s) => new { Measures = itemMeasures[s.Index], Position = itemPositions[s.Index] });
-
-      foreach (var itemWithPosition in itemsWithPositions) {
-        if (itemWithPosition.Position.AssignedBin == binNr && itemWithPosition.Measures.Overlaps(itemWithPosition.Position, currentPosition, currentItem))
-          return false;
-      }
-
-      return true;
-    }
-
-    private static ThreeDimensionalPacking MoveLeft(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X - 1, original.Y, original.Z);
-    }
-    private static ThreeDimensionalPacking MoveDown(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y - 1, original.Z);
-    }
-    private static ThreeDimensionalPacking MoveBack(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y, original.Z - 1);
-    }
-  }
-}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/ThreeDimensionalBottomLeftGroupingVectorDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/ThreeDimensionalBottomLeftGroupingVectorDecoder.cs	(revision 9439)
+++ 	(revision )
@@ -1,130 +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 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.Problems.BinPacking.PackingPlans;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Collections;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
-
-namespace HeuristicLab.Problems.BinPacking.Decoders {
-  [Item("Identical bin three dimensional direct grouping vector decoder", "<Description missing...>")]
-  [StorableClass]
-  public class ThreeDimensionalBottomLeftGroupingVectorDecoder : IdenticalBinPackingSolutionDecoder<
-      ThreeDimensionalPacking,
-      CuboidPackingBin,
-      CuboidPackingItem,
-      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
-
-    public ThreeDimensionalBottomLeftGroupingVectorDecoder()
-      : base() {
-        //EncodedSolutionParameter.ActualName = "EncodedSolution";
-    }
-    [StorableConstructor]
-    protected ThreeDimensionalBottomLeftGroupingVectorDecoder(bool deserializing) : base(deserializing) { }
-    protected ThreeDimensionalBottomLeftGroupingVectorDecoder(ThreeDimensionalBottomLeftGroupingVectorDecoder original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ThreeDimensionalBottomLeftGroupingVectorDecoder(this, cloner);
-    }
-
-
-    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
-
-      var solution = encodedSolution as GroupingVectorEncoding;
-      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
-
-      RegularSimpleRotationPackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = new RegularSimpleRotationPackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(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, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
-      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];
-          ThreeDimensionalPacking position = null;
-
-          position = PackingHeuristics.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue);
-
-          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 = PackingItemMeasuresParameter.ActualValue[itemIndex];
-          ThreeDimensionalPacking position = null;
-
-          //Look for space in current bin
-          position = PackingHeuristics.DeepestLeftBottomPosition(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;
-
-      return result;
-    }
-  }
-}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/ThreeDimensionalBottomLeftPackingSequenceDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/ThreeDimensionalBottomLeftPackingSequenceDecoder.cs	(revision 9439)
+++ 	(revision )
@@ -1,97 +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 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.Problems.BinPacking.PackingPlans;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Collections;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-
-namespace HeuristicLab.Problems.BinPacking.Decoders {
-  [Item("Identical bin, three dimensional, direct permutation decoder", "<Description missing...>")]
-  [StorableClass]
-  public class ThreeDimensionalBottomLeftPackingSequenceDecoder : IdenticalBinPackingSolutionDecoder<
-      ThreeDimensionalPacking,
-      CuboidPackingBin,
-      CuboidPackingItem,
-      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
-
-    public ThreeDimensionalBottomLeftPackingSequenceDecoder()
-      : base() {
-        //EncodedSolutionParameter.ActualName = "EncodedSolution";
-    }
-    [StorableConstructor]
-    protected ThreeDimensionalBottomLeftPackingSequenceDecoder(bool deserializing) : base(deserializing) { }
-    protected ThreeDimensionalBottomLeftPackingSequenceDecoder(ThreeDimensionalBottomLeftPackingSequenceDecoder original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ThreeDimensionalBottomLeftPackingSequenceDecoder(this, cloner);
-    }
-
-
-    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
-
-      var solution = encodedSolution as PackingSequenceEncoding;
-      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
-
-      RegularSimpleRotationPackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = new RegularSimpleRotationPackingPlan<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 = PackingHeuristics.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 = PackingHeuristics.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;
-
-      return result;
-    }
-  }
-}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/TwoDimensionalBottomLeftGroupingVectorDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/TwoDimensionalBottomLeftGroupingVectorDecoder.cs	(revision 9439)
+++ 	(revision )
@@ -1,146 +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 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.Problems.BinPacking.PackingPlans;
-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;
-
-namespace HeuristicLab.Problems.BinPacking.Decoders {
-  [Item("Identical bin two dimensional grouping vector decoder", "<Description missing...>")]
-  [StorableClass]
-  public class TwoDimensionalBottomLeftGroupingVectorDecoder : IdenticalBinPackingSolutionDecoder<
-      TwoDimensionalPacking,
-      RectangularPackingBin,
-      RectangularPackingItem,
-      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
-
-    public TwoDimensionalBottomLeftGroupingVectorDecoder()
-      : base() {
-        //EncodedSolutionParameter.ActualName = "EncodedSolution";
-    }
-    [StorableConstructor]
-    protected TwoDimensionalBottomLeftGroupingVectorDecoder(bool deserializing) : base(deserializing) { }
-    protected TwoDimensionalBottomLeftGroupingVectorDecoder(TwoDimensionalBottomLeftGroupingVectorDecoder original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new TwoDimensionalBottomLeftGroupingVectorDecoder(this, cloner);
-    }
-
-
-    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
-
-      var solution = encodedSolution as GroupingVectorEncoding;
-      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
-
-      RegularSimpleRotationPackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = 
-        new RegularSimpleRotationPackingPlan<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 = PackingHeuristics.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 = PackingHeuristics.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;
-
-
-      return result;
-    }
-  }
-}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/TwoDimensionalBottomLeftPackingSequenceDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/TwoDimensionalBottomLeftPackingSequenceDecoder.cs	(revision 9439)
+++ 	(revision )
@@ -1,99 +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 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.Problems.BinPacking.PackingPlans;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Collections;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-
-namespace HeuristicLab.Problems.BinPacking.Decoders {
-  [Item("Identical bin, two dimensional, direct permutation decoder", "<Description missing...>")]
-  [StorableClass]
-  public class TwoDimensionalBottomLeftPackingSequenceDecoder : IdenticalBinPackingSolutionDecoder<
-      TwoDimensionalPacking,
-      RectangularPackingBin,
-      RectangularPackingItem,
-      PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> {
-
-    public TwoDimensionalBottomLeftPackingSequenceDecoder()
-      : base() {
-        //EncodedSolutionParameter.ActualName = "EncodedSolution";
-    }
-    [StorableConstructor]
-    protected TwoDimensionalBottomLeftPackingSequenceDecoder(bool deserializing) : base(deserializing) { }
-    protected TwoDimensionalBottomLeftPackingSequenceDecoder(TwoDimensionalBottomLeftPackingSequenceDecoder original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new TwoDimensionalBottomLeftPackingSequenceDecoder(this, cloner);
-    }
-
-
-    protected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
-
-      var solution = encodedSolution as PackingSequenceEncoding;
-      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
-
-      RegularSimpleRotationPackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = 
-        new RegularSimpleRotationPackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
-
-      ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>();
-      int nrOfBins = 1;
-      //foreach (RectangularPackingItem item in PackingItemMeasuresParameter.ActualValue) {   
-      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 = PackingHeuristics.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 = PackingHeuristics.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;
-
-      return result;
-    }
-  }
-}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/PackingDimensions.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/PackingDimensions.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/PackingDimensions.cs	(revision 9440)
@@ -37,4 +37,8 @@
     /// </summary>
     public Int32 AssignedBin { get; set; }
+    /// <summary>
+    /// Determins if the positioned item is to be rotate by 90 degrees or not.
+    /// </summary>
+    public Boolean Rotated { get; set; }
 
     [StorableConstructor]
@@ -43,8 +47,10 @@
       : base(original, cloner) {
         AssignedBin = original.AssignedBin;
+        Rotated = original.Rotated;
     }
 
-    public PackingDimensions(Int32 assignedBin) {
+    public PackingDimensions(Int32 assignedBin, Boolean rotated) {
       this.AssignedBin = assignedBin;
+      this.Rotated = rotated;
     }
 
@@ -52,9 +58,20 @@
       StringBuilder sb = new StringBuilder();
       sb.Append("[");
-      sb.Append("AssignedBin: ");
-      sb.Append(AssignedBin);
+      sb.Append(AssignedBin + "-");
+      sb.Append(Rotated);
       sb.Append("]");
       return sb.ToString();
     }
+
+    public override bool Equals(object obj) {
+      var pd = obj as PackingDimensions;
+      if (pd != null)
+        return (pd.AssignedBin == this.AssignedBin && pd.Rotated == this.Rotated);
+      else return false;
+    }
+
+    public override int GetHashCode() {
+      return 31 * AssignedBin * (Rotated ? 3 : 7);
+    }
   }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/ThreeDimensionalPacking.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/ThreeDimensionalPacking.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/ThreeDimensionalPacking.cs	(revision 9440)
@@ -49,5 +49,7 @@
     }
 
-    public ThreeDimensionalPacking(int assignedBin, int x, int y, int z) : base(assignedBin) {
+    public ThreeDimensionalPacking(int assignedBin, int x, int y, int z) : this(assignedBin, x, y, z, false) {}
+    public ThreeDimensionalPacking(int assignedBin, int x, int y, int z, bool rotated)
+      : base(assignedBin, rotated) {
       this.X = x;
       this.Y = y;
@@ -67,4 +69,16 @@
       return sb.ToString();
     }
+
+
+    public override bool Equals(object obj) {
+      var tdp = obj as ThreeDimensionalPacking;
+      if (tdp != null)
+        return (tdp.X == this.X && tdp.Y == this.Y && tdp.Z == this.Z);
+      else return false;
+    }
+
+    public override int GetHashCode() {
+      return base.GetHashCode() + 13 * X + 17 * Y + 23 * Z;
+    }
   }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/TwoDimensionalPacking.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/TwoDimensionalPacking.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/TwoDimensionalPacking.cs	(revision 9440)
@@ -45,7 +45,9 @@
     public override IDeepCloneable Clone(Cloner cloner) {
       return new TwoDimensionalPacking(this, cloner);
-    }   
+    }
 
-    public TwoDimensionalPacking(int assignedBin, int x, int y) : base(assignedBin) {
+    public TwoDimensionalPacking(int assignedBin, int x, int y) : this(assignedBin, x, y, false) { }
+    public TwoDimensionalPacking(int assignedBin, int x, int y, bool rotated)
+      : base(assignedBin, rotated) {
       this.X = x;
       this.Y = y;
@@ -63,4 +65,16 @@
       return sb.ToString();
     }
+
+
+    public override bool Equals(object obj) {
+      var tdp = obj as TwoDimensionalPacking;
+      if (tdp != null)
+        return (tdp.X == this.X && tdp.Y == this.Y);
+      else return false;
+    }
+
+    public override int GetHashCode() {
+      return base.GetHashCode() + 13 * X + 17 * Y;
+    }
   }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorRandomCreator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorRandomCreator.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/GroupingVectorRandomCreator.cs	(revision 9440)
@@ -64,5 +64,5 @@
 		public static GroupingVectorEncoding Apply(int items, int lowerBound, IRandom random) {
 			var solution = new GroupingVectorEncoding();
-			solution.GroupingVector = new IntegerVector(items, random, 0, lowerBound);
+			solution.GroupingVector = new IntegerVector(items, random, 0, lowerBound + 1);
 			return solution;
 		}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/ExhaustiveSingleGroupingMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/ExhaustiveSingleGroupingMoveGenerator.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/ExhaustiveSingleGroupingMoveGenerator.cs	(revision 9440)
@@ -0,0 +1,71 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Exhaustive Single Grouping Move Generator", "Generates all possible single grouping moves from a given groupingVector.")]
+  [StorableClass]
+  public class ExhaustiveSingleGroupingMoveGenerator : SingleGroupingMoveGenerator, IExhaustiveMoveGenerator {
+    [StorableConstructor]
+    protected ExhaustiveSingleGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ExhaustiveSingleGroupingMoveGenerator(ExhaustiveSingleGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveSingleGroupingMoveGenerator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveSingleGroupingMoveGenerator(this, cloner);
+    }
+
+    public static IEnumerable<SingleGroupingMove> Generate(GroupingVectorEncoding groupingVector, int nrOfBins) {
+      for (int i = 0; i < groupingVector.GroupingVector.Length; i++)
+        for (int j = 0; j < nrOfBins; j++) {
+          if (j != groupingVector.GroupingVector[i])
+            yield return new SingleGroupingMove(i, j, groupingVector);
+        }
+    }
+
+    public static SingleGroupingMove[] Apply(GroupingVectorEncoding groupingVector) {
+      int nrOfBins = 0;
+      foreach (int binNr in groupingVector.GroupingVector) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+
+      int totalMoves = (groupingVector.GroupingVector.Length) * (nrOfBins - 1);
+      SingleGroupingMove[] moves = new SingleGroupingMove[totalMoves];
+      int count = 0;
+      foreach (SingleGroupingMove move in Generate(groupingVector, nrOfBins)) {
+        moves[count++] = move;
+      }
+      return moves;
+    }
+
+    protected override SingleGroupingMove[] GenerateMoves(GroupingVectorEncoding groupingVector) {
+      return Apply(groupingVector);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/ExhaustiveTargetBinSingleGroupingMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/ExhaustiveTargetBinSingleGroupingMoveGenerator.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/ExhaustiveTargetBinSingleGroupingMoveGenerator.cs	(revision 9440)
@@ -0,0 +1,75 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Exhaustive Target Bin Single Grouping Move Generator", "Generates all possible single grouping moves for a specified target bin from a given groupingVector.")]
+  [StorableClass]
+  public class ExhaustiveTargetBinSingleGroupingMoveGenerator : SingleGroupingMoveGenerator, IExhaustiveMoveGenerator {
+    [StorableConstructor]
+    protected ExhaustiveTargetBinSingleGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ExhaustiveTargetBinSingleGroupingMoveGenerator(ExhaustiveTargetBinSingleGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveTargetBinSingleGroupingMoveGenerator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveTargetBinSingleGroupingMoveGenerator(this, cloner);
+    }
+
+    private static IEnumerable<SingleGroupingMove> Generate(GroupingVectorEncoding groupingVector, int lastBinNr, List<int> indexesOfItemsInLastBin) {
+      for (int i = 0; i < indexesOfItemsInLastBin.Count; i++)
+        for (int j = 0; j < lastBinNr; j++) {
+          yield return new SingleGroupingMove(i, j, groupingVector);
+        }
+    }
+
+    public static SingleGroupingMove[] Apply(GroupingVectorEncoding groupingVector) {
+      int lastBinNr = 0;
+      foreach (int binNr in groupingVector.GroupingVector) {
+        if (binNr > lastBinNr)
+          lastBinNr = binNr;
+      }
+      int nrOfBins = lastBinNr + 1;
+      List<int> indexesOfItemsInLastBin = new List<int>();
+      for (int i = 0; i < groupingVector.GroupingVector.Length; i++ ) {
+        if (groupingVector.GroupingVector[i] == lastBinNr)
+          indexesOfItemsInLastBin.Add(i);
+      }
+
+      int totalMoves = indexesOfItemsInLastBin.Count * (nrOfBins - 1);
+      SingleGroupingMove[] moves = new SingleGroupingMove[totalMoves];
+      int count = 0;
+      foreach (SingleGroupingMove move in Generate(groupingVector, lastBinNr, indexesOfItemsInLastBin)) {
+        moves[count++] = move;
+      }
+      return moves;
+    }
+
+    protected override SingleGroupingMove[] GenerateMoves(GroupingVectorEncoding groupingVector) {
+      return Apply(groupingVector);
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMove.cs	(revision 9440)
@@ -0,0 +1,56 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Single Grouping Move", "A move on a grouping vector that is specified by a single group-assignment-index.")]
+  [StorableClass]
+  public class SingleGroupingMove : Item {
+    [Storable]
+    public int Index { get; protected set; }
+    [Storable]
+    public int NewGroup { get; protected set; }
+    [Storable]
+    public GroupingVectorEncoding GroupingVector { get; protected set; }
+
+    [StorableConstructor]
+    protected SingleGroupingMove(bool deserializing) : base(deserializing) { }
+    protected SingleGroupingMove(SingleGroupingMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index = original.Index;
+      this.NewGroup = original.NewGroup;
+      if (original.GroupingVector != null)
+        this.GroupingVector = cloner.Clone(original.GroupingVector);
+    }
+    public SingleGroupingMove(int index, int newGroup, GroupingVectorEncoding groupingVector)
+      : base() {
+      Index = index;
+      GroupingVector = groupingVector;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleGroupingMove(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveAttribute.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveAttribute.cs	(revision 9440)
@@ -0,0 +1,57 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("SingleGroupingMoveAttribute", "Specifies the tabu attributes for a single grouping move on a grouping vector.")]
+  [StorableClass]
+  public class SingleGroupingMoveAttribute : Item {
+    [Storable]
+    public int ItemIndex { get; protected set; }
+    [Storable]
+    public int AssignedBin { get; protected set; }
+    [Storable]
+    public double MoveQuality { get; protected set; }
+
+    [StorableConstructor]
+    protected SingleGroupingMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected SingleGroupingMoveAttribute(SingleGroupingMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.ItemIndex = original.ItemIndex;
+      this.AssignedBin = original.AssignedBin;
+      this.MoveQuality = original.MoveQuality;
+    }
+    public SingleGroupingMoveAttribute() : this(-1, -1, -1) { }
+    public SingleGroupingMoveAttribute(int itemIndex, int assignedBin, double moveQuality)
+      : base() {
+      ItemIndex = itemIndex;
+      AssignedBin = assignedBin;
+      MoveQuality = moveQuality;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleGroupingMoveAttribute(this, cloner);
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveGenerator.cs	(revision 9440)
@@ -0,0 +1,71 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Single Grouping Move Generator", "Base class for all single grouping move generators.")]
+  [StorableClass]
+  public abstract class SingleGroupingMoveGenerator : SingleSuccessorOperator, IGroupingVectorMoveOperator, IMoveGenerator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+    public ILookupParameter<SingleGroupingMove> SingleGroupingMoveParameter {
+      get { return (LookupParameter<SingleGroupingMove>)Parameters["SingleGroupingMove"]; }
+    }
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    [StorableConstructor]
+    protected SingleGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected SingleGroupingMoveGenerator(SingleGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public SingleGroupingMoveGenerator()
+      : 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 ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
+    }
+
+    public override IOperation Apply() {
+      GroupingVectorEncoding gv = GroupingVectorParameter.ActualValue;
+      SingleGroupingMove[] moves = GenerateMoves(gv);
+      Scope[] moveScopes = new Scope[moves.Length];
+      for (int i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        moveScopes[i].Variables.Add(new Variable(SingleGroupingMoveParameter.ActualName, moves[i]));
+      }
+      CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
+      return base.Apply();
+    }
+
+    protected abstract SingleGroupingMove[] GenerateMoves(GroupingVectorEncoding groupingVector);
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveHardTabuCriterion.cs	(revision 9440)
@@ -0,0 +1,110 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("SingleGroupingMoveHardTabuCriterion", "<Missing>")]
+  [StorableClass]
+  public class SingleGroupingMoveHardTabuCriterion : SingleSuccessorOperator, IGroupingVectorMoveOperator, ITabuChecker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<SingleGroupingMove> SingleGroupingMoveParameter {
+      get { return (ILookupParameter<SingleGroupingMove>)Parameters["SingleGroupingMove"]; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+    public ILookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (ILookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MoveTabu"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ValueParameter<BoolValue> UseAspirationCriterionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseAspirationCriterion"]; }
+    }
+
+    [StorableConstructor]
+    protected SingleGroupingMoveHardTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected SingleGroupingMoveHardTabuCriterion(SingleGroupingMoveHardTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public SingleGroupingMoveHardTabuCriterion()
+      : base() {
+      Parameters.Add(new LookupParameter<SingleGroupingMove>("SingleGroupingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution to evaluate."));
+      Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the current move."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseAspirationCriterion", "Whether to use the aspiration criterion or not.", new BoolValue(true)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleGroupingMoveHardTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      SingleGroupingMove move = SingleGroupingMoveParameter.ActualValue;
+      GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue;
+      int length = groupingVector.GroupingVector.Length;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool maximization = MaximizationParameter.ActualValue.Value;   
+      bool useAspiration = UseAspirationCriterionParameter.Value.Value;
+      bool isTabu = IsMoveTabu(tabuList, move, groupingVector, moveQuality, maximization, useAspiration);
+
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+
+    private bool IsMoveTabu(ItemList<IItem> tabuList, SingleGroupingMove move, GroupingVectorEncoding groupingVector, double moveQuality, bool maximization, bool useAspiration) {
+      var movedGroupingVector = new IntegerVector(groupingVector.GroupingVector);
+      movedGroupingVector[move.Index] = move.NewGroup;
+      foreach (IItem tabuMove in tabuList) {
+        SingleGroupingMoveAttribute sgmAttr = (tabuMove as SingleGroupingMoveAttribute);
+        if (sgmAttr != null
+          && (!useAspiration
+              || maximization && moveQuality <= sgmAttr.MoveQuality
+              || !maximization && moveQuality >= sgmAttr.MoveQuality)) {
+                if (move.Index == sgmAttr.ItemIndex || groupingVector.GroupingVector[move.Index] == sgmAttr.AssignedBin)
+                  return true;
+        }
+      }
+      return false;
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveMaker.cs	(revision 9440)
@@ -0,0 +1,79 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Single Grouping Move Maker", "Peforms a single grouping move on a given grouping vector and updates the quality.")]
+  [StorableClass]
+  public class SingleGroupingMoveMaker : SingleSuccessorOperator, IMoveMaker, IGroupingVectorMoveOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<SingleGroupingMove> SingleGroupingMoveParameter {
+      get { return (ILookupParameter<SingleGroupingMove>)Parameters["SingleGroupingMove"]; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+
+    [StorableConstructor]
+    protected SingleGroupingMoveMaker(bool deserializing) : base(deserializing) { }
+    protected SingleGroupingMoveMaker(SingleGroupingMoveMaker original, Cloner cloner) : base(original, cloner) { }
+    public SingleGroupingMoveMaker()
+      : 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<DoubleValue>("MoveQuality", "The relative quality of the move."));
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution as grouping vector."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleGroupingMoveMaker(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      SingleGroupingMove move = SingleGroupingMoveParameter.ActualValue;
+      GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue;
+      DoubleValue moveQuality = MoveQualityParameter.ActualValue;
+      DoubleValue quality = QualityParameter.ActualValue;
+
+      groupingVector.GroupingVector[move.Index] = move.NewGroup;
+
+      quality.Value = moveQuality.Value;
+
+      return base.Apply();
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveSoftTabuCriterion.cs	(revision 9440)
@@ -0,0 +1,110 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("SingleGroupingMoveSoftTabuCriterion", "<Missing>")]
+  [StorableClass]
+  public class SingleGroupingMoveSoftTabuCriterion : SingleSuccessorOperator, IGroupingVectorMoveOperator, ITabuChecker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<SingleGroupingMove> SingleGroupingMoveParameter {
+      get { return (ILookupParameter<SingleGroupingMove>)Parameters["SingleGroupingMove"]; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+    public ILookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (ILookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MoveTabu"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ValueParameter<BoolValue> UseAspirationCriterionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseAspirationCriterion"]; }
+    }
+
+    [StorableConstructor]
+    protected SingleGroupingMoveSoftTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected SingleGroupingMoveSoftTabuCriterion(SingleGroupingMoveSoftTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public SingleGroupingMoveSoftTabuCriterion()
+      : base() {
+      Parameters.Add(new LookupParameter<SingleGroupingMove>("SingleGroupingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution to evaluate."));
+      Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the current move."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseAspirationCriterion", "Whether to use the aspiration criterion or not.", new BoolValue(true)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleGroupingMoveSoftTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      SingleGroupingMove move = SingleGroupingMoveParameter.ActualValue;
+      GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue;
+      int length = groupingVector.GroupingVector.Length;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool maximization = MaximizationParameter.ActualValue.Value;   
+      bool useAspiration = UseAspirationCriterionParameter.Value.Value;
+      bool isTabu = IsMoveTabu(tabuList, move, groupingVector, moveQuality, maximization, useAspiration);
+
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+
+    private bool IsMoveTabu(ItemList<IItem> tabuList, SingleGroupingMove move, GroupingVectorEncoding groupingVector, double moveQuality, bool maximization, bool useAspiration) {
+      var movedGroupingVector = new IntegerVector(groupingVector.GroupingVector);
+      movedGroupingVector[move.Index] = move.NewGroup;
+      foreach (IItem tabuMove in tabuList) {
+        SingleGroupingMoveAttribute sgmAttr = (tabuMove as SingleGroupingMoveAttribute);
+        if (sgmAttr != null
+          && (!useAspiration
+              || maximization && moveQuality <= sgmAttr.MoveQuality
+              || !maximization && moveQuality >= sgmAttr.MoveQuality)) {
+                if (move.Index == sgmAttr.ItemIndex && groupingVector.GroupingVector[move.Index] == sgmAttr.AssignedBin)
+                  return true;
+        }
+      }
+      return false;
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingTabuMaker.cs	(revision 9440)
@@ -0,0 +1,64 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Single grouping tabu maker", "Declares a given single grouping move as tabu, by adding its attributes to the tabu list and also store the solution quality or the move quality (whichever is better).")]
+  [StorableClass]
+  public class SingleGroupingTabuMaker : TabuMaker, IGroupingVectorMoveOperator{
+    public ILookupParameter<SingleGroupingMove> SingleGroupingMoveParameter {
+      get { return (ILookupParameter<SingleGroupingMove>)Parameters["SingleGroupingMove"]; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+
+    [StorableConstructor]
+    protected SingleGroupingTabuMaker(bool deserializing) : base(deserializing) { }
+    protected SingleGroupingTabuMaker(SingleGroupingTabuMaker original, Cloner cloner) : base(original, cloner) { }
+    public SingleGroupingTabuMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<SingleGroupingMove>("SingleGroupingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleGroupingTabuMaker(this, cloner);
+    }
+
+    protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) {
+      SingleGroupingMove move = SingleGroupingMoveParameter.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);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/MultiComponentVectorMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/MultiComponentVectorMoveAttribute.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/MultiComponentVectorMoveAttribute.cs	(revision 9440)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("MultiComponentVectorMoveAttribute", "Base class for specifying a move attribute for multi component vector moves.")]
+  [StorableClass]
+  public class MultiComponentVectorMoveAttribute : Item {
+    [Storable]
+    public double MoveQuality { get; protected set; }
+
+    [StorableConstructor]
+    protected MultiComponentVectorMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected MultiComponentVectorMoveAttribute(MultiComponentVectorMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.MoveQuality = original.MoveQuality;
+    }
+    public MultiComponentVectorMoveAttribute() : this(0) { }
+    public MultiComponentVectorMoveAttribute( double moveQuality)
+      : base() {
+      MoveQuality = moveQuality;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiComponentVectorMoveAttribute(this, cloner);
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SingleGroupingMoveAttribute.cs	(revision 9440)
@@ -0,0 +1,53 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("SingleGroupingMoveAttribute", "Specifies the tabu attributes for a single grouping move on an multi component vector.")]
+  [StorableClass]
+  public class SingleGroupingMoveAttribute : MultiComponentVectorMoveAttribute {
+    [Storable]
+    public int ItemIndex { get; protected set; }
+    [Storable]
+    public int AssignedBin { get; protected set; }
+
+    [StorableConstructor]
+    protected SingleGroupingMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected SingleGroupingMoveAttribute(SingleGroupingMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.ItemIndex = original.ItemIndex;
+      this.AssignedBin = original.AssignedBin;
+    }
+    public SingleGroupingMoveAttribute() : this(-1, -1, -1) { }
+    public SingleGroupingMoveAttribute(int itemIndex, int assignedBin, double moveQuality)
+      : base(moveQuality) {
+      ItemIndex = itemIndex;
+      AssignedBin = assignedBin;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleGroupingMoveAttribute(this, cloner);
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SingleItemRotationMoveAttribute.cs	(revision 9440)
@@ -0,0 +1,53 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("SingleItemRotationMoveAttribute", "Specifies the tabu attributes for a single item rotation move on an multi component vector.")]
+  [StorableClass]
+  public class SingleItemRotationMoveAttribute : MultiComponentVectorMoveAttribute {
+    [Storable]
+    public int ItemIndex { get; protected set; }
+    [Storable]
+    public bool ItemRotation { get; protected set; }
+
+    [StorableConstructor]
+    protected SingleItemRotationMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected SingleItemRotationMoveAttribute(SingleItemRotationMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.ItemIndex = original.ItemIndex;
+      this.ItemRotation = original.ItemRotation;
+    }
+    public SingleItemRotationMoveAttribute() : this(-1, false, -1) { }
+    public SingleItemRotationMoveAttribute(int itemIndex, bool itemRotation, double moveQuality)
+      : base(moveQuality) {
+      ItemIndex = itemIndex;
+      ItemRotation = itemRotation;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleItemRotationMoveAttribute(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SwapSequenceMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SwapSequenceMoveAttribute.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SwapSequenceMoveAttribute.cs	(revision 9440)
@@ -0,0 +1,59 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("SwapSequenceMoveAttribute", "Specifies the tabu attributes for a swap sequence move on an multi component vector.")]
+  [StorableClass]
+  public class SwapSequenceMoveAttribute : MultiComponentVectorMoveAttribute {
+    [Storable]
+    public int Index1 { get; protected set; }
+    [Storable]
+    public int Index2 { get; protected set; }
+    [Storable]
+    public int ItemIndex1 { get; protected set; }
+    [Storable]
+    public int ItemIndex2 { get; protected set; }
+
+    [StorableConstructor]
+    protected SwapSequenceMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected SwapSequenceMoveAttribute(SwapSequenceMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.ItemIndex1 = original.ItemIndex1;
+      this.ItemIndex2 = original.ItemIndex2;
+    }
+    public SwapSequenceMoveAttribute() : this(-1, -1, -1, -1, -1) { }
+    public SwapSequenceMoveAttribute(int index1, int index2, int itemIndex1, int itemIndex2, double moveQuality)
+      : base(moveQuality) {
+        Index1 = index1;
+        Index2 = index2;
+        ItemIndex1 = itemIndex1;
+        ItemIndex2 = itemIndex2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SwapSequenceMoveAttribute(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/ExhaustiveMultiComponentVectorMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/ExhaustiveMultiComponentVectorMoveGenerator.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/ExhaustiveMultiComponentVectorMoveGenerator.cs	(revision 9440)
@@ -0,0 +1,87 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("Exhaustive MultiComponentVector Move Generator", "Generates all possible multi component moves from a given multiComponentVector.")]
+  [StorableClass]
+  public class ExhaustiveMultiComponentVectorMoveGenerator : MultiComponentVectorMoveGenerator, IExhaustiveMoveGenerator {
+    [StorableConstructor]
+    protected ExhaustiveMultiComponentVectorMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ExhaustiveMultiComponentVectorMoveGenerator(ExhaustiveMultiComponentVectorMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveMultiComponentVectorMoveGenerator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveMultiComponentVectorMoveGenerator(this, cloner);
+    }
+
+
+    public static MultiComponentVectorMove[] Apply(MultiComponentVectorEncoding multiComponentVector) {
+      //NrOfMoves = nrOfRotationMoves + nrOfSingleGroupingMoves + nrOfSwapSequenceMoves
+      //  nrOfRotationMoves       = nrOfItems
+      //  nrOfSingleGroupingMoves = nrOfItems * (nrOfBins - 1)
+      //  nrOfSwapSequenceMoves   = SUM(foreach binNr: !nrOfItemsInBin)
+
+      int lastBinNr = 0;
+      foreach (var pi in multiComponentVector.PackingInformations) {
+        if (pi.AssignedBin > lastBinNr)
+          lastBinNr = pi.AssignedBin;
+      }
+      int nrOfBins = lastBinNr + 1;
+
+      int nrOfRotationMoves = multiComponentVector.PackingInformations.Count;
+      int nrOfSingleGroupingMoves = nrOfRotationMoves * (nrOfBins - 1);
+
+      int[] itemsPerBin = new int[nrOfBins];
+      foreach (var pi in multiComponentVector.PackingInformations) {
+        itemsPerBin[pi.AssignedBin]++;
+      }
+      int nrOfSwapSequenceMoves = 0;
+      foreach (int items in itemsPerBin) {
+        nrOfSwapSequenceMoves += (items * (items - 1)) / 2;
+      }
+
+      int totalMoves = nrOfRotationMoves + nrOfSingleGroupingMoves + nrOfSwapSequenceMoves;
+      MultiComponentVectorMove[] moves = new MultiComponentVectorMove[totalMoves];
+      int count = 0;
+      foreach (MultiComponentVectorMove move in GenerateRotationMoves(multiComponentVector)) {
+        moves[count++] = move;
+      }
+      foreach (MultiComponentVectorMove move in GenerateSingleGroupingMoves(multiComponentVector)) {
+        moves[count++] = move;
+      }
+      foreach (MultiComponentVectorMove move in GenerateSwapSequenceMoves(multiComponentVector)) {
+        moves[count++] = move;
+      }
+      return moves;
+    }    
+
+    protected override MultiComponentVectorMove[] GenerateMoves(MultiComponentVectorEncoding multiComponentVector) {
+      return Apply(multiComponentVector);
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/MultiComponentVectorMove.cs	(revision 9440)
@@ -0,0 +1,50 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("MultiComponentVectorMove", "An abstract move for a multi component vector encoded solution.")]
+  [StorableClass]
+  public abstract class MultiComponentVectorMove : Item {
+    [Storable]
+    public MultiComponentVectorEncoding MultiComponentVector { get; protected set; }
+
+    [StorableConstructor]
+    protected MultiComponentVectorMove(bool deserializing) : base(deserializing) { }
+    protected MultiComponentVectorMove(MultiComponentVectorMove original, Cloner cloner)
+      : base(original, cloner) {
+        if (original.MultiComponentVector != null)
+          this.MultiComponentVector = cloner.Clone(original.MultiComponentVector);
+    }
+    public MultiComponentVectorMove(MultiComponentVectorEncoding multiComponentVector)
+      : base() {
+        MultiComponentVector = multiComponentVector;
+    }
+
+    public abstract MultiComponentVectorEncoding GetVectorAfterMove();
+    public abstract Type GetMoveAttributeType();
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SingleGroupingMove.cs	(revision 9440)
@@ -0,0 +1,73 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+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 {
+    [Storable]
+    public int ItemIndex { get; protected set; }
+    [Storable]
+    public int NewGroup { get; protected set; }
+
+    [StorableConstructor]
+    protected SingleGroupingMove(bool deserializing) : base(deserializing) { }
+    protected SingleGroupingMove(SingleGroupingMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.ItemIndex = original.ItemIndex;
+      this.NewGroup = original.NewGroup;
+    }
+    public SingleGroupingMove(int index, int newGroup, MultiComponentVectorEncoding multiComponentVector)
+      : base(multiComponentVector) {
+      ItemIndex = index;
+      NewGroup = newGroup;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleGroupingMove(this, cloner);
+    }
+
+    public override MultiComponentVectorEncoding GetVectorAfterMove() {
+      //var result = new MultiComponentVectorEncoding();
+      //result.PackingInformations = new ItemList<PackingInformation>(this.MultiComponentVector.PackingInformations);
+      //result.PackingInformations[ItemIndex].AssignedBin = NewGroup;
+      //return result;
+      return InsertItemgeneAfterLastItemgeneOfUsedBin(MultiComponentVector, ItemIndex, NewGroup);
+    }
+    private MultiComponentVectorEncoding InsertItemgeneAfterLastItemgeneOfUsedBin(MultiComponentVectorEncoding solution, int itemIndex, int binNr) {
+      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);
+      return solution;
+    }
+
+    public override System.Type GetMoveAttributeType() {
+      return typeof(SingleGroupingMoveAttribute);
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SingleItemRotationMove.cs	(revision 9440)
@@ -0,0 +1,60 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("SingleItemRotationMove", "A move on a multi component vector that is specified by a single index. The item at the specified index is rotated.")]
+  [StorableClass]
+  public class SingleItemRotationMove : MultiComponentVectorMove {
+    [Storable]
+    public int ItemIndex { get; protected set; }
+
+    [StorableConstructor]
+    protected SingleItemRotationMove(bool deserializing) : base(deserializing) { }
+    protected SingleItemRotationMove(SingleItemRotationMove original, Cloner cloner)
+      : base(original, cloner) {
+        this.ItemIndex = original.ItemIndex;
+    }
+    public SingleItemRotationMove(int index, MultiComponentVectorEncoding multiComponentVector)
+      : base(multiComponentVector) {
+        ItemIndex = index;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleItemRotationMove(this, cloner);
+    }
+
+    public override MultiComponentVectorEncoding GetVectorAfterMove() {
+      var result = new MultiComponentVectorEncoding();
+      result.PackingInformations = new ItemList<PackingInformation>(this.MultiComponentVector.PackingInformations);
+      result.PackingInformations[ItemIndex].Rotated = !result.PackingInformations[ItemIndex].Rotated;
+      return result;
+    }
+
+    public override System.Type GetMoveAttributeType() {
+      return typeof(SingleItemRotationMoveAttribute);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SwapSequenceMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SwapSequenceMove.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SwapSequenceMove.cs	(revision 9440)
@@ -0,0 +1,66 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("SwapSequenceMove", "A move on a multi component vector that is specified by two indexes. The packing informations at the speciefied indexes are beeing swapped.")]
+  [StorableClass]
+  public class SwapSequenceMove : MultiComponentVectorMove {
+    [Storable]
+    public int Index1 { get; protected set; }
+    [Storable]
+    public int Index2 { get; protected set; }
+
+    [StorableConstructor]
+    protected SwapSequenceMove(bool deserializing) : base(deserializing) { }
+    protected SwapSequenceMove(SwapSequenceMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index1 = original.Index1;
+      this.Index2 = original.Index2;
+    }
+    public SwapSequenceMove(int index1, int index2, MultiComponentVectorEncoding multiComponentVector)
+      : base(multiComponentVector) {
+        Index1 = index1;
+        Index2 = index2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SwapSequenceMove(this, cloner);
+    }
+
+    public override MultiComponentVectorEncoding GetVectorAfterMove() {
+      var result = new MultiComponentVectorEncoding();
+      result.PackingInformations = new ItemList<PackingInformation>(this.MultiComponentVector.PackingInformations);
+      var aux = result.PackingInformations[Index1];
+      result.PackingInformations[Index1] = result.PackingInformations[Index2];
+      result.PackingInformations[Index2] = aux;
+      return result;
+    }
+
+    public override System.Type GetMoveAttributeType() {
+      return typeof(SwapSequenceMoveAttribute);
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveGenerator.cs	(revision 9440)
@@ -0,0 +1,110 @@
+﻿#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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("MultiComponentVectorMoveGenerator", "Base class for all multi-component vector move generators.")]
+  [StorableClass]
+  public abstract class MultiComponentVectorMoveGenerator : SingleSuccessorOperator, IMultiComponentVectorMoveOperator, IMoveGenerator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter {
+      get { return (ILookupParameter<MultiComponentVectorEncoding>)Parameters["MultiComponentVector"]; }
+    }
+    public ILookupParameter<MultiComponentVectorMove> MultiComponentVectorMoveParameter {
+      get { return (LookupParameter<MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }
+    }
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    [StorableConstructor]
+    protected MultiComponentVectorMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected MultiComponentVectorMoveGenerator(MultiComponentVectorMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public MultiComponentVectorMoveGenerator()
+      : 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 ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
+    }
+
+
+
+
+    public static IEnumerable<MultiComponentVectorMove> GenerateRotationMoves(MultiComponentVectorEncoding multiComponentVector) {
+      for (int i = 0; i < multiComponentVector.PackingInformations.Count; i++)
+        yield return new SingleItemRotationMove(i, multiComponentVector);
+    }
+
+    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);
+        }
+    }
+
+    public static IEnumerable<MultiComponentVectorMove> GenerateSwapSequenceMoves(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 SwapSequenceMove(entry.Value[i], entry.Value[j], multiComponentVector);
+      }
+    }
+
+
+    public override IOperation Apply() {
+      MultiComponentVectorEncoding mcv = MultiComponentVectorParameter.ActualValue;
+      MultiComponentVectorMove[] moves = GenerateMoves(mcv);
+      Scope[] moveScopes = new Scope[moves.Length];
+      for (int i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        moveScopes[i].Variables.Add(new Variable(MultiComponentVectorMoveParameter.ActualName, moves[i]));
+      }
+      CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
+      return base.Apply();
+    }
+
+    protected abstract MultiComponentVectorMove[] GenerateMoves(MultiComponentVectorEncoding multiComponentVector);
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveHardTabuCriterion.cs	(revision 9440)
@@ -0,0 +1,147 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("MultiComponentVectorMoveHardTabuCriterion", "<Missing>")]
+  [StorableClass]
+  public class MultiComponentVectorMoveHardTabuCriterion : SingleSuccessorOperator, IMultiComponentVectorMoveOperator, ITabuChecker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<MultiComponentVectorMove> MultiComponentVectorMoveParameter {
+      get { return (ILookupParameter<MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }
+    }
+    public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter {
+      get { return (ILookupParameter<MultiComponentVectorEncoding>)Parameters["MultiComponentVector"]; }
+    }
+    public ILookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (ILookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MoveTabu"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ValueParameter<BoolValue> UseAspirationCriterionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseAspirationCriterion"]; }
+    }
+
+    [StorableConstructor]
+    protected MultiComponentVectorMoveHardTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected MultiComponentVectorMoveHardTabuCriterion(MultiComponentVectorMoveHardTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public MultiComponentVectorMoveHardTabuCriterion()
+      : base() {
+        Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "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."));
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the current move."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseAspirationCriterion", "Whether to use the aspiration criterion or not.", new BoolValue(true)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiComponentVectorMoveHardTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;
+      MultiComponentVectorEncoding multiComponentVector = MultiComponentVectorParameter.ActualValue;
+      int length = multiComponentVector.PackingInformations.Count;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool maximization = MaximizationParameter.ActualValue.Value;
+      bool useAspiration = UseAspirationCriterionParameter.Value.Value;
+      bool isTabu = IsMoveTabu(tabuList, move, multiComponentVector, moveQuality, maximization, useAspiration);
+
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+
+    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;   
+      SwapSequenceMove ssm = move as SwapSequenceMove;
+      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;
+        }
+      } 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 (sgm.ItemIndex == sgmAttr.ItemIndex || multiComponentVector.PackingInformations[sgm.ItemIndex].AssignedBin == sgmAttr.AssignedBin)
+                    isTabu = true;
+          }
+          if (isTabu) break;
+        }
+      } else if (ssm != null) {
+        foreach (IItem tabuMove in attributes) {
+          SwapSequenceMoveAttribute ssmAttr = (tabuMove as SwapSequenceMoveAttribute);
+          if (ssmAttr != null
+            && (!useAspiration
+                || maximization && moveQuality <= ssmAttr.MoveQuality
+                || !maximization && moveQuality >= ssmAttr.MoveQuality)) {
+                  if (ssm.Index1 == ssmAttr.Index1
+                    || ssm.Index2 == ssmAttr.Index2
+                    || multiComponentVector.PackingInformations[ssm.Index1].ItemIndex == ssmAttr.ItemIndex1
+                    || multiComponentVector.PackingInformations[ssm.Index2].ItemIndex == ssmAttr.ItemIndex2)
+              isTabu = true;
+          }
+          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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveMaker.cs	(revision 9440)
@@ -0,0 +1,79 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("MultiComponentVectorMoveMaker", "Peforms a single move on a given multi-component vector and updates the quality.")]
+  [StorableClass]
+  public class MultiComponentVectorMoveMaker : SingleSuccessorOperator, IMoveMaker, IMultiComponentVectorMoveOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<MultiComponentVectorMove> MultiComponentVectorMoveParameter {
+      get { return (ILookupParameter<MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }
+    }
+    public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter {
+      get { return (ILookupParameter<MultiComponentVectorEncoding>)Parameters["MultiComponentVector"]; }
+    }
+
+    [StorableConstructor]
+    protected MultiComponentVectorMoveMaker(bool deserializing) : base(deserializing) { }
+    protected MultiComponentVectorMoveMaker(MultiComponentVectorMoveMaker original, Cloner cloner) : base(original, cloner) { }
+    public MultiComponentVectorMoveMaker()
+      : 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<DoubleValue>("MoveQuality", "The relative quality of the move."));
+      Parameters.Add(new LookupParameter<MultiComponentVectorEncoding>("MultiComponentVector", "The solution as grouping vector."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiComponentVectorMoveMaker(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;
+      MultiComponentVectorEncoding MultiComponentVector = MultiComponentVectorParameter.ActualValue;
+      DoubleValue moveQuality = MoveQualityParameter.ActualValue;
+      DoubleValue quality = QualityParameter.ActualValue;
+
+      MultiComponentVector = move.GetVectorAfterMove();
+
+      quality.Value = moveQuality.Value;
+
+      return base.Apply();
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveSoftTabuCriterion.cs	(revision 9440)
@@ -0,0 +1,147 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("MultiComponentVectorMoveSoftTabuCriterion", "<Missing>")]
+  [StorableClass]
+  public class MultiComponentVectorMoveSoftTabuCriterion : SingleSuccessorOperator, IMultiComponentVectorMoveOperator, ITabuChecker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<MultiComponentVectorMove> MultiComponentVectorMoveParameter {
+      get { return (ILookupParameter<MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }
+    }
+    public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter {
+      get { return (ILookupParameter<MultiComponentVectorEncoding>)Parameters["MultiComponentVector"]; }
+    }
+    public ILookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (ILookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MoveTabu"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ValueParameter<BoolValue> UseAspirationCriterionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseAspirationCriterion"]; }
+    }
+
+    [StorableConstructor]
+    protected MultiComponentVectorMoveSoftTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected MultiComponentVectorMoveSoftTabuCriterion(MultiComponentVectorMoveSoftTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public MultiComponentVectorMoveSoftTabuCriterion()
+      : base() {
+        Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "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."));
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the current move."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseAspirationCriterion", "Whether to use the aspiration criterion or not.", new BoolValue(true)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiComponentVectorMoveSoftTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;
+      MultiComponentVectorEncoding multiComponentVector = MultiComponentVectorParameter.ActualValue;
+      int length = multiComponentVector.PackingInformations.Count;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool maximization = MaximizationParameter.ActualValue.Value;
+      bool useAspiration = UseAspirationCriterionParameter.Value.Value;
+      bool isTabu = IsMoveTabu(tabuList, move, multiComponentVector, moveQuality, maximization, useAspiration);
+
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+
+    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;   
+      SwapSequenceMove ssm = move as SwapSequenceMove;
+      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;
+        }
+      } 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 (sgm.ItemIndex == sgmAttr.ItemIndex && multiComponentVector.PackingInformations[sgm.ItemIndex].AssignedBin == sgmAttr.AssignedBin)
+                    isTabu = true;
+          }
+          if (isTabu) break;
+        }
+      } else if (ssm != null) {
+        foreach (IItem tabuMove in attributes) {
+          SwapSequenceMoveAttribute ssmAttr = (tabuMove as SwapSequenceMoveAttribute);
+          if (ssmAttr != null
+            && (!useAspiration
+                || maximization && moveQuality <= ssmAttr.MoveQuality
+                || !maximization && moveQuality >= ssmAttr.MoveQuality)) {
+                  if (ssm.Index1 == ssmAttr.Index1
+                    && ssm.Index2 == ssmAttr.Index2
+                    && multiComponentVector.PackingInformations[ssm.Index1].ItemIndex == ssmAttr.ItemIndex1
+                    && multiComponentVector.PackingInformations[ssm.Index2].ItemIndex == ssmAttr.ItemIndex2)
+              isTabu = true;
+          }
+          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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorTabuMaker.cs	(revision 9440)
@@ -0,0 +1,74 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("Multi component tabu maker", "Declares a given single grouping move as tabu, by adding its attributes to the tabu list and also store the solution quality or the move quality (whichever is better).")]
+  [StorableClass]
+  public class MultiComponentVectorTabuMaker : TabuMaker, IMultiComponentVectorMoveOperator{
+    public ILookupParameter<MultiComponentVectorMove> MultiComponentVectorMoveParameter {
+      get { return (ILookupParameter<MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }
+    }
+    public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter {
+      get { return (ILookupParameter<MultiComponentVectorEncoding>)Parameters["MultiComponentVector"]; }
+    }
+
+    [StorableConstructor]
+    protected MultiComponentVectorTabuMaker(bool deserializing) : base(deserializing) { }
+    protected MultiComponentVectorTabuMaker(MultiComponentVectorTabuMaker original, Cloner cloner) : base(original, cloner) { }
+    public MultiComponentVectorTabuMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<MultiComponentVectorEncoding>("MultiComponentVector", "The solution to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiComponentVectorTabuMaker(this, cloner);
+    }
+
+    protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) {
+      MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;
+      MultiComponentVectorEncoding solution = MultiComponentVectorParameter.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
+                              
+      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.ItemIndex, solution.PackingInformations[sgm.ItemIndex].AssignedBin, baseQuality);
+      SwapSequenceMove ssm = move as SwapSequenceMove;
+      if (ssm != null)
+        return new SwapSequenceMoveAttribute(ssm.Index1, ssm.Index2, solution.PackingInformations[ssm.Index1].ItemIndex, solution.PackingInformations[ssm.Index2].ItemIndex, 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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/StochasticMultiComponentVectorMoveGenerator.cs	(revision 9440)
@@ -0,0 +1,86 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.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.MultiComponentVector {
+  [Item("StochasticMultiComponentVectorMoveGenerator", "Generates all possible multi component moves from a given multiComponentVector.")]
+  [StorableClass]
+  public class StochasticMultiComponentVectorMoveGenerator : MultiComponentVectorMoveGenerator, 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 StochasticMultiComponentVectorMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticMultiComponentVectorMoveGenerator(StochasticMultiComponentVectorMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticMultiComponentVectorMoveGenerator()
+      : 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 StochasticMultiComponentVectorMoveGenerator(this, cloner);
+    }
+
+    public static MultiComponentVectorMove[] Apply(MultiComponentVectorEncoding multiComponentVector, IRandom random, int sampleSize) {
+      MultiComponentVectorMove[] moves = new MultiComponentVectorMove[sampleSize];
+      var rm = new List<MultiComponentVectorMove> (GenerateRotationMoves(multiComponentVector));
+      var gm = new List<MultiComponentVectorMove> (GenerateSingleGroupingMoves(multiComponentVector));
+      var sm = new List<MultiComponentVectorMove> (GenerateSwapSequenceMoves(multiComponentVector));
+
+      for (int i = 0; i < sampleSize; i++) {
+        int typeDecision = random.Next(3);
+        switch (typeDecision) {
+          case 0: moves[i] = rm[random.Next(rm.Count)];
+            break;
+          case 1: moves[i] = gm[random.Next(gm.Count)];
+            break;
+          case 2: moves[i] = sm[random.Next(sm.Count)];
+            break;
+          default:
+            break;
+        }
+      }
+      return moves;
+    }
+
+    protected override MultiComponentVectorMove[] GenerateMoves(MultiComponentVectorEncoding multiComponentVector) {
+      IRandom random = RandomParameter.ActualValue;
+      return Apply(multiComponentVector, random, SampleSizeParameter.ActualValue.Value);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorCrossover.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorCrossover.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorCrossover.cs	(revision 9440)
@@ -0,0 +1,54 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("Multi Component Vector Crossover", "An operator which crosses two GroupingVector representations.")]
+  [StorableClass]
+  public abstract class MultiComponentVectorCrossover : PackingSolutionCrossover, IMultiComponentVectorOperator {
+
+    [StorableConstructor]
+    protected MultiComponentVectorCrossover(bool deserializing) : base(deserializing) { }
+    protected MultiComponentVectorCrossover(MultiComponentVectorCrossover original, Cloner cloner) : base(original, cloner) { }
+    public MultiComponentVectorCrossover()
+      : base() {
+        ParentsParameter.ActualName = "MultiComponentVector";
+        ChildParameter.ActualName = "MultiComponentVector";
+    }
+
+    public abstract MultiComponentVectorEncoding Cross(IRandom random, MultiComponentVectorEncoding parent1, MultiComponentVectorEncoding parent2);
+
+    public override IOperation Apply() {
+      var parents = ParentsParameter.ActualValue;
+
+      ChildParameter.ActualValue =
+        Cross(RandomParameter.ActualValue, parents[0] as MultiComponentVectorEncoding, parents[1] as MultiComponentVectorEncoding);
+
+      return base.Apply();
+    }
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorEncoding.cs	(revision 9440)
@@ -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.Text;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("Multi Component Vector Encoding", "Represents an encoding for a bin packing problem using an array of objects containing multiple packing-informations for every packing-item.")]
+  [StorableClass]
+  public class MultiComponentVectorEncoding : Item, IPackingSolutionEncoding {
+
+    [Storable]
+    public ItemList<PackingInformation> PackingInformations {get;set;}   
+
+    [StorableConstructor]
+    protected MultiComponentVectorEncoding(bool deserializing) : base(deserializing) { }
+    protected MultiComponentVectorEncoding(MultiComponentVectorEncoding original, Cloner cloner)
+      : base(original, cloner) {
+        this.PackingInformations = cloner.Clone(original.PackingInformations);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiComponentVectorEncoding(this, cloner);
+    }
+
+    public MultiComponentVectorEncoding()
+      : base() {
+        PackingInformations = new ItemList<PackingInformation>();
+    }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      sb.Append("[ ");
+      foreach (var pi in PackingInformations) {
+        sb.Append(pi.ToString() + " ");        
+      }
+      sb.Append("]");
+      return sb.ToString();
+    }
+
+
+    public override bool Equals(object obj) {
+      MultiComponentVectorEncoding mce = obj as MultiComponentVectorEncoding;
+      if (mce != null && mce.PackingInformations != null && mce.PackingInformations.Count == this.PackingInformations.Count) {
+        for (int i = 0; i <= mce.PackingInformations.Count; i++) {
+          if (mce.PackingInformations[i] != this.PackingInformations[i])
+            return false;
+        }
+      }
+
+      return true;
+    }
+    public override int GetHashCode() {
+      return PackingInformations.GetHashCode();
+    }
+  }
+
+  [Item("Packing Information", "Represents a composition of packing informations for the multi-component packing-encoding.")]
+  [StorableClass]
+  public class PackingInformation : Item {
+    [Storable]
+    public int ItemIndex { get; set; }
+    [Storable]
+    public int AssignedBin { get; set; }
+    [Storable]
+    public bool Rotated { get; set; }
+
+    public PackingInformation(int itemIndex, int assignedBin, bool rotated) {
+      this.AssignedBin  = assignedBin;
+      this.ItemIndex   = itemIndex;
+      this.Rotated      = rotated;
+    }     
+    public PackingInformation(PackingInformation original) {
+      this.AssignedBin = original.AssignedBin;
+      this.ItemIndex = original.ItemIndex;
+      this.Rotated = original.Rotated;
+    }
+
+    [StorableConstructor]
+    protected PackingInformation(bool deserializing) : base(deserializing) { }
+    protected PackingInformation(PackingInformation original, Cloner cloner)
+      : base(original, cloner) {
+        this.AssignedBin  = original.AssignedBin;
+        this.ItemIndex   = original.ItemIndex;
+        this.Rotated      = original.Rotated;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingInformation(this, cloner);
+    }
+
+    public override string ToString() {
+      return String.Format("({0}, {1}, {2}) ", ItemIndex, AssignedBin, Rotated);
+    }
+
+    public override bool Equals(object obj) {
+      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 false;
+    }
+
+    public override int GetHashCode() {
+      return base.GetHashCode();
+    }
+
+    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));
+      }
+      return result;
+    }
+  }
+
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorManipulator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorManipulator.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorManipulator.cs	(revision 9440)
@@ -0,0 +1,50 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("Multi Component Vector Manipulator", "An operator which manipulates a PackingSequence representation.")]
+  [StorableClass]
+  public abstract class MultiComponentVectorManipulator : PackingSolutionManipulator, IMultiComponentVectorOperator {
+    [StorableConstructor]
+    protected MultiComponentVectorManipulator(bool deserializing) : base(deserializing) { }
+    protected MultiComponentVectorManipulator(MultiComponentVectorManipulator original, Cloner cloner) : base(original, cloner) { }
+    public MultiComponentVectorManipulator()
+      : base() {
+        EncodedSolutionParameter.ActualName = "MultiComponentVector";
+    }
+
+    protected abstract void Manipulate(IRandom random, MultiComponentVectorEncoding individual);
+    public override IOperation Apply() {
+      var solution = EncodedSolutionParameter.ActualValue as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("PackingSolutionEncoding was not found or is not of type MultiComponentVectorEncoding.");
+      Manipulate(RandomParameter.ActualValue, solution);
+      return base.Apply();
+    }
+
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorRandomCreator.cs	(revision 9440)
@@ -0,0 +1,74 @@
+﻿#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.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+	[Item("Multi Component Vector Creator", "Creator class used to create MultiComponentVector solutions for bin packing problems.")]
+	[StorableClass]
+	public class MultiComponentVectorRandomCreator : PackingSolutionCreator, IStochasticOperator {
+
+		public ILookupParameter<IRandom> RandomParameter {
+			get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+		}
+		public IValueLookupParameter<IntValue> PackingItemsParameter {
+			get { return (IValueLookupParameter<IntValue>)Parameters["PackingItems"]; }
+		}
+		public IValueLookupParameter<IntValue> LowerBoundParameter {
+			get { return (IValueLookupParameter<IntValue>)Parameters["LowerBound"]; }
+		}
+
+		[StorableConstructor]
+		protected MultiComponentVectorRandomCreator(bool deserializing) : base(deserializing) { }
+		protected MultiComponentVectorRandomCreator(MultiComponentVectorRandomCreator original, Cloner cloner) : base(original, cloner) {
+		}
+		public override IDeepCloneable Clone(Cloner cloner) {
+			return new MultiComponentVectorRandomCreator(this, cloner);
+		}
+
+    public MultiComponentVectorRandomCreator()
+			: base() {
+			Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
+			Parameters.Add(new ValueLookupParameter<IntValue>("PackingItems", "The number of packing-items handled in this problem instance."));
+			Parameters.Add(new ValueLookupParameter<IntValue>("LowerBound", "The lower possible number of bins needed to solve this problem (taken from Dell'Amico, Martello and Vigo; 2002)"));
+
+			EncodedSolutionParameter.ActualName = "MultiComponentVector";
+		}
+
+
+    public static MultiComponentVectorEncoding Apply(int items, int lowerBound, IRandom random) {
+			var solution = new MultiComponentVectorEncoding();
+      solution.PackingInformations = PackingInformation.CreateListRandomly(items, lowerBound, random);
+			return solution;
+		}
+
+		protected override IPackingSolutionEncoding CreateSolution() {
+			return Apply(PackingItemsParameter.ActualValue.Value, LowerBoundParameter.ActualValue.Value, RandomParameter.ActualValue);
+		}
+	}
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/PartiallyMatchedMultiComponentVectorCrossover.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/PartiallyMatchedMultiComponentVectorCrossover.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/PartiallyMatchedMultiComponentVectorCrossover.cs	(revision 9440)
@@ -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;
+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/ThreeWayMultiComponentVectorManipulator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/ThreeWayMultiComponentVectorManipulator.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/ThreeWayMultiComponentVectorManipulator.cs	(revision 9440)
@@ -0,0 +1,80 @@
+﻿#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("Uniform Multi Component Vector Manipulator", "An operator which manipulates a PackingSequence representation.")]
+  [StorableClass]
+  public class ThreeWayMultiComponentVectorManipulator :  MultiComponentVectorManipulator {
+    [StorableConstructor]
+    protected ThreeWayMultiComponentVectorManipulator(bool deserializing) : base(deserializing) { }
+    protected ThreeWayMultiComponentVectorManipulator(ThreeWayMultiComponentVectorManipulator original, Cloner cloner) : base(original, cloner) { }
+    public ThreeWayMultiComponentVectorManipulator()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ThreeWayMultiComponentVectorManipulator(this, cloner);
+    }
+
+    protected override void Manipulate(IRandom random, MultiComponentVectorEncoding individual) {
+      int manipulatorDecision = random.Next(0, 3);
+
+      //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;
+      } 
+      //Randomly change the bin-assignment for one item
+      else if (manipulatorDecision == 1) {
+        individual.PackingInformations[random.Next(individual.PackingInformations.Count - 1)].AssignedBin = 0;
+      }
+      //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;
+        }
+
+      }
+
+    }
+
+  }
+}
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 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs	(revision 9440)
@@ -0,0 +1,145 @@
+﻿#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.Problems.BinPacking.PackingItem;
+using HeuristicLab.Problems.BinPacking.Shapes;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingPlan {
+  //RegularPackingPlan defines that the packingItems have to be parallel to the packingBin in every moment
+  //SimpleRotation defines that the items may be rotated 
+  //  only in one dimension, 
+  //  only once and 
+  //  only by 90degree
+  //    so that parallelism to the correlating bin is ensured
+  //This definition implies that the floor of the (3D) objects never changes (what may be a wanted constraint in most cases..)
+  [Item("PackingPlan", "Represents a concrete solution for a bin-packing problem.")]
+  [StorableClass]
+  public class PackingPlan<D, B, I> : ParameterizedNamedItem, IPackingPlan
+    where D : class, IPackingDimensions
+    where B : PackingShape<D>, IPackingBin
+    where I : PackingShape<D>, IPackingItem {
+
+    #region Properties
+    public int NrOfBins {
+      get {
+        if (PackingItemPositions != null)
+          return PackingItemPositions.Select(p => p.Value.AssignedBin).Max() + 1;
+        else return 0;
+      }
+    }
+
+    [Storable]
+    public ObservableDictionary<int, D> PackingItemPositions { get; set; }
+
+    //[Storable]
+    //public ItemList<BoolValue> PackingItemsRotated { get; set; }
+
+    [Storable]
+    public B PackingBinMeasures {
+      get;
+      set;
+    }
+    [Storable]
+    public ItemList<I> PackingItemMeasures {
+      get;
+      set;
+    }
+    [Storable]
+    private DoubleValue quality;
+    public DoubleValue Quality {
+      get { return quality; }
+      set {
+        if (quality != value) {
+          if (quality != null) DeregisterQualityEvents();
+          quality = value;
+          if (quality != null) RegisterQualityEvents();
+          OnQualityChanged();
+        }
+      }
+    }
+    #endregion
+
+    public PackingPlan(B binMeasures, ItemList<I> itemMeasures) : base() {
+      this.PackingBinMeasures = binMeasures;
+      this.PackingItemMeasures = itemMeasures;
+    }
+
+    [StorableConstructor]
+    protected PackingPlan(bool deserializing) : base(deserializing) { }
+    protected PackingPlan(PackingPlan<D,B,I> original, Cloner cloner)
+      : base(original, cloner) {
+        PackingItemPositions = new ObservableDictionary<int, D>(original.PackingItemPositions);
+      PackingBinMeasures = original.PackingBinMeasures;
+      PackingItemMeasures = original.PackingItemMeasures;
+      //PackingItemsRotated = cloner.Clone(original.PackingItemsRotated);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingPlan<D,B,I>(this, cloner);
+    }
+
+
+    #region Events
+    public event EventHandler QualityChanged;
+    private void OnQualityChanged() {
+      var changed = QualityChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+    private void RegisterQualityEvents() {
+      Quality.ValueChanged += new EventHandler(Quality_ValueChanged);
+    }
+    private void DeregisterQualityEvents() {
+      Quality.ValueChanged -= new EventHandler(Quality_ValueChanged);
+    }
+    private void Quality_ValueChanged(object sender, EventArgs e) {
+      OnQualityChanged();
+    }
+
+    public event EventHandler PackingItemPositionChanged;
+    private void OnPackingItemPositionChanged() {
+      var changed = PackingItemPositionChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+    private void RegisterPackingItemPositionEvents() {
+      PackingItemPositions.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(PackingItemPosition_PropertyChanged);
+    }
+    private void DeregisterPackingItemPositionEvents() {
+      PackingItemPositions.PropertyChanged -= new System.ComponentModel.PropertyChangedEventHandler(PackingItemPosition_PropertyChanged);
+    }
+    private void PackingItemPosition_PropertyChanged(object sender, EventArgs e) {
+      OnPackingItemPositionChanged();
+    }
+    #endregion
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/RegularSimpleRotationPackingPlan.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/RegularSimpleRotationPackingPlan.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/RegularSimpleRotationPackingPlan.cs	(revision 9440)
@@ -0,0 +1,68 @@
+﻿#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.Problems.BinPacking.PackingItem;
+using HeuristicLab.Problems.BinPacking.Shapes;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingPlan {
+  //RegularPackingPlan defines that the packingItems have to be parallel to the packingBin in every moment
+  //SimpleRotation defines that the items may be rotated 
+  //  only in one dimension, 
+  //  only once and 
+  //  only by 90degree
+  //    so that parallelism to the correlating bin is ensured
+  //This definition implies that the floor of the (3D) objects never changes (what may be a wanted constraint in most cases..)
+  [Item("RegularSimpleRotationPackingPlan", "Represents a concrete solution for a bin-packing problem using simple rotation (90degrees-steps) and regular shapes (e.g. rectangle)")]
+  [StorableClass]
+  public class RegularSimpleRotationPackingPlan<D, B, I> : PackingPlan<D, B, I>
+    where D : class, IPackingDimensions
+    where B : PackingShape<D>, IRegularPackingShape, IPackingBin
+    where I : PackingShape<D>, IRegularPackingShape, IPackingItem {
+    
+    #region Properties
+    public ItemList<BoolValue> PackingItemsRotated { get; set; }
+    #endregion
+
+    public RegularSimpleRotationPackingPlan(B binMeasures, ItemList<I> itemMeasures) : base(binMeasures, itemMeasures) {
+
+    }
+
+    [StorableConstructor]
+    protected RegularSimpleRotationPackingPlan(bool deserializing) : base(deserializing) { }
+    protected RegularSimpleRotationPackingPlan(RegularSimpleRotationPackingPlan<D,B,I> original, Cloner cloner)
+      : base(original, cloner) {
+        PackingItemsRotated = cloner.Clone(original.PackingItemsRotated);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RegularSimpleRotationPackingPlan<D,B,I>(this, cloner);
+    }
+
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/2D/BinUtilizationRectangularIdenticalBinEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/2D/BinUtilizationRectangularIdenticalBinEvaluator.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/2D/BinUtilizationRectangularIdenticalBinEvaluator.cs	(revision 9440)
@@ -30,5 +30,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Common;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Dimensions;
 using HeuristicLab.Problems.BinPacking.PackingBin;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/2D/PackingRatioRectangularIdenticalBinEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/2D/PackingRatioRectangularIdenticalBinEvaluator.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/2D/PackingRatioRectangularIdenticalBinEvaluator.cs	(revision 9440)
@@ -30,5 +30,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Common;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.PackingItem;
 using HeuristicLab.Problems.BinPacking.PackingBin;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/3D/BinUtilizationCuboiddenticalBinEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/3D/BinUtilizationCuboiddenticalBinEvaluator.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/3D/BinUtilizationCuboiddenticalBinEvaluator.cs	(revision 9440)
@@ -30,5 +30,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Common;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Dimensions;
 using HeuristicLab.Problems.BinPacking.PackingBin;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/3D/PackingRatioCuboidIdenticalBinEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/3D/PackingRatioCuboidIdenticalBinEvaluator.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/3D/PackingRatioCuboidIdenticalBinEvaluator.cs	(revision 9440)
@@ -30,5 +30,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Common;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Dimensions;
 using HeuristicLab.Problems.BinPacking.PackingBin;
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 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/BinUtilizationRegularIdenticalBinEvaluator.cs	(revision 9440)
@@ -30,5 +30,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Common;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 
 namespace HeuristicLab.Problems.BinPacking.Evaluators {
@@ -53,5 +53,4 @@
       B binMeasure = PackingBinMeasuresParameter.ActualValue;
       ItemList<I> itemMeasures = PackingItemMeasuresParameter.ActualValue;
-      int nrOfBins = plan.NrOfBins;
 
 
@@ -67,10 +66,11 @@
 
       //if (itemPositionsAreValid)
-      return CalculatePackingRatio(plan as PackingPlan<D, B, I>, binMeasure, itemMeasures, nrOfBins);
+      return CalculateBinUtilization(plan as PackingPlan<D, B, I>, binMeasure, itemMeasures);
 
       //return quality;
     }
 
-    private DoubleValue CalculatePackingRatio(PackingPlan<D, B, I> plan, B binMeasure, ItemList<I> itemMeasures, int nrOfBins) {
+    public static DoubleValue CalculateBinUtilization(PackingPlan<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/PackingPlanEvaluationAlgorithm.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingPlanEvaluationAlgorithm.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingPlanEvaluationAlgorithm.cs	(revision 9440)
@@ -12,5 +12,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Problems.BinPacking.Shapes;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 
 namespace HeuristicLab.Problems.BinPacking.Evaluators {
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 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingPlanEvaluator.cs	(revision 9440)
@@ -31,5 +31,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Data;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Shapes;
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingRatioRegularIdenticalBinEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingRatioRegularIdenticalBinEvaluator.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingRatioRegularIdenticalBinEvaluator.cs	(revision 9440)
@@ -30,5 +30,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Common;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 
 namespace HeuristicLab.Problems.BinPacking.Evaluators {
@@ -53,5 +53,4 @@
       B binMeasure = PackingBinMeasuresParameter.ActualValue;
       ItemList<I> itemMeasures = PackingItemMeasuresParameter.ActualValue;
-      int nrOfBins = plan.NrOfBins;
 
 
@@ -67,5 +66,5 @@
 
       //if (itemPositionsAreValid)
-      return CalculatePackingRatio(plan as PackingPlan<D, B, I>, binMeasure, itemMeasures, nrOfBins);
+      return CalculatePackingRatio(plan as PackingPlan<D, B, I>, binMeasure, itemMeasures);
 
       //return quality;
@@ -81,5 +80,6 @@
         k.......a constant, k>1.
      */
-    private DoubleValue CalculatePackingRatio(PackingPlan<D, B, I> plan, B binMeasure, ItemList<I> itemMeasures, int nrOfBins) {
+    public static DoubleValue CalculatePackingRatio(PackingPlan<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/RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs	(revision 9440)
@@ -31,5 +31,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Data;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Shapes;
 using HeuristicLab.Collections;
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 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 9440)
@@ -127,4 +127,8 @@
       <Private>False</Private>
     </Reference>
+    <Reference Include="HeuristicLab.Optimization.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization.Operators-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="HeuristicLab.Parameters-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <Private>False</Private>
@@ -161,11 +165,30 @@
     <Compile Include="Analyzers\BestBinPackingSolutionAnalyzer.cs" />
     <Compile Include="Analyzers\BinPackingAnalyzer.cs" />
-    <Compile Include="Decoders\PackingHeuristics.cs" />
-    <Compile Include="Decoders\ThreeDimensionalBottomLeftGroupingVectorDecoder.cs" />
-    <Compile Include="Decoders\TwoDimensionalBottomLeftGroupingVectorDecoder.cs" />
-    <Compile Include="Decoders\IB2DLowestGapFillGroupingVectorDecoder.cs" />
-    <Compile Include="Decoders\ThreeDimensionalBottomLeftPackingSequenceDecoder.cs" />
-    <Compile Include="Decoders\TwoDimensionalBottomLeftPackingSequenceDecoder.cs" />
+    <Compile Include="Decoders\2D\BL\BottomLeftMultiComponentVectorDecoder.cs" />
+    <Compile Include="Decoders\2D\BL\BottomLeftFunctions.cs" />
+    <Compile Include="Decoders\2D\EP\ExtremePointGroupingVectorDecoder2D.cs" />
+    <Compile Include="Decoders\2D\EP\ExtremePointMultiComponentVectorDecoder2D.cs" />
+    <Compile Include="Decoders\2D\EP\ExtremePointPackingSequenceDecoder2D.cs" />
+    <Compile Include="Decoders\2D\EP\ExtremePointsFunctions2D.cs" />
+    <Compile Include="Decoders\3D\EP\ExtremePointMultiComponentVectorDecoder3D.cs" />
+    <Compile Include="Decoders\3D\EP\ExtremePointGroupingVectorDecoder3D.cs" />
+    <Compile Include="Decoders\3D\EP\ExtremePointPackingSequenceDecoder3D.cs" />
+    <Compile Include="Decoders\3D\DBL\DeepestBottomLeftMultiComponentVectorDecoder.cs" />
+    <Compile Include="Decoders\3D\DBL\DeepestBottomLeftFunctions.cs" />
+    <Compile Include="Decoders\3D\EP\ExtremePointsFunctions3D.cs" />
+    <Compile Include="Decoders\3D\DBL\DeepestBottomLeftGroupingVectorDecoder.cs" />
+    <Compile Include="Decoders\2D\BL\BottomLeftGroupingVectorDecoder.cs" />
+    <Compile Include="Decoders\3D\DBL\DeepestBottomLeftPackingSequenceDecoder.cs" />
+    <Compile Include="Decoders\2D\BL\BottomLeftPackingSequenceDecoder.cs" />
     <Compile Include="Decoders\IdenticalBinPackingSolutionDecoder.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" />
+    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMoveAttribute.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMoveGenerator.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMoveMaker.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingTabuMaker.cs" />
+    <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMoveHardTabuCriterion.cs" />
     <Compile Include="Encodings\GroupingVector\UniformGroupingVectorManipulator.cs" />
     <Compile Include="Encodings\GroupingVector\GroupingVectorCrossover.cs" />
@@ -173,4 +196,26 @@
     <Compile Include="Encodings\GroupingVector\GroupingVectorManipulator.cs" />
     <Compile Include="Encodings\GroupingVector\GroupingVectorRandomCreator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\SwapSequenceMoveAttribute.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\SingleGroupingMoveAttribute.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\MultiComponentVectorMoveAttribute.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\SingleItemRotationMoveAttribute.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\MultiComponentVectorMoveHardTabuCriterion.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Moves\MultiComponentVectorMove.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Moves\SwapSequenceMove.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Moves\SingleItemRotationMove.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\ExhaustiveMultiComponentVectorMoveGenerator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Moves\SingleGroupingMove.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\MultiComponentVectorMoveGenerator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\MultiComponentVectorMoveSoftTabuCriterion.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\MultiComponentVectorMoveMaker.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\MultiComponentVectorTabuMaker.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\StochasticMultiComponentVectorMoveGenerator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\PartiallyMatchedMultiComponentVectorCrossover.cs" />
+    <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorCrossover.cs" />
+    <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorEncoding.cs" />
+    <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorManipulator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorRandomCreator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\ThreeWayMultiComponentVectorManipulator.cs" />
+    <Compile Include="Encodings\PackingPlans\PackingPlan.cs" />
     <Compile Include="Encodings\PackingSequence\PackingSequenceCrossover.cs" />
     <Compile Include="Encodings\PackingSequence\PackingSequenceManipulator.cs" />
@@ -180,7 +225,4 @@
     <Compile Include="Encodings\PackingSolutionCrossover.cs" />
     <Compile Include="Encodings\PackingSolutionManipulator.cs" />
-    <Compile Include="Encodings\Potvin\PotvinEncodingWrapper.cs">
-      <SubType>Code</SubType>
-    </Compile>
     <Compile Include="Evaluators\2D\BinUtilizationRectangularIdenticalBinEvaluator.cs" />
     <Compile Include="Evaluators\2D\PackingRatioRectangularIdenticalBinEvaluator.cs" />
@@ -198,5 +240,9 @@
     <Compile Include="Instances\BPPORLIBParser.cs" />
     <Compile Include="Instances\BPPORLIBDataDescriptor.cs" />
+    <Compile Include="Interfaces\IMultiComponentVectorMoveOperator.cs" />
+    <Compile Include="Interfaces\IGroupingVectorMoveOperator.cs" />
+    <Compile Include="Interfaces\IMultiComponentVectorOperator.cs" />
     <Compile Include="Interfaces\IGroupingVectorOperator.cs" />
+    <Compile Include="Interfaces\IPackingMoveEvaluator.cs" />
     <Compile Include="Interfaces\IPackingOperator.cs" />
     <Compile Include="Interfaces\IPackingSolutionManipulator.cs" />
@@ -210,4 +256,7 @@
     <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="Problem\BinPackingProblem.cs" />
     <Compile Include="Problem\CuboidIdenticalBinPackingProblem.cs" />
@@ -228,11 +277,8 @@
     <Compile Include="Interfaces\IPackingPlan.cs" />
     <Compile Include="PackingItem\RectangularPackingItem.cs" />
-    <Compile Include="PackingPlans\PackingPlan.cs" />
-    <Compile Include="PackingPlans\RegularSimpleRotationPackingPlan.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="ClassDiagram1.cd" />
     <None Include="HeuristicLab.snk" />
     <None Include="Instances\Data\BPPORLIB.rar" />
@@ -240,7 +286,5 @@
     <None Include="Plugin.cs.frame" />
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Encodings\DirectedBinaryTree\" />
-  </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IGroupingVectorMoveOperator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IGroupingVectorMoveOperator.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IGroupingVectorMoveOperator.cs	(revision 9440)
@@ -0,0 +1,34 @@
+﻿#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;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Optimization;
+using HeuristicLab.Problems.BinPacking.Shapes;
+
+namespace HeuristicLab.Problems.BinPacking.Interfaces {
+  public interface IGroupingVectorMoveOperator : IGroupingVectorOperator, IMoveOperator {
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IGroupingVectorOperator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IGroupingVectorOperator.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IGroupingVectorOperator.cs	(revision 9440)
@@ -25,5 +25,5 @@
 using System.Text;
 using HeuristicLab.Core;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Shapes;
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IMultiComponentVectorMoveOperator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IMultiComponentVectorMoveOperator.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IMultiComponentVectorMoveOperator.cs	(revision 9440)
@@ -0,0 +1,34 @@
+﻿#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;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Optimization;
+using HeuristicLab.Problems.BinPacking.Shapes;
+
+namespace HeuristicLab.Problems.BinPacking.Interfaces {
+  public interface IMultiComponentVectorMoveOperator : IMultiComponentVectorOperator, IMoveOperator {
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IMultiComponentVectorOperator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IMultiComponentVectorOperator.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IMultiComponentVectorOperator.cs	(revision 9440)
@@ -0,0 +1,33 @@
+﻿#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;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Problems.BinPacking.Shapes;
+
+namespace HeuristicLab.Problems.BinPacking.Interfaces {
+  public interface IMultiComponentVectorOperator : IOperator {
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingMoveEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingMoveEvaluator.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingMoveEvaluator.cs	(revision 9440)
@@ -0,0 +1,29 @@
+﻿#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 IPackingMoveEvaluator : ISingleObjectiveMoveEvaluator, IMoveOperator, IPackingOperator {
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingOperator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingOperator.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingOperator.cs	(revision 9440)
@@ -25,5 +25,5 @@
 using System.Text;
 using HeuristicLab.Core;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Shapes;
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSequenceOperator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSequenceOperator.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSequenceOperator.cs	(revision 9440)
@@ -25,5 +25,5 @@
 using System.Text;
 using HeuristicLab.Core;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Shapes;
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionDecoder.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionDecoder.cs	(revision 9440)
@@ -25,5 +25,5 @@
 using System.Text;
 using HeuristicLab.Core;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Shapes;
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/GroupingVectorMoveEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/GroupingVectorMoveEvaluator.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/GroupingVectorMoveEvaluator.cs	(revision 9440)
@@ -0,0 +1,80 @@
+﻿#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("Grouping Vector MoveEvaluator", "Base class for evaluating packing moves.")]
+  [StorableClass]
+  public class GroupingVectorMoveEvaluator : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator{
+    public ILookupParameter<SingleGroupingMove> SingleGroupingMoveParameter {
+      get { return (ILookupParameter<SingleGroupingMove>)Parameters["SingleGroupingMove"]; }  
+    }                
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+
+    [StorableConstructor]
+    protected GroupingVectorMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected GroupingVectorMoveEvaluator(GroupingVectorMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public GroupingVectorMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<SingleGroupingMove>("SingleGroupingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingVectorMoveEvaluator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue;
+      SingleGroupingMove move = SingleGroupingMoveParameter.ActualValue;
+
+      GroupingVectorEncoding newSolution = new GroupingVectorEncoding();
+      newSolution.GroupingVector = new IntegerVector (groupingVector.GroupingVector);
+      newSolution.GroupingVector[move.Index] = move.NewGroup;
+
+      var packingPlan = ExtremePointGroupingVectorDecoder3D.Decode(newSolution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      DoubleValue quality = PackingRatioRegularIdenticalBinEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.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/MultiComponentVectorMoveEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/MultiComponentVectorMoveEvaluator.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/MultiComponentVectorMoveEvaluator.cs	(revision 9440)
@@ -0,0 +1,79 @@
+﻿#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.MultiComponentVector;
+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("Multi Component Vector MoveEvaluator", "Base class for evaluating packing moves.")]
+  [StorableClass]
+  public class MultiComponentVectorMoveEvaluator : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator{
+    public ILookupParameter<MultiComponentVectorMove> MultiComponentVectorMoveParameter {
+      get { return (ILookupParameter<MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }  
+    }                
+    public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter {
+      get { return (ILookupParameter<MultiComponentVectorEncoding>)Parameters["MultiComponentVector"]; }
+    }
+
+    [StorableConstructor]
+    protected MultiComponentVectorMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected MultiComponentVectorMoveEvaluator(MultiComponentVectorMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public MultiComponentVectorMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<MultiComponentVectorEncoding>("MultiComponentVector", "The solution to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiComponentVectorMoveEvaluator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      MultiComponentVectorEncoding MultiComponentVector = MultiComponentVectorParameter.ActualValue;
+      MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;
+
+      MultiComponentVectorEncoding newSolution = new MultiComponentVectorEncoding();
+      newSolution = move.GetVectorAfterMove();
+
+      var packingPlan = ExtremePointMultiComponentVectorDecoder3D.Decode(newSolution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      DoubleValue quality = PackingRatioRegularIdenticalBinEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.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/PackingMoveEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator.cs	(revision 9440)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator.cs	(revision 9440)
@@ -0,0 +1,76 @@
+#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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.Shapes;
+
+namespace HeuristicLab.Problems.BinPacking {
+  [Item("PackingMoveEvaluator", "A base class for operators which evaluate Packing-Solution moves.")]
+  [StorableClass]
+  public abstract class PackingMoveEvaluator<D, B, I> : SingleSuccessorOperator, IPackingMoveEvaluator, IMoveOperator
+    where D : class, IPackingDimensions
+    where B : PackingShape<D>, IPackingBin
+    where I : PackingShape<D>, IPackingItem {     
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<ItemList<I>> PackingItemMeasuresParameter {
+      get { return (LookupParameter<ItemList<I>>)Parameters["PackingItemMeasures"]; }
+    }
+    public ILookupParameter<B> PackingBinMeasuresParameter {
+      get { return (LookupParameter<B>)Parameters["PackingBinMeasures"]; }
+    }
+    public IValueLookupParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
+      get { return (IValueLookupParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
+    }
+    public IValueLookupParameter<IPackingPlanEvaluator> PackingPlanEvaluatorParameter {
+      get { return (IValueLookupParameter<IPackingPlanEvaluator>)Parameters["PackingPlanEvaluator"]; }
+    }
+    
+    [StorableConstructor]
+    protected PackingMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected PackingMoveEvaluator(PackingMoveEvaluator<D, B, I> original, Cloner cloner) : base(original, cloner) { }
+    protected PackingMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of a packing solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The evaluated quality of a move on a packing solution."));
+      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."));
+      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."));
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Plugin.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Plugin.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Plugin.cs	(revision 9440)
@@ -26,5 +26,5 @@
   /// Plugin class for HeuristicLab.Problems.BinPacking plugin.
   /// </summary>
-  [Plugin("HeuristicLab.Problems.BinPacking", "3.3.7.8737")]
+  [Plugin("HeuristicLab.Problems.BinPacking", "3.3.7.9348")]
   [PluginFile("HeuristicLab.Problems.BinPacking-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Common", "3.3")]
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/BinPackingProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/BinPackingProblem.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/BinPackingProblem.cs	(revision 9440)
@@ -31,5 +31,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Parameters;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Evaluators;
 using HeuristicLab.Problems.BinPacking.Analyzers;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/CuboidIdenticalBinPackingProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/CuboidIdenticalBinPackingProblem.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/CuboidIdenticalBinPackingProblem.cs	(revision 9440)
@@ -43,4 +43,5 @@
 using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
 using HeuristicLab.Problems.Instances;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 
 namespace HeuristicLab.Problems.BinPacking.Problem {
@@ -119,7 +120,9 @@
     protected override void InitializeDecoder() {
       if (SolutionCreator is PackingSequenceRandomCreator) {
-        PackingSolutionDecoder = new ThreeDimensionalBottomLeftPackingSequenceDecoder();
+        PackingSolutionDecoder = new ExtremePointPackingSequenceDecoder3D();
       } else if (SolutionCreator is GroupingVectorRandomCreator) {
-        PackingSolutionDecoder = new ThreeDimensionalBottomLeftGroupingVectorDecoder();
+        PackingSolutionDecoder = new ExtremePointGroupingVectorDecoder3D();
+      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
+        PackingSolutionDecoder = new ExtremePointMultiComponentVectorDecoder3D();
       } else {
         string error = "The given problem does not support the selected solution-creator.";
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RectangularIdenticalBinPackingProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RectangularIdenticalBinPackingProblem.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RectangularIdenticalBinPackingProblem.cs	(revision 9440)
@@ -39,8 +39,9 @@
 using HeuristicLab.Data;
 using HeuristicLab.Problems.BinPacking.Decoders;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
 using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
 using HeuristicLab.Problems.Instances;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 
 namespace HeuristicLab.Problems.BinPacking.Problem {
@@ -114,7 +115,9 @@
     protected override void InitializeDecoder() {
       if (SolutionCreator is PackingSequenceRandomCreator) {
-        PackingSolutionDecoder = new TwoDimensionalBottomLeftPackingSequenceDecoder();
+        PackingSolutionDecoder = new ExtremePointPackingSequenceDecoder2D();
       } else if (SolutionCreator is GroupingVectorRandomCreator) {
-        PackingSolutionDecoder = new TwoDimensionalBottomLeftGroupingVectorDecoder();
+        PackingSolutionDecoder = new ExtremePointGroupingVectorDecoder2D();
+      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
+        PackingSolutionDecoder = new ExtremePointMultiComponentVectorDecoder2D();
       } else {
         string error = "The given problem does not support the selected solution-creator.";
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RegularIdenticalBinPackingProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RegularIdenticalBinPackingProblem.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RegularIdenticalBinPackingProblem.cs	(revision 9440)
@@ -36,5 +36,5 @@
 using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Data;
-using HeuristicLab.Problems.BinPacking.PackingPlans;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
 using HeuristicLab.Problems.BinPacking.Analyzers;
 using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
@@ -42,4 +42,5 @@
 using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
 using HeuristicLab.Problems.Instances;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 
 namespace HeuristicLab.Problems.BinPacking.Problem {
@@ -79,5 +80,5 @@
     }
 
-    protected RegularIdenticalBinPackingProblem(IPackingPlanEvaluationAlgorithm e) : this(e, new GroupingVectorRandomCreator()) { }
+    protected RegularIdenticalBinPackingProblem(IPackingPlanEvaluationAlgorithm e) : this(e, new MultiComponentVectorRandomCreator()) { }
     protected RegularIdenticalBinPackingProblem(IPackingPlanEvaluationAlgorithm e, IPackingSolutionCreator c)
       : base(e, c) {
@@ -134,4 +135,7 @@
         Operators.AddRange(ApplicationManager.Manager.GetInstances<IGroupingVectorOperator>());
         InitializeDecoder();
+      } else if (SolutionCreator.GetType() == typeof(MultiComponentVectorRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IMultiComponentVectorOperator>());
+        InitializeDecoder();
       } 
     }
@@ -192,4 +196,5 @@
       if (PackingSolutionDecoder != null) PackingSolutionDecoder.PackingPlanParameter.ActualNameChanged += PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged;
     }
+
     #endregion
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Shapes/CuboidPackingShape.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Shapes/CuboidPackingShape.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Shapes/CuboidPackingShape.cs	(revision 9440)
@@ -53,5 +53,5 @@
 
     #region Helpers
-    public int MultipliedMeasures { get { return Height * Width * Depth; } }
+    public int MultipliedMeasures { get { return Width * Height * Depth; } }
    
     public override bool Encloses(ThreeDimensionalPacking checkedPosition, PackingShape<ThreeDimensionalPacking> checkedShape) {
@@ -162,7 +162,7 @@
         y1 = myPosition.Y;
         z1 = myPosition.Z;
-        x2 = myPosition.X + myShape.Width;
+        x2 = myPosition.X + (myPosition.Rotated ? myShape.Depth : myShape.Width);
         y2 = myPosition.Y + myShape.Height;
-        z2 = myPosition.Z + myShape.Depth;
+        z2 = myPosition.Z + (myPosition.Rotated ? myShape.Width : myShape.Depth);
       }
     }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Shapes/RectangularPackingShape.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Shapes/RectangularPackingShape.cs	(revision 9439)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Shapes/RectangularPackingShape.cs	(revision 9440)
@@ -142,6 +142,6 @@
         x1 = myPosition.X;
         y1 = myPosition.Y;
-        x2 = myPosition.X + myShape.Width;
-        y2 = myPosition.Y + myShape.Height;
+        x2 = myPosition.X + (myPosition.Rotated ? myShape.Height : myShape.Width);
+        y2 = myPosition.Y + (myPosition.Rotated ? myShape.Width : myShape.Height);
       }
     }
