Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Plugin.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Plugin.cs	(revision 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Plugin.cs	(revision 9473)
@@ -26,5 +26,5 @@
   /// Plugin class for HeuristicLab.Problems.BinPacking.Views plugin.
   /// </summary>
-  [Plugin("HeuristicLab.Problems.BinPacking.Views", "3.3.7.9348")]
+  [Plugin("HeuristicLab.Problems.BinPacking.Views", "3.3.7.9440")]
   [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 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Properties/AssemblyInfo.cs	(revision 9473)
@@ -54,3 +54,3 @@
 // by using the '*' as shown below:
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.7.9348")]
+[assembly: AssemblyFileVersion("3.3.7.9440")]
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPotvinDecoder3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPotvinDecoder3D.cs	(revision 9473)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPotvinDecoder3D.cs	(revision 9473)
@@ -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.Potvin;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+  [Item("Identical bin, three dimensional, extreme points based decoder for the Potvin encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointPotvinDecoder3D : IdenticalBinPackingSolutionDecoder<
+      ThreeDimensionalPacking,
+      CuboidPackingBin,
+      CuboidPackingItem,
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> {
+
+    public ExtremePointPotvinDecoder3D ()
+      : base() {
+    }
+    [StorableConstructor]
+    protected ExtremePointPotvinDecoder3D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointPotvinDecoder3D(ExtremePointPotvinDecoder3D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointPotvinDecoder3D(this, cloner);
+    }
+
+
+    protected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {
+
+      var solution = encodedSolution as PotvinEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type Potvin-encoding.");
+
+      PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = 
+        new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+
+      result.PackingItemPositions = ExtremePointsFunctions3D.ExtremePointBasedPacking(ref 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 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointsFunctions3D.cs	(revision 9473)
@@ -5,7 +5,9 @@
 using HeuristicLab.Collections;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PackingEncoding.Potvin;
 using HeuristicLab.Problems.BinPacking.Dimensions;
 using HeuristicLab.Problems.BinPacking.Interfaces;
@@ -18,4 +20,145 @@
 
 
+
+    public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(ref PotvinEncoding solution, 
+      ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) {
+        if (!solution.DelimiterInitialized) {
+          #region Preperations
+          var itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
+          int nrOfBins = 1;
+
+          var occupiedPoints = new List<int[, ,]>();
+          occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+
+          HashSet<ThreeDimensionalPacking> extremePoints = new HashSet<ThreeDimensionalPacking>();
+          extremePoints.Add(new ThreeDimensionalPacking(0, 0, 0, 0, false));
+          #endregion
+
+          Dictionary<int, List<int>> itemIndexesForBin = new Dictionary<int, List<int>>();
+          itemIndexesForBin[0] = new List<int>();
+
+          foreach (int itemIndex in solution.IntVector) {
+            var item = itemMeasures[itemIndex];
+            extremePoints = OrderExtremePoints(extremePoints, occupiedPoints, binMeasures);
+            var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions);
+            if (positionFound != null) {
+              extremePoints.Remove(positionFound);
+            } else {
+              positionFound = new ThreeDimensionalPacking(nrOfBins, 0, 0, 0);
+              occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+              itemIndexesForBin[nrOfBins] = new List<int>();
+              nrOfBins++;
+            }
+            itemPositions[itemIndex] = positionFound;
+            itemIndexesForBin[positionFound.AssignedBin].Add(itemIndex);
+            occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+            extremePoints = GenerateNewExtremePointsForNewItem(extremePoints, occupiedPoints, item, positionFound, binMeasures);
+          }
+          List<int> intVector = new List<int>();
+          foreach (var indexes in itemIndexesForBin) {
+            foreach (var index in indexes.Value) {
+              intVector.Add(index);
+            }
+            intVector.Add(-1);
+          }
+          intVector.RemoveAt(intVector.Count - 1);
+          solution.IntVector = new IntegerVector (intVector.ToArray());
+
+          return itemPositions;
+        } else {
+          #region Preperations
+          int nrOfBins = solution.IntVector.Count(i => i.Equals (-1)) + 1;
+
+          //Get all indexes of items for every bin according to int vector
+          Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>();
+          Dictionary<int, HashSet<ThreeDimensionalPacking>> extremePointsForBin = new Dictionary<int, HashSet<ThreeDimensionalPacking>>();
+          var occupiedPoints = new List<int[, ,]>();
+
+          int binCounter = 0;
+          unpackedItemIndexesPerBin[binCounter] = new List<int>();
+          for (int i = 0; i < solution.IntVector.Length; i++) {
+            if (solution.IntVector[i].Equals(-1)) {
+              unpackedItemIndexesPerBin[binCounter++] = new List<int>();
+              extremePointsForBin[i] = new HashSet<ThreeDimensionalPacking>();
+              extremePointsForBin[i].Add(new ThreeDimensionalPacking(i, 0, 0, 0, false));
+              occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+            } else {
+              unpackedItemIndexesPerBin[binCounter].Add(solution.IntVector[i]);
+            }
+
+          }
+
+
+          ObservableDictionary<int, ThreeDimensionalPacking> itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();
+          var remainingItems = new List<int>();
+
+          #endregion Preperations
+
+
+
+          //Iterate over all bin-lists
+          for (int binNr = 0; binNr < nrOfBins; binNr++) {
+            //Iterate over the current bin-item-list and find feasible positions in the current bin for each item
+            var unpackedItems = unpackedItemIndexesPerBin[binNr];
+            for (int i = 0; i < unpackedItems.Count; i++) {
+              var itemIndex = unpackedItems[i];
+              var item = itemMeasures[itemIndex];
+
+              extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
+              var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
+              if (positionFound != null) {
+                extremePointsForBin[binNr].Remove(positionFound);
+                itemPositions[itemIndex] = positionFound;
+                occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+                extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+              } else
+                remainingItems.Add(itemIndex);
+            }
+          }
+
+
+
+          //Packing of remaining items    
+          //Iterate over all bin-lists
+          for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {
+            var unpackedItems = new List<int>(remainingItems);
+            //Iterate over all the remaining items
+            for (int i = 0; i < unpackedItems.Count; i++) {
+              var itemIndex = unpackedItems[i];
+              var item = itemMeasures[itemIndex];
+
+              extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
+              var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
+              if (positionFound != null) {
+                extremePointsForBin[binNr].Remove(positionFound);
+                InsertItemgeneAfterLastItemgeneOfUsedBin(ref solution, itemIndex, binNr);
+                itemPositions[itemIndex] = positionFound;
+                occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);
+                extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);
+                remainingItems.Remove(itemIndex);
+              }
+            }
+            if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {
+              extremePointsForBin[nrOfBins] = new HashSet<ThreeDimensionalPacking>();
+              extremePointsForBin[nrOfBins].Add(new ThreeDimensionalPacking(nrOfBins, 0, 0, 0, false));
+              occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);
+              nrOfBins++;
+            }
+          }
+
+          return itemPositions;
+        }
+    }
+    private static void InsertItemgeneAfterLastItemgeneOfUsedBin(ref PotvinEncoding solution, int itemIndex, int binNr) { 
+      List<int> temp = new List<int> (solution.IntVector);
+      temp.Remove(itemIndex);
+      var delimiterIndexes = temp.Select((value, index) => value == -1).Select((value, index) => index);
+      int insertionIndex = temp.Count; 
+      if (binNr < delimiterIndexes.Count()) {
+        insertionIndex = delimiterIndexes.ElementAt(binNr);
+      }
+      temp.Insert(insertionIndex, itemIndex);
+      solution.IntVector = new IntegerVector (temp.ToArray());
+    }
 
 
@@ -56,5 +199,5 @@
           var item = itemMeasures[itemIndex];
 
-          extremePointsForBin[binNr] = new HashSet<ThreeDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
           var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
           if (positionFound != null) {
@@ -78,5 +221,5 @@
           var item = itemMeasures[itemIndex];
 
-          extremePointsForBin[binNr] = new HashSet<ThreeDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
           var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated);
           if (positionFound != null) {
@@ -147,5 +290,5 @@
           var item = itemMeasures[itemIndex];
 
-          extremePointsForBin[binNr] = new HashSet<ThreeDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
           var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
           if (positionFound != null) {
@@ -170,5 +313,5 @@
           var item = itemMeasures[itemIndex];
 
-          extremePointsForBin[binNr] = new HashSet<ThreeDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+          extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);
           var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);
           if (positionFound != null) {
@@ -208,5 +351,5 @@
       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)));
+        extremePoints = OrderExtremePoints(extremePoints, occupiedPoints, binMeasures);
         var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions);
         if (positionFound != null) {
@@ -373,4 +516,9 @@
       return extremePoints;
     }
+
+
+    private static HashSet<ThreeDimensionalPacking> OrderExtremePoints(HashSet<ThreeDimensionalPacking> hashSet, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
+      return new HashSet<ThreeDimensionalPacking>(hashSet.OrderBy(ep => ep.AssignedBin).ThenBy(ep => ep.Z).ThenBy(ep => ep.X).ThenBy(ep => ep.Y).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));
+    }
     private static int ShortestPossibleSideFromEP(ThreeDimensionalPacking ep, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {
       int shortestSide = int.MaxValue;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/ChangePositionMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/ChangePositionMoveAttribute.cs	(revision 9473)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/ChangePositionMoveAttribute.cs	(revision 9473)
@@ -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.MultiComponentVector {
+  [Item("ChangePositionMoveAttribute", "Specifies the tabu attributes for a change position move on an multi component vector.")]
+  [StorableClass]
+  public class ChangePositionMoveAttribute : MultiComponentVectorMoveAttribute {
+    [Storable]
+    public int Index { get; protected set; }
+    [Storable]
+    public int TargetIndex { get; protected set; }
+    [Storable]
+    public int ItemIndex { get; protected set; }
+
+    [StorableConstructor]
+    protected ChangePositionMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected ChangePositionMoveAttribute(ChangePositionMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+        this.Index = original.Index;
+        this.TargetIndex = original.TargetIndex;      
+      this.ItemIndex = original.ItemIndex;
+    }
+    public ChangePositionMoveAttribute() : this(-1, -1, -1, -1) { }
+    public ChangePositionMoveAttribute(int index, int targetIndex, int itemIndex, double moveQuality)
+      : base(moveQuality) {
+        Index = index;
+        TargetIndex = targetIndex;
+        ItemIndex = itemIndex;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ChangePositionMoveAttribute(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/MCVTripleMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/MCVTripleMoveAttribute.cs	(revision 9473)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/MCVTripleMoveAttribute.cs	(revision 9473)
@@ -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.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("MCVTripleMoveAttribute", "Specifies the tabu attributes for a change position move on an multi component vector.")]
+  [StorableClass]
+  public class MCVTripleMoveAttribute : MultiComponentVectorMoveAttribute {
+    [Storable]
+    public int Index { get; protected set; } 
+    [Storable]
+    public int ItemIndex { get; protected set; }  
+    [Storable]
+    public int TargetIndex { get; protected set; }
+    [Storable]
+    public bool RotationBefore { get; protected set; }
+    [Storable]
+    public bool RotationAfter { get; protected set; }
+    [Storable]
+    public int GroupBefore { get; protected set; }
+    [Storable]
+    public int GroupAfter { get; protected set; }
+
+    [StorableConstructor]
+    protected MCVTripleMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected MCVTripleMoveAttribute(MCVTripleMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+        this.Index = original.Index;
+        this.TargetIndex = original.TargetIndex;      
+      this.ItemIndex = original.ItemIndex;
+      this.RotationAfter = original.RotationAfter;
+      this.RotationBefore = original.RotationBefore;
+      this.GroupBefore = original.GroupBefore;
+      this.GroupAfter = original.GroupAfter;
+    }
+    public MCVTripleMoveAttribute() : this(-1, -1, -1, false, false, -1, -1, -1) { }
+    public MCVTripleMoveAttribute(int index, int targetIndex, int itemIndex, bool rotationBefore, bool rotationAfter, int groupBefore, int groupAfter, double moveQuality)
+      : base(moveQuality) {
+        Index = index;
+        TargetIndex = targetIndex;
+        ItemIndex = itemIndex;
+        RotationBefore = rotationBefore;
+        RotationAfter = rotationAfter;
+        GroupBefore = groupBefore;
+        GroupAfter = groupAfter;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MCVTripleMoveAttribute(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 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SingleGroupingMoveAttribute.cs	(revision 9473)
@@ -29,5 +29,5 @@
   public class SingleGroupingMoveAttribute : MultiComponentVectorMoveAttribute {
     [Storable]
-    public int ItemIndex { get; protected set; }
+    public int Index { get; protected set; }
     [Storable]
     public int AssignedBin { get; protected set; }
@@ -37,11 +37,11 @@
     protected SingleGroupingMoveAttribute(SingleGroupingMoveAttribute original, Cloner cloner)
       : base(original, cloner) {
-      this.ItemIndex = original.ItemIndex;
+      this.Index = original.Index;
       this.AssignedBin = original.AssignedBin;
     }
     public SingleGroupingMoveAttribute() : this(-1, -1, -1) { }
-    public SingleGroupingMoveAttribute(int itemIndex, int assignedBin, double moveQuality)
+    public SingleGroupingMoveAttribute(int index, int assignedBin, double moveQuality)
       : base(moveQuality) {
-      ItemIndex = itemIndex;
+      Index = index;
       AssignedBin = assignedBin;
     }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SwapPositionMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SwapPositionMoveAttribute.cs	(revision 9473)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SwapPositionMoveAttribute.cs	(revision 9473)
@@ -0,0 +1,61 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("SwapPositionMoveAttribute", "Specifies the tabu attributes for a swap sequence move on an multi component vector.")]
+  [StorableClass]
+  public class SwapPositionMoveAttribute : 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 SwapPositionMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected SwapPositionMoveAttribute(SwapPositionMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+        this.Index1 = original.Index1;
+        this.Index2 = original.Index2;
+      this.ItemIndex1 = original.ItemIndex1;
+      this.ItemIndex2 = original.ItemIndex2;
+    }
+    public SwapPositionMoveAttribute() : this(-1, -1, -1, -1, -1) { }
+    public SwapPositionMoveAttribute(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 SwapPositionMoveAttribute(this, cloner);
+    }
+  }
+}
Index: anches/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 9472)
+++ 	(revision )
@@ -1,59 +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 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/ExhaustiveMCVTripleMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/ExhaustiveMCVTripleMoveGenerator.cs	(revision 9473)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/ExhaustiveMCVTripleMoveGenerator.cs	(revision 9473)
@@ -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 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 Triple Move Generator", "Generates all possible multi component moves from a given multiComponentVector.")]
+  [StorableClass]
+  public class ExhaustiveMCVTripleMoveGenerator : MultiComponentVectorMoveGenerator, IExhaustiveMoveGenerator {
+    [StorableConstructor]
+    protected ExhaustiveMCVTripleMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ExhaustiveMCVTripleMoveGenerator(ExhaustiveMCVTripleMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveMCVTripleMoveGenerator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveMCVTripleMoveGenerator(this, cloner);
+    }
+
+    public static IEnumerable<MultiComponentVectorMove> GenerateMCVTripleMoves(MultiComponentVectorEncoding mcv) {
+      int nrOfBins = 0;
+      foreach (var pi in mcv.PackingInformations) {
+        if (pi.AssignedBin > nrOfBins)
+          nrOfBins = pi.AssignedBin;
+      }
+      nrOfBins++;
+      Dictionary<int, List<int>> indexesPerBin = new Dictionary<int, List<int>>();
+      for (int i = 0; i < mcv.PackingInformations.Count; i++) {
+        int currentBin = mcv.PackingInformations[i].AssignedBin;
+        if (!indexesPerBin.ContainsKey(currentBin))
+          indexesPerBin[currentBin] = new List<int>();
+        indexesPerBin[currentBin].Add(i);
+      }
+                                                        
+      for (int index = 0; index < mcv.PackingInformations.Count; index++) { 
+        for (int group = 0; group < nrOfBins; group++) {
+          foreach (int targetIndex in indexesPerBin[group]) {
+            yield return new MCVTripleMove(index, false, group, targetIndex, mcv);
+            yield return new MCVTripleMove(index, true, group, targetIndex, mcv);
+          }
+        }
+      }
+    }
+
+    public static MultiComponentVectorMove[] Apply(MultiComponentVectorEncoding multiComponentVector) {
+      var generatedMoves = new List<MultiComponentVectorMove>(GenerateMCVTripleMoves(multiComponentVector));
+      int totalMoves = generatedMoves.Count;
+      MultiComponentVectorMove[] moves = new MultiComponentVectorMove[totalMoves];
+      int count = 0;
+      foreach (MultiComponentVectorMove move in generatedMoves) {
+        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/ExhaustiveMultiComponentVectorMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/ExhaustiveMultiComponentVectorMoveGenerator.cs	(revision 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/ExhaustiveMultiComponentVectorMoveGenerator.cs	(revision 9473)
@@ -40,31 +40,14 @@
     }
 
-
     public static MultiComponentVectorMove[] Apply(MultiComponentVectorEncoding multiComponentVector) {
-      //NrOfMoves = nrOfRotationMoves + nrOfSingleGroupingMoves + nrOfSwapSequenceMoves
+      //NrOfMoves = nrOfRotationMoves + nrOfSingleGroupingMoves + nrOfSwapPositionMoves
       //  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;
+      //  nrOfSwapPositionMoves   = SUM(foreach binNr: !nrOfItemsInBin)
+      int totalMoves = 
+        NrOfRotationMoves(multiComponentVector) +
+        NrOfSingleGroupingMoves(multiComponentVector) +
+        NrOfSwapPositionMoves(multiComponentVector) +
+        NrOfChangePositionMoves(multiComponentVector);
       MultiComponentVectorMove[] moves = new MultiComponentVectorMove[totalMoves];
       int count = 0;
@@ -75,9 +58,12 @@
         moves[count++] = move;
       }
-      foreach (MultiComponentVectorMove move in GenerateSwapSequenceMoves(multiComponentVector)) {
+      foreach (MultiComponentVectorMove move in GenerateSwapPositionMoves(multiComponentVector)) {
+        moves[count++] = move;
+      }
+      foreach (MultiComponentVectorMove move in GenerateChangePositionMoves(multiComponentVector)) {
         moves[count++] = move;
       }
       return moves;
-    }    
+    }  
 
     protected override MultiComponentVectorMove[] GenerateMoves(MultiComponentVectorEncoding multiComponentVector) {
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/ChangePositionMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/ChangePositionMove.cs	(revision 9473)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/ChangePositionMove.cs	(revision 9473)
@@ -0,0 +1,72 @@
+﻿#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("ChangePositionMove", "A move on a multi component vector that is specified by two indexes. The packing informations at the first index is inserted at the second one.")]
+  [StorableClass]
+  public class ChangePositionMove : MultiComponentVectorMove {
+    [Storable]
+    public int Index { get; protected set; }
+    [Storable]
+    public int TargetIndex { get; protected set; }
+
+    [StorableConstructor]
+    protected ChangePositionMove(bool deserializing) : base(deserializing) { }
+    protected ChangePositionMove(ChangePositionMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index = original.Index;
+      this.TargetIndex = original.TargetIndex;
+    }
+    public ChangePositionMove(int index, int targetIndex, MultiComponentVectorEncoding multiComponentVector)
+      : base(multiComponentVector) {
+        Index = index;
+        TargetIndex = targetIndex;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ChangePositionMove(this, cloner);
+    }
+
+    public override MultiComponentVectorEncoding GetVectorAfterMove() {
+      return GetVectorAfterMove(MultiComponentVector, Index, TargetIndex);
+    }
+    public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int index, int targetIndex) {
+      var result = multiComponentVector.Clone(new Cloner()) as MultiComponentVectorEncoding;
+      var aux = result.PackingInformations[index];
+      result.PackingInformations.RemoveAt(index);
+      result.PackingInformations.Insert(targetIndex, aux);
+      return result;
+    }
+
+    public override System.Type GetMoveAttributeType() {
+      return typeof(ChangePositionMoveAttribute);
+    }
+
+    public override string ToString() {
+      return "PM(i=" + Index + ",ti=" + TargetIndex + ")";
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/MCVTripleMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/MCVTripleMove.cs	(revision 9473)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/MCVTripleMove.cs	(revision 9473)
@@ -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.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("MCVTripleMove", "A move on a multi component vector that is specified by a rotation-value, two indexes and a groupNr.")]
+  [StorableClass]
+  public class MCVTripleMove : MultiComponentVectorMove {
+    [Storable]
+    public int Index { get; protected set; }
+    [Storable]
+    public bool Rotation { get; protected set; }
+    [Storable]
+    public int Group { get; protected set; }
+    [Storable]
+    public int TargetIndex { get; protected set; }
+
+    [StorableConstructor]
+    protected MCVTripleMove(bool deserializing) : base(deserializing) { }
+    protected MCVTripleMove(MCVTripleMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index = original.Index;
+      this.Rotation = original.Rotation;
+      this.Group = original.Group;
+      this.TargetIndex = original.TargetIndex;
+    }
+    public MCVTripleMove(int index, bool rotation, int group, int targetIndex, MultiComponentVectorEncoding multiComponentVector)
+      : base(multiComponentVector) {
+        Index = index;
+        Rotation = rotation;
+        Group = group;
+        TargetIndex = targetIndex;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MCVTripleMove(this, cloner);
+    }
+
+    public override MultiComponentVectorEncoding GetVectorAfterMove() {
+      var result = MultiComponentVector;
+      if (Rotation)
+        result = SingleItemRotationMove.GetVectorAfterMove(MultiComponentVector, Index);
+      if (!MultiComponentVector.PackingInformations[Index].AssignedBin.Equals(Group))
+        result = SingleGroupingMove.GetVectorAfterMove(result, Index, Group);
+      if (!Index.Equals(TargetIndex))
+        result = ChangePositionMove.GetVectorAfterMove(result, Index, TargetIndex);
+      return result;
+    }
+
+    public override System.Type GetMoveAttributeType() {
+      return typeof(MCVTripleMoveAttribute);
+    }
+
+    public override string ToString() {
+      return "TM(i=" + Index + ",r=" + Rotation + ",g=" + Group + ",ti=" + TargetIndex + ")";
+    }
+  }
+}
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 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SingleGroupingMove.cs	(revision 9473)
@@ -30,5 +30,5 @@
   public class SingleGroupingMove : MultiComponentVectorMove {
     [Storable]
-    public int ItemIndex { get; protected set; }
+    public int Index { get; protected set; }
     [Storable]
     public int NewGroup { get; protected set; }
@@ -38,10 +38,10 @@
     protected SingleGroupingMove(SingleGroupingMove original, Cloner cloner)
       : base(original, cloner) {
-      this.ItemIndex = original.ItemIndex;
+      this.Index = original.Index;
       this.NewGroup = original.NewGroup;
     }
     public SingleGroupingMove(int index, int newGroup, MultiComponentVectorEncoding multiComponentVector)
       : base(multiComponentVector) {
-      ItemIndex = index;
+      Index = index;
       NewGroup = newGroup;
     }
@@ -52,11 +52,8 @@
 
     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);
+      return GetVectorAfterMove(MultiComponentVector, Index, NewGroup);
     }
-    private MultiComponentVectorEncoding InsertItemgeneAfterLastItemgeneOfUsedBin(MultiComponentVectorEncoding solution, int itemIndex, int binNr) {
+    public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding originalSolution, int itemIndex, int binNr) {
+      var solution = originalSolution.Clone (new Cloner()) as MultiComponentVectorEncoding;
       var itemgene = solution.PackingInformations[itemIndex];
       solution.PackingInformations.Remove(itemgene);
@@ -64,4 +61,5 @@
       int targetIndex = solution.PackingInformations.FindLastIndex(pi => pi.AssignedBin == binNr);
       solution.PackingInformations.Insert(targetIndex + 1, itemgene);
+      //solution.PackingInformations[itemIndex].AssignedBin = binNr;
       return solution;
     }
@@ -70,4 +68,8 @@
       return typeof(SingleGroupingMoveAttribute);
     }
+
+    public override string ToString() {
+      return "GM(i="+Index+",g="+NewGroup+")";
+    }
   }
 }
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 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SingleItemRotationMove.cs	(revision 9473)
@@ -48,7 +48,9 @@
 
     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 GetVectorAfterMove (MultiComponentVector, ItemIndex);
+    }
+    public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int itemIndex) {
+      var result = multiComponentVector.Clone(new Cloner()) as MultiComponentVectorEncoding;
+      result.PackingInformations[itemIndex].Rotated = !result.PackingInformations[itemIndex].Rotated;
       return result;
     }
@@ -57,4 +59,8 @@
       return typeof(SingleItemRotationMoveAttribute);
     }
+
+    public override string ToString() {
+      return "RM(i=" + ItemIndex+")";
+    }
   }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SwapPositionMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SwapPositionMove.cs	(revision 9473)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SwapPositionMove.cs	(revision 9473)
@@ -0,0 +1,72 @@
+﻿#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("SwapPositionMove", "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 SwapPositionMove : MultiComponentVectorMove {
+    [Storable]
+    public int Index1 { get; protected set; }
+    [Storable]
+    public int Index2 { get; protected set; }
+
+    [StorableConstructor]
+    protected SwapPositionMove(bool deserializing) : base(deserializing) { }
+    protected SwapPositionMove(SwapPositionMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index1 = original.Index1;
+      this.Index2 = original.Index2;
+    }
+    public SwapPositionMove(int index1, int index2, MultiComponentVectorEncoding multiComponentVector)
+      : base(multiComponentVector) {
+        Index1 = index1;
+        Index2 = index2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SwapPositionMove(this, cloner);
+    }
+
+    public override MultiComponentVectorEncoding GetVectorAfterMove() {
+      return GetVectorAfterMove(MultiComponentVector, Index1, Index2);
+    }
+    public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int index1, int index2) {
+      var result = multiComponentVector.Clone(new Cloner()) as MultiComponentVectorEncoding;
+      var aux = result.PackingInformations[index1];
+      result.PackingInformations[index1] = result.PackingInformations[index2];
+      result.PackingInformations[index2] = aux;
+      return result;
+    }
+
+    public override System.Type GetMoveAttributeType() {
+      return typeof(SwapPositionMoveAttribute);
+    }
+
+    public override string ToString() {
+      return "SM(i1=" + Index1 + ",i2=" + Index2 + ")";
+    }
+  }
+}
Index: anches/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 9472)
+++ 	(revision )
@@ -1,66 +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 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 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveGenerator.cs	(revision 9473)
@@ -27,5 +27,8 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Decoders;
 using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.PackingBin;
+using HeuristicLab.Problems.BinPacking.PackingItem;
 
 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
@@ -44,5 +47,6 @@
     protected ScopeParameter CurrentScopeParameter {
       get { return (ScopeParameter)Parameters["CurrentScope"]; }
-    }
+    }               
+
 
     [StorableConstructor]
@@ -57,6 +61,7 @@
 
 
-
-
+    public static int NrOfRotationMoves(MultiComponentVectorEncoding mcv) {
+      return mcv.PackingInformations.Count;
+    }
     public static IEnumerable<MultiComponentVectorMove> GenerateRotationMoves(MultiComponentVectorEncoding multiComponentVector) {
       for (int i = 0; i < multiComponentVector.PackingInformations.Count; i++)
@@ -64,4 +69,13 @@
     }
 
+    public static int NrOfSingleGroupingMoves(MultiComponentVectorEncoding mcv) {
+      int nrOfBins = 0;
+      foreach (var pi in mcv.PackingInformations) {
+        if (pi.AssignedBin > nrOfBins)
+          nrOfBins = pi.AssignedBin;
+      }
+      nrOfBins++;
+      return mcv.PackingInformations.Count * (nrOfBins - 1);
+    }
     public static IEnumerable<MultiComponentVectorMove> GenerateSingleGroupingMoves(MultiComponentVectorEncoding multiComponentVector) {
       int nrOfBins = 0;
@@ -78,5 +92,22 @@
     }
 
-    public static IEnumerable<MultiComponentVectorMove> GenerateSwapSequenceMoves(MultiComponentVectorEncoding multiComponentVector) {
+    public static int NrOfSwapPositionMoves(MultiComponentVectorEncoding mcv) {
+      int nrOfBins = 0;
+      foreach (var pi in mcv.PackingInformations) {
+        if (pi.AssignedBin > nrOfBins)
+          nrOfBins = pi.AssignedBin;
+      }
+      nrOfBins++;
+      int[] itemsPerBin = new int[nrOfBins];
+      foreach (var pi in mcv.PackingInformations) {
+        itemsPerBin[pi.AssignedBin]++;
+      }
+      int nrOfSwapPositionMoves = 0;
+      foreach (int items in itemsPerBin) {
+        nrOfSwapPositionMoves += (items * (items - 1)) / 2;
+      }
+      return nrOfSwapPositionMoves;
+    }
+    public static IEnumerable<MultiComponentVectorMove> GenerateSwapPositionMoves(MultiComponentVectorEncoding multiComponentVector) {
       Dictionary<int, List<int>> indexesPerBin = new Dictionary<int, List<int>>();
       for (int i = 0; i < multiComponentVector.PackingInformations.Count; i++) {
@@ -89,8 +120,39 @@
         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);
+            yield return new SwapPositionMove(entry.Value[i], entry.Value[j], multiComponentVector);
       }
     }
 
+    public static int NrOfChangePositionMoves(MultiComponentVectorEncoding mcv) {
+      int nrOfBins = 0;
+      foreach (var pi in mcv.PackingInformations) {
+        if (pi.AssignedBin > nrOfBins)
+          nrOfBins = pi.AssignedBin;
+      }
+      nrOfBins++;
+      int[] itemsPerBin = new int[nrOfBins];
+      foreach (var pi in mcv.PackingInformations) {
+        itemsPerBin[pi.AssignedBin]++;
+      }
+      int nrOfSwapPositionMoves = 0;
+      foreach (int items in itemsPerBin) {
+        nrOfSwapPositionMoves += (items * (items - 1)) / 2;
+      }
+      return nrOfSwapPositionMoves;
+    }
+    public static IEnumerable<MultiComponentVectorMove> GenerateChangePositionMoves(MultiComponentVectorEncoding multiComponentVector) {
+      Dictionary<int, List<int>> indexesPerBin = new Dictionary<int, List<int>>();
+      for (int i = 0; i < multiComponentVector.PackingInformations.Count; i++) {
+        int currentBin = multiComponentVector.PackingInformations[i].AssignedBin;
+        if (!indexesPerBin.ContainsKey(currentBin))
+          indexesPerBin[currentBin] = new List<int>();
+        indexesPerBin[currentBin].Add(i);
+      }
+      foreach (var entry in indexesPerBin) {
+        for (int i = 0; i < entry.Value.Count - 1; i++)
+          for (int j = i + 1; j < entry.Value.Count; j++)
+            yield return new ChangePositionMove(entry.Value[i], entry.Value[j], multiComponentVector);
+      }
+    }
 
     public override IOperation Apply() {
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 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveHardTabuCriterion.cs	(revision 9473)
@@ -94,7 +94,9 @@
     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;
+      SingleItemRotationMove sirm = move as SingleItemRotationMove;
+      SingleGroupingMove sgm = move as SingleGroupingMove;
+      SwapPositionMove spm = move as SwapPositionMove;
+      ChangePositionMove cpm = move as ChangePositionMove;
+      MCVTripleMove tm = move as MCVTripleMove;
       var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType()));
 
@@ -102,4 +104,6 @@
         foreach (IItem tabuMove in attributes) {
           SingleItemRotationMoveAttribute sirmAttr = (tabuMove as SingleItemRotationMoveAttribute);
+          if (sirmAttr.MoveQuality.Equals(moveQuality))
+            return true;
           if (sirmAttr != null
             && (!useAspiration
@@ -114,24 +118,62 @@
         foreach (IItem tabuMove in attributes) {
           SingleGroupingMoveAttribute sgmAttr = (tabuMove as SingleGroupingMoveAttribute);
+          if (sgmAttr.MoveQuality.Equals(moveQuality))
+            return true;
           if (sgmAttr != null
             && (!useAspiration
                 || maximization && moveQuality <= sgmAttr.MoveQuality
                 || !maximization && moveQuality >= sgmAttr.MoveQuality)) {
-                  if (sgm.ItemIndex == sgmAttr.ItemIndex || multiComponentVector.PackingInformations[sgm.ItemIndex].AssignedBin == sgmAttr.AssignedBin)
+                  if ( multiComponentVector.PackingInformations[sgm.Index].ItemIndex ==  multiComponentVector.PackingInformations[sgmAttr.Index].ItemIndex
+                    || multiComponentVector.PackingInformations[sgm.Index].AssignedBin == sgmAttr.AssignedBin)
                     isTabu = true;
           }
           if (isTabu) break;
         }
-      } else if (ssm != null) {
+      } else if (spm != null) {
         foreach (IItem tabuMove in attributes) {
-          SwapSequenceMoveAttribute ssmAttr = (tabuMove as SwapSequenceMoveAttribute);
-          if (ssmAttr != null
+          SwapPositionMoveAttribute spmAttr = (tabuMove as SwapPositionMoveAttribute);
+          if (spmAttr.MoveQuality.Equals(moveQuality))
+            return true;
+          if (spmAttr != 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)
+                || maximization && moveQuality <= spmAttr.MoveQuality
+                || !maximization && moveQuality >= spmAttr.MoveQuality)) {
+            if (spm.Index1 == spmAttr.Index1
+              || spm.Index2 == spmAttr.Index2
+              || multiComponentVector.PackingInformations[spm.Index1].ItemIndex == spmAttr.ItemIndex1
+              || multiComponentVector.PackingInformations[spm.Index2].ItemIndex == spmAttr.ItemIndex2)
+              isTabu = true;
+          }
+          if (isTabu) break;
+        }
+      } else if (cpm != null) {
+        foreach (IItem tabuMove in attributes) {
+          ChangePositionMoveAttribute cpmAttr = (tabuMove as ChangePositionMoveAttribute);
+          if (cpmAttr.MoveQuality.Equals(moveQuality))
+            return true;
+          if (cpmAttr != null
+            && (!useAspiration
+                || maximization && moveQuality <= cpmAttr.MoveQuality
+                || !maximization && moveQuality >= cpmAttr.MoveQuality)) {
+            if (cpm.Index == cpmAttr.Index
+        || cpm.TargetIndex == cpmAttr.TargetIndex
+        || multiComponentVector.PackingInformations[cpm.Index].ItemIndex == cpmAttr.ItemIndex)
+              isTabu = true;
+          }
+          if (isTabu) break;
+        }
+      } else if (tm != null) {
+        foreach (IItem tabuMove in attributes) {
+          MCVTripleMoveAttribute tmAttr = (tabuMove as MCVTripleMoveAttribute);
+          if (tmAttr.MoveQuality.Equals(moveQuality))
+            return true;
+          if (tmAttr != null
+            && (!useAspiration
+                || maximization && moveQuality <= tmAttr.MoveQuality
+                || !maximization && moveQuality >= tmAttr.MoveQuality)) {
+                  if ((tm.Index == tmAttr.Index && tm.TargetIndex == tmAttr.TargetIndex)
+                      || tm.Index == tmAttr.Index
+                      || multiComponentVector.PackingInformations[tm.Index].ItemIndex == tmAttr.ItemIndex
+                    )
               isTabu = true;
           }
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 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveMaker.cs	(revision 9473)
@@ -66,9 +66,9 @@
     public override IOperation Apply() {
       MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;
-      MultiComponentVectorEncoding MultiComponentVector = MultiComponentVectorParameter.ActualValue;
+      MultiComponentVectorEncoding multiComponentVector = MultiComponentVectorParameter.ActualValue;
       DoubleValue moveQuality = MoveQualityParameter.ActualValue;
       DoubleValue quality = QualityParameter.ActualValue;
 
-      MultiComponentVector = move.GetVectorAfterMove();
+      multiComponentVector.PackingInformations = move.GetVectorAfterMove().PackingInformations;
 
       quality.Value = moveQuality.Value;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveSoftTabuCriterion.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveSoftTabuCriterion.cs	(revision 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveSoftTabuCriterion.cs	(revision 9473)
@@ -65,5 +65,5 @@
     public MultiComponentVectorMoveSoftTabuCriterion()
       : base() {
-        Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "The move to evaluate."));
+      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."));
@@ -94,7 +94,10 @@
     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;
+
+      SingleItemRotationMove sirm = move as SingleItemRotationMove;
+      SingleGroupingMove sgm = move as SingleGroupingMove;
+      SwapPositionMove spm = move as SwapPositionMove;
+      ChangePositionMove cpm = move as ChangePositionMove;
+      MCVTripleMove tm = move as MCVTripleMove;
       var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType()));
 
@@ -106,6 +109,6 @@
                 || maximization && moveQuality <= sirmAttr.MoveQuality
                 || !maximization && moveQuality >= sirmAttr.MoveQuality)) {
-                  if (sirm.ItemIndex == sirmAttr.ItemIndex && multiComponentVector.PackingInformations[sirm.ItemIndex].Rotated == sirmAttr.ItemRotation)
-                    isTabu = true;
+            if (sirm.ItemIndex == sirmAttr.ItemIndex && multiComponentVector.PackingInformations[sirm.ItemIndex].Rotated == sirmAttr.ItemRotation)
+              isTabu = true;
           }
           if (isTabu) break;
@@ -118,20 +121,51 @@
                 || maximization && moveQuality <= sgmAttr.MoveQuality
                 || !maximization && moveQuality >= sgmAttr.MoveQuality)) {
-                  if (sgm.ItemIndex == sgmAttr.ItemIndex && multiComponentVector.PackingInformations[sgm.ItemIndex].AssignedBin == sgmAttr.AssignedBin)
-                    isTabu = true;
+                  if (multiComponentVector.PackingInformations[sgm.Index].ItemIndex == multiComponentVector.PackingInformations[sgmAttr.Index].ItemIndex 
+              && multiComponentVector.PackingInformations[sgm.Index].AssignedBin == sgmAttr.AssignedBin)
+              isTabu = true;
           }
           if (isTabu) break;
         }
-      } else if (ssm != null) {
+      } else if (spm != null) {
         foreach (IItem tabuMove in attributes) {
-          SwapSequenceMoveAttribute ssmAttr = (tabuMove as SwapSequenceMoveAttribute);
-          if (ssmAttr != null
+          SwapPositionMoveAttribute spmAttr = (tabuMove as SwapPositionMoveAttribute);
+          if (spmAttr != 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)
+                || maximization && moveQuality <= spmAttr.MoveQuality
+                || !maximization && moveQuality >= spmAttr.MoveQuality)) {
+            if (spm.Index1 == spmAttr.Index1
+              && spm.Index2 == spmAttr.Index2
+              && multiComponentVector.PackingInformations[spm.Index1].ItemIndex == spmAttr.ItemIndex1
+              && multiComponentVector.PackingInformations[spm.Index2].ItemIndex == spmAttr.ItemIndex2)
+              isTabu = true;
+          }
+          if (isTabu) break;
+        }
+      } else if (cpm != null) {
+        foreach (IItem tabuMove in attributes) {
+          ChangePositionMoveAttribute cpmAttr = (tabuMove as ChangePositionMoveAttribute);
+          if (cpmAttr != null
+            && (!useAspiration
+                || maximization && moveQuality <= cpmAttr.MoveQuality
+                || !maximization && moveQuality >= cpmAttr.MoveQuality)) {
+            if (cpm.Index == cpmAttr.Index
+        && cpm.TargetIndex == cpmAttr.TargetIndex
+        && multiComponentVector.PackingInformations[cpm.Index].ItemIndex == cpmAttr.ItemIndex)
+              isTabu = true;
+          }
+          if (isTabu) break;
+        }
+      } else if (tm != null) {
+        foreach (IItem tabuMove in attributes) {
+          MCVTripleMoveAttribute tmAttr = (tabuMove as MCVTripleMoveAttribute);
+          if (tmAttr != null
+            && (!useAspiration
+                || maximization && moveQuality <= tmAttr.MoveQuality
+                || !maximization && moveQuality >= tmAttr.MoveQuality)) {
+            if ((tm.Index == tmAttr.Index && tm.TargetIndex == tmAttr.TargetIndex)
+                && multiComponentVector.PackingInformations[tm.Index].ItemIndex == tmAttr.ItemIndex
+                && tm.Rotation == !(tmAttr.RotationAfter.Equals(tmAttr.RotationBefore))
+                && (tm.Group == tmAttr.GroupAfter && multiComponentVector.PackingInformations[tm.Index].AssignedBin == tmAttr.GroupBefore)
+              )
               isTabu = true;
           }
@@ -140,5 +174,5 @@
       } 
 
-      
+
 
       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 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorTabuMaker.cs	(revision 9473)
@@ -64,8 +64,22 @@
       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);
+        return new SingleGroupingMoveAttribute(sgm.Index, solution.PackingInformations[sgm.Index].AssignedBin, baseQuality);
+      SwapPositionMove spm = move as SwapPositionMove;
+      if (spm != null)
+        return new SwapPositionMoveAttribute(spm.Index1, spm.Index2, solution.PackingInformations[spm.Index1].ItemIndex, solution.PackingInformations[spm.Index2].ItemIndex, baseQuality);
+      ChangePositionMove cpm = move as ChangePositionMove;
+      if (cpm != null)
+        return new ChangePositionMoveAttribute(cpm.Index, cpm.TargetIndex, solution.PackingInformations[cpm.Index].ItemIndex, baseQuality);
+      MCVTripleMove tm = move as MCVTripleMove;
+      if (tm != null)
+        return new MCVTripleMoveAttribute(
+          tm.Index, 
+          tm.TargetIndex,
+          solution.PackingInformations[tm.Index].ItemIndex,
+          solution.PackingInformations[tm.Index].Rotated,
+          tm.Rotation ^ solution.PackingInformations[tm.Index].Rotated,
+          solution.PackingInformations[tm.Index].AssignedBin,
+          tm.Group,
+          baseQuality);
 
       else return solution;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/StochasticMCVTripleMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/StochasticMCVTripleMoveGenerator.cs	(revision 9473)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/StochasticMCVTripleMoveGenerator.cs	(revision 9473)
@@ -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.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector {
+  [Item("Stochastic MultiComponentVector Triple Move Generator", "Generates all possible multi component moves from a given multiComponentVector.")]
+  [StorableClass]
+  public class StochasticMCVTripleMoveGenerator : 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 StochasticMCVTripleMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticMCVTripleMoveGenerator(StochasticMCVTripleMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticMCVTripleMoveGenerator()
+      : 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 StochasticMCVTripleMoveGenerator(this, cloner);
+    }
+
+    public static List<MultiComponentVectorMove> GenerateMCVTripleMoves(MultiComponentVectorEncoding mcv, IRandom random, int sampleSize) {
+      var result = new List<MultiComponentVectorMove>();
+      var moves = new List<MultiComponentVectorMove> (ExhaustiveMCVTripleMoveGenerator.GenerateMCVTripleMoves(mcv));
+      int moveCount = moves.Count;
+      for (int i = 0; i < sampleSize; i++) {
+        result.Add(moves [random.Next(moveCount)]);
+      }
+      return result;
+    }
+
+    public static MultiComponentVectorMove[] Apply(MultiComponentVectorEncoding multiComponentVector, IRandom random, int sampleSize) {
+      var generatedMoves = GenerateMCVTripleMoves(multiComponentVector, random, sampleSize);
+      int totalMoves = generatedMoves.Count;
+      MultiComponentVectorMove[] moves = new MultiComponentVectorMove[totalMoves];
+      int count = 0;
+      foreach (MultiComponentVectorMove move in generatedMoves) {
+        moves[count++] = move;
+      }
+      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/Moves/ThreeWay/StochasticMultiComponentVectorMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/StochasticMultiComponentVectorMoveGenerator.cs	(revision 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/StochasticMultiComponentVectorMoveGenerator.cs	(revision 9473)
@@ -60,9 +60,10 @@
       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));
+      var gm = new List<MultiComponentVectorMove>(GenerateSingleGroupingMoves(multiComponentVector));
+      var sm = new List<MultiComponentVectorMove>(GenerateSwapPositionMoves(multiComponentVector));
+      var cpm = new List<MultiComponentVectorMove>(GenerateChangePositionMoves(multiComponentVector));
 
       for (int i = 0; i < sampleSize; i++) {
-        int typeDecision = random.Next(3);
+        int typeDecision = random.Next(4);
         switch (typeDecision) {
           case 0: moves[i] = rm[random.Next(rm.Count)];
@@ -71,4 +72,6 @@
             break;
           case 2: moves[i] = sm[random.Next(sm.Count)];
+            break;
+          case 3: moves[i] = cpm[random.Next(cpm.Count)];
             break;
           default:
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 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorEncoding.cs	(revision 9473)
@@ -68,5 +68,5 @@
       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++) {
+        for (int i = 0; i < mce.PackingInformations.Count; i++) {
           if (mce.PackingInformations[i] != this.PackingInformations[i])
             return false;
@@ -134,5 +134,14 @@
       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));
+        result.Add(new PackingInformation(itemIndex, random.Next(0, lowerBound + 1), random.Next(0, 100) > 60 ? true : false));
+      }
+      return result;
+    }
+
+    public static ItemList<PackingInformation> CreateListRandomlyWithSortedSequence(int items, int lowerBound, IRandom random) {
+      Permutation permutation = new Permutation(PermutationTypes.Absolute, items);
+      var result = new ItemList<PackingInformation>();
+      foreach (int itemIndex in permutation) {
+        result.Add(new PackingInformation(itemIndex, random.Next(0, lowerBound + 1), false));
       }
       return result;
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorRandomCreator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorRandomCreator.cs	(revision 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorRandomCreator.cs	(revision 9473)
@@ -43,4 +43,7 @@
 			get { return (IValueLookupParameter<IntValue>)Parameters["LowerBound"]; }
 		}
+		public IValueParameter<BoolValue> SortedSequenceParameter {
+			get { return (IValueParameter<BoolValue>)Parameters["SortedSequence"]; }
+		}
 
 		[StorableConstructor]
@@ -52,22 +55,27 @@
 		}
 
-    public MultiComponentVectorRandomCreator()
+		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)"));
+			Parameters.Add(new ValueParameter<BoolValue>("SortedSequence", "Determines if the items of the created instances are to be sorted by their size."));
 
 			EncodedSolutionParameter.ActualName = "MultiComponentVector";
+			SortedSequenceParameter.ActualValue = new BoolValue(false);
 		}
 
 
-    public static MultiComponentVectorEncoding Apply(int items, int lowerBound, IRandom random) {
+		public static MultiComponentVectorEncoding Apply(int items, int lowerBound, IRandom random, bool sortedSequence) {
 			var solution = new MultiComponentVectorEncoding();
-      solution.PackingInformations = PackingInformation.CreateListRandomly(items, lowerBound, random);
+			if (sortedSequence)
+				solution.PackingInformations = PackingInformation.CreateListRandomlyWithSortedSequence(items, lowerBound, random);
+			else
+				solution.PackingInformations = PackingInformation.CreateListRandomly(items, lowerBound, random);
 			return solution;
 		}
 
 		protected override IPackingSolutionEncoding CreateSolution() {
-			return Apply(PackingItemsParameter.ActualValue.Value, LowerBoundParameter.ActualValue.Value, RandomParameter.ActualValue);
+			return Apply(PackingItemsParameter.ActualValue.Value, LowerBoundParameter.ActualValue.Value, RandomParameter.ActualValue, SortedSequenceParameter.Value.Value);
 		}
 	}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/Potvin/PotvinCrossover.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/Potvin/PotvinCrossover.cs	(revision 9473)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/Potvin/PotvinCrossover.cs	(revision 9473)
@@ -0,0 +1,99 @@
+﻿#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.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.Potvin {
+  [Item("Potvin Encoding Crossover", "An operator which crosses two Potvin representations. According to RBX by Potvin.")]
+  [StorableClass]
+  public class PotvinCrossover : PackingSolutionCrossover, IPotvinOperator {
+
+    [StorableConstructor]
+    protected PotvinCrossover(bool deserializing) : base(deserializing) { }
+    protected PotvinCrossover(PotvinCrossover original, Cloner cloner) : base(original, cloner) { }
+    public PotvinCrossover()
+      : base() {
+        ParentsParameter.ActualName = "Potvin";
+        ChildParameter.ActualName = "Potvin";
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinCrossover(this, cloner);
+    }
+
+    public PotvinEncoding Cross(IRandom random, PotvinEncoding parent1, PotvinEncoding parent2) {
+      PotvinEncoding child = parent2.Clone() as PotvinEncoding;
+
+      if (parent1.NrOfBins > 0 && child.NrOfBins > 0) {
+        int tourParent1 = random.Next(parent1.NrOfBins);
+        List<int> replacing = parent1.GetItemsInBin(tourParent1);
+
+        int tourParent2 = random.Next(child.NrOfBins);
+        List<int> replaced = child.GetItemsInBin(tourParent2);
+
+        child.Tours.Remove(replaced);
+        child.Tours.Insert(tourParent2, replacing);
+
+        Permutation vehicleAssignment = child.VehicleAssignment;
+
+        int vehicle = vehicleAssignment[tourParent2];
+        int vehicle2 = parent1.VehicleAssignment[tourParent1];
+        vehicleAssignment[tourParent2] = vehicle2;
+
+        for (int i = 0; i < vehicleAssignment.Length; i++) {
+          if (vehicleAssignment[i] == vehicle2 && i != tourParent2) {
+            vehicleAssignment[i] = vehicle;
+            break;
+          }
+        }
+
+        foreach (int city in replaced.Stops)
+          if (FindRoute(child, city) == null && !child.Unrouted.Contains(city))
+            child.Unrouted.Add(city);
+
+        if (Repair(random, child, replacing, problemInstance, allowInfeasible) || allowInfeasible)
+          return child;
+        else {
+          if (random.NextDouble() < 0.5)
+            return parent1.Clone() as PotvinEncoding;
+          else
+            return parent2.Clone() as PotvinEncoding;
+        }
+      } else {
+        return child;
+      }
+    }
+
+    public override IOperation Apply() {
+      var parents = ParentsParameter.ActualValue;
+
+      ChildParameter.ActualValue =
+        Cross(RandomParameter.ActualValue, parents[0] as PotvinEncoding, parents[1] as PotvinEncoding);
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/Potvin/PotvinEncoding.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/Potvin/PotvinEncoding.cs	(revision 9473)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/Potvin/PotvinEncoding.cs	(revision 9473)
@@ -0,0 +1,118 @@
+﻿#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 System.Text;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.Potvin {
+  [Item("Potvin Encoding", "Represents an encoding for a bin packing problem using a delimited permutation of item-indexes.")]
+  [StorableClass]
+  public class PotvinEncoding : Item, IPackingSolutionEncoding{
+
+    [Storable]
+    public IntegerVector IntVector { get; set; }
+    [Storable]
+    public bool DelimiterInitialized { get; set; }
+
+    private int nrOfBins = -1;
+    public int NrOfBins { 
+      get { 
+        if (nrOfBins < 0) { 
+          nrOfBins = 1;
+          foreach (int i in IntVector) {
+            if (i == -1)
+              nrOfBins++;
+          }
+        }
+        return nrOfBins;
+      } 
+    }
+
+    public List<int> GetItemsInBin(int binNr) {
+      int binCount = 0;
+      List<int> result = new List<int> ();
+      foreach (int i in IntVector) {
+        if (i == -1) {
+          binCount++;
+          if (binCount > binNr)
+            break;
+        }
+        if (binCount == binNr)
+          result.Add(i);
+      }
+      return result;
+    }
+
+    [StorableConstructor]
+    protected PotvinEncoding(bool deserializing) : base(deserializing) { }
+    protected PotvinEncoding(PotvinEncoding original, Cloner cloner)
+      : base(original, cloner) {
+        this.IntVector = cloner.Clone(original.IntVector);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinEncoding(this, cloner);
+    }
+
+    public PotvinEncoding()
+      : base() {
+        IntVector = new IntegerVector();
+        DelimiterInitialized = false;
+    }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      sb.Append("[ ");
+      sb.Append(IntVector.ToString());         
+      sb.Append("]");
+      return sb.ToString();
+    }
+
+
+    public override bool Equals(object obj) {
+      if (obj.GetType() == typeof(PotvinEncoding))
+        return AreEqual(this, obj as PotvinEncoding);
+
+      return false;
+    }
+    public override int GetHashCode() {
+      return IntVector.GetHashCode();
+    }
+    private static bool AreEqual(PotvinEncoding PotvinEncoding1, PotvinEncoding PotvinEncoding2) {
+      return AreEqual(PotvinEncoding1.IntVector, PotvinEncoding2.IntVector);
+    }
+
+    private static bool AreEqual(IntArray v1, IntArray v2) {
+      if (v1.Length != v2.Length)
+        return false;
+      for (int i = 0; i < v1.Length; i++) {
+        if (v1[i] != v2[i])
+          return false;
+      }
+      return true;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/Potvin/PotvinManipulator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/Potvin/PotvinManipulator.cs	(revision 9473)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/Potvin/PotvinManipulator.cs	(revision 9473)
@@ -0,0 +1,111 @@
+﻿#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.Potvin {
+  [Item("Potvin Encoding Manipulator", "An operator which manipulates a Potvin representation.")]
+  [StorableClass]
+  public class PotvinManipulator : PackingSolutionManipulator, IPotvinOperator {
+    [StorableConstructor]
+    protected PotvinManipulator(bool deserializing) : base(deserializing) { }
+    protected PotvinManipulator(PotvinManipulator original, Cloner cloner) : base(original, cloner) { }
+    public PotvinManipulator()
+      : base() {
+        EncodedSolutionParameter.ActualName = "Potvin";
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PotvinManipulator(this, cloner);
+    }
+
+    protected int SelectRandomTourBiasedByLength(IRandom random, PotvinEncoding individual) {
+      int tourIndex = -1;
+
+      double sum = 0.0;
+      double[] probabilities = new double[individual.Tours.Count];
+      for (int i = 0; i < individual.Tours.Count; i++) {
+        probabilities[i] = 1.0 / ((double)individual.Tours[i].Stops.Count / (double)ProblemInstance.Cities.Value);
+        sum += probabilities[i];
+      }
+
+      for (int i = 0; i < probabilities.Length; i++)
+        probabilities[i] = probabilities[i] / sum;
+
+      double rand = random.NextDouble();
+      double cumulatedProbabilities = 0.0;
+      int index = 0;
+      while (tourIndex == -1 && index < probabilities.Length) {
+        if (cumulatedProbabilities <= rand && rand <= cumulatedProbabilities + probabilities[index])
+          tourIndex = index;
+
+        cumulatedProbabilities += probabilities[index];
+        index++;
+      }
+
+      return tourIndex;
+    }
+
+    protected bool FindInsertionPlace(PotvinEncoding individual, int city, int routeToAvoid, bool allowInfeasible, out int route, out int place) {
+      return individual.FindInsertionPlace(
+        city, routeToAvoid, allowInfeasible, out route, out place);
+    }
+
+    protected void Manipulate(IRandom random, PotvinEncoding individual) {
+
+      int selectedIndex = SelectRandomTourBiasedByLength(random, individual);
+      if (selectedIndex >= 0) {
+        Tour route1 =
+          individual.Tours[selectedIndex];
+
+        int count = route1.Stops.Count;
+        int i = 0;
+        while (i < count) {
+          int insertedRoute, insertedPlace;
+
+          int city = route1.Stops[i];
+          route1.Stops.Remove(city);
+
+          if (FindInsertionPlace(individual, city, selectedIndex, allowInfeasible, out insertedRoute, out insertedPlace)) {
+            individual.Tours[insertedRoute].Stops.Insert(insertedPlace, city);
+          } else {
+            route1.Stops.Insert(i, city);
+            i++;
+          }
+
+          count = route1.Stops.Count;
+        }
+      }
+    }
+
+    public override IOperation Apply() {
+      var solution = EncodedSolutionParameter.ActualValue as PotvinEncoding;
+      if (solution == null) throw new InvalidOperationException("PackingSolutionEncoding was not found or is not of type PotvinEncoding.");
+      Manipulate(RandomParameter.ActualValue, solution);
+      return base.Apply();
+    }
+
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/Potvin/PotvinRandomCreator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/Potvin/PotvinRandomCreator.cs	(revision 9473)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/Potvin/PotvinRandomCreator.cs	(revision 9473)
@@ -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.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+
+namespace HeuristicLab.Encodings.PackingEncoding.Potvin {
+	[Item("PotvinCreator", "Creator class used to create Potvin-Encoding solutions for bin packing problems.")]
+	[StorableClass]
+	public class PotvinRandomCreator : PackingSolutionCreator, IStochasticOperator {
+
+		public ILookupParameter<IRandom> RandomParameter {
+			get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+		}
+		public IValueLookupParameter<IntValue> PackingItemsParameter {
+			get { return (IValueLookupParameter<IntValue>)Parameters["PackingItems"]; }
+		}
+
+		[StorableConstructor]
+		protected PotvinRandomCreator(bool deserializing) : base(deserializing) { }
+		protected PotvinRandomCreator(PotvinRandomCreator original, Cloner cloner) : base(original, cloner) {
+		}
+		public override IDeepCloneable Clone(Cloner cloner) {
+			return new PotvinRandomCreator(this, cloner);
+		}
+
+    public PotvinRandomCreator()
+			: 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."));
+
+			EncodedSolutionParameter.ActualName = "Potvin";
+		}
+
+
+    public static PotvinEncoding Apply(int items, IRandom random) {
+      var solution = new PotvinEncoding();
+		  solution.IntVector = new IntegerVector(new Permutation(PermutationTypes.Absolute, items, random));
+			return solution;
+		}
+
+		protected override IPackingSolutionEncoding CreateSolution() {
+			return Apply(PackingItemsParameter.ActualValue.Value, RandomParameter.ActualValue);
+		}
+	}
+}
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 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingRatioRegularIdenticalBinEvaluator.cs	(revision 9473)
@@ -93,5 +93,5 @@
         double usedSpaceInThisBin = packedItemsInThisBin.Select(s => s.Value.MultipliedMeasures).Sum();
         //k = 2 --> (Fi/C)*(Fi/C)
-        result += (((usedSpaceInThisBin) / (usableSpace)) * ((usedSpaceInThisBin) / (usableSpace))) / (i + 1);
+        result += (((usedSpaceInThisBin) / (usableSpace)) * ((usedSpaceInThisBin) / (usableSpace))) / (i*i + 1);
       }
 
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 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 9473)
@@ -176,4 +176,7 @@
     <Compile Include="Decoders\3D\DBL\DeepestBottomLeftMultiComponentVectorDecoder.cs" />
     <Compile Include="Decoders\3D\DBL\DeepestBottomLeftFunctions.cs" />
+    <Compile Include="Decoders\3D\EP\ExtremePointPotvinDecoder3D.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Decoders\3D\EP\ExtremePointsFunctions3D.cs" />
     <Compile Include="Decoders\3D\DBL\DeepestBottomLeftGroupingVectorDecoder.cs" />
@@ -196,11 +199,17 @@
     <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\ChangePositionMoveAttribute.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\MCVTripleMoveAttribute.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\SwapPositionMoveAttribute.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\StochasticMCVTripleMoveGenerator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\ExhaustiveMCVTripleMoveGenerator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Moves\ChangePositionMove.cs" />
+    <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Moves\MCVTripleMove.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\SwapPositionMove.cs" />
     <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Moves\SingleItemRotationMove.cs" />
     <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\ExhaustiveMultiComponentVectorMoveGenerator.cs" />
@@ -211,7 +220,9 @@
     <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\MultiComponentVectorTabuMaker.cs" />
     <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\StochasticMultiComponentVectorMoveGenerator.cs" />
+    <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorEncoding.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <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" />
@@ -225,4 +236,10 @@
     <Compile Include="Encodings\PackingSolutionCrossover.cs" />
     <Compile Include="Encodings\PackingSolutionManipulator.cs" />
+    <Compile Include="Encodings\Potvin\PotvinEncoding.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Encodings\Potvin\PotvinRandomCreator.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Evaluators\2D\BinUtilizationRectangularIdenticalBinEvaluator.cs" />
     <Compile Include="Evaluators\2D\PackingRatioRectangularIdenticalBinEvaluator.cs" />
@@ -240,4 +257,5 @@
     <Compile Include="Instances\BPPORLIBParser.cs" />
     <Compile Include="Instances\BPPORLIBDataDescriptor.cs" />
+    <Compile Include="Interfaces\IPotvinOperator.cs" />
     <Compile Include="Interfaces\IMultiComponentVectorMoveOperator.cs" />
     <Compile Include="Interfaces\IGroupingVectorMoveOperator.cs" />
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPotvinOperator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPotvinOperator.cs	(revision 9473)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPotvinOperator.cs	(revision 9473)
@@ -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 IPotvinOperator : IOperator {
+  }
+}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Plugin.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Plugin.cs	(revision 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Plugin.cs	(revision 9473)
@@ -26,5 +26,5 @@
   /// Plugin class for HeuristicLab.Problems.BinPacking plugin.
   /// </summary>
-  [Plugin("HeuristicLab.Problems.BinPacking", "3.3.7.9348")]
+  [Plugin("HeuristicLab.Problems.BinPacking", "3.3.7.9440")]
   [PluginFile("HeuristicLab.Problems.BinPacking-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Common", "3.3")]
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/CuboidIdenticalBinPackingProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/CuboidIdenticalBinPackingProblem.cs	(revision 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/CuboidIdenticalBinPackingProblem.cs	(revision 9473)
@@ -44,4 +44,5 @@
 using HeuristicLab.Problems.Instances;
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Encodings.PackingEncoding.Potvin;
 
 namespace HeuristicLab.Problems.BinPacking.Problem {
@@ -125,4 +126,6 @@
       } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
         PackingSolutionDecoder = new ExtremePointMultiComponentVectorDecoder3D();
+      } else if (SolutionCreator is PotvinRandomCreator) {
+        PackingSolutionDecoder = new ExtremePointPotvinDecoder3D();
       } else {
         string error = "The given problem does not support the selected solution-creator.";
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RegularIdenticalBinPackingProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RegularIdenticalBinPackingProblem.cs	(revision 9472)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RegularIdenticalBinPackingProblem.cs	(revision 9473)
@@ -43,4 +43,5 @@
 using HeuristicLab.Problems.Instances;
 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Encodings.PackingEncoding.Potvin;
 
 namespace HeuristicLab.Problems.BinPacking.Problem {
@@ -138,4 +139,7 @@
         Operators.AddRange(ApplicationManager.Manager.GetInstances<IMultiComponentVectorOperator>());
         InitializeDecoder();
+      } else if (SolutionCreator.GetType() == typeof(PotvinRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IPotvinOperator>());
+        InitializeDecoder();
       } 
     }
