Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs	(revision 14145)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/BinPacking2D.cs	(revision 14146)
@@ -120,5 +120,5 @@
     }
 
-    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<PackingItem> items) {
+    public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> items) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
@@ -131,5 +131,5 @@
       }
     }
-    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<PackingItem> items, Dictionary<int, bool> rotationArray) {
+    public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> items, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
@@ -142,5 +142,5 @@
       }
     }
-    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<PackingItem> items, bool stackingConstraints) {
+    public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
@@ -153,5 +153,5 @@
       }
     }
-    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<PackingItem> items, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
+    public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
@@ -187,5 +187,5 @@
     }
     public override bool IsStaticStable(PackingItem item, PackingPosition position) {
-      throw new NotImplementedException();
+      throw new NotSupportedException();
     }
 
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj	(revision 14145)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/HeuristicLab.Problems.BinPacking2D-3.3.csproj	(revision 14146)
@@ -163,14 +163,18 @@
   <ItemGroup>
     <Compile Include="BinPacking2D.cs" />
-    <Compile Include="Decoders\EP\ExtremePointPackingSequenceDecoder2D.cs">
-      <SubType>Code</SubType>
-    </Compile>
+    <Compile Include="BinUtilizationEvaluator.cs" />
+    <Compile Include="ExtremePointPermutationDecoder.cs" />
     <Compile Include="Instances\BPPData.cs" />
     <Compile Include="Instances\RandomDataDescriptor.cs" />
     <Compile Include="Instances\RandomInstanceProvider.cs" />
+    <Compile Include="Interfaces\IEvaluator.cs" />
+    <Compile Include="Interfaces\IPermutationDecoder.cs" />
     <Compile Include="Interfaces\I2DGVDecoder.cs" />
     <Compile Include="Interfaces\I2DMCVDecoder.cs" />
     <Compile Include="Interfaces\I2DOperator.cs" />
     <Compile Include="Interfaces\I2DPSDecoder.cs" />
+    <Compile Include="MoveEvaluators\TranslocationMoveEvaluator.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="PackingItem.cs" />
     <Compile Include="PackingPosition.cs" />
@@ -193,8 +197,5 @@
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Decoders\BL\" />
-    <Folder Include="MoveEvaluators\" />
-  </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingRatioEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingRatioEvaluator.cs	(revision 14145)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingRatioEvaluator.cs	(revision 14146)
@@ -20,18 +20,22 @@
 #endregion
 
-
+using System;
+using System.Linq;
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PackingEncoding;
 using HeuristicLab.Problems.BinPacking;
+using System.Collections.Generic;
 
 namespace HeuristicLab.Problems.BinPacking2D {
-  [Item("Packing-Ratio Evaluator (2d)", "Calculates the ratio between packed and unpacked space. Found in Falkenauer:1996")]
+  [Item("Packing-Ratio Evaluator (2d)", "Calculates the ratio between packed and unpacked space.")]
   [StorableClass]
-  public class PackingRatioEvaluator : PackingRatioEvaluator<PackingPosition, PackingShape, PackingItem> {
+  public class PackingRatioEvaluator : Item, IEvaluator {
 
     [StorableConstructor]
-    protected PackingRatioEvaluator (bool deserializing) : base(deserializing) { }
-    protected PackingRatioEvaluator (PackingRatioEvaluator original, Cloner cloner)
+    protected PackingRatioEvaluator(bool deserializing) : base(deserializing) { }
+    protected PackingRatioEvaluator(PackingRatioEvaluator original, Cloner cloner)
       : base(original, cloner) {
     }
@@ -40,4 +44,34 @@
       return new PackingRatioEvaluator(this, cloner);
     }
+
+    #region IEvaluator Members
+    public double Evaluate(Solution solution) {
+      return CalculatePackingRatio(solution);
+    }
+
+    /* 
+        Falkenauer:1996 - A Hybrid Grouping Genetic Algorithm for Bin Packing
+        
+        fBPP = (SUM[i=1..N](Fi / C)^k)/N
+        N.......the number of bins used in the solution,
+        Fi......the sum of sizes of the items in the bin i (the fill of the bin),
+        C.......the bin capacity and
+        k.......a constant, k>1.
+     */
+    public static double CalculatePackingRatio(Solution solution) {
+      int nrOfBins = solution.NrOfBins;
+      double result = 0;
+      const double k = 2;
+      for (int i = 0; i < nrOfBins; i++) {
+        var f = solution.BinPackings[i].ItemMeasures.Sum(kvp => kvp.Value.Volume);
+        var c = solution.BinPackings[i].BinMeasures.Volume;
+        result += Math.Pow(f / c, k);
+      }
+
+      result = result / nrOfBins;
+      return result;
+    }
+
+    #endregion
   }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingSequenceProblem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingSequenceProblem.cs	(revision 14145)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/PackingSequenceProblem.cs	(revision 14146)
@@ -23,7 +23,6 @@
 
 using System;
-using System.CodeDom;
+using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -31,49 +30,268 @@
 using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.BinPacking;
 using HeuristicLab.Problems.BinPacking2D;
+using HeuristicLab.Problems.Instances;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.BinPacking2d {
+  [Item("Bin Packing Problem (2D, permutation encoding) (BPP)", "Represents a two-dimensional bin-packing problem using only bins with identical measures and bins/items with rectangular shapes.")]
   [StorableClass]
   [Creatable(Category = CreatableAttribute.Categories.CombinatorialProblems, Priority = 300)]
-  public class PackingSequenceProblem : PackingSequenceProblem<Permutation, PermutationEncoding> {
+  public sealed class PackingSequenceProblem : SingleObjectiveBasicProblem<PermutationEncoding>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
+    private readonly string SolutionEvaluatorParameterName = "SolutionEvaluator";
+    #region Default Instance
+    private static readonly BPPData DefaultInstance = new BPPData() {
+      Name = "2D BPP Default Instance",
+      Description = "The default instance for 2D Bin Packing.",
+      BinShape = new PackingShape(20, 16),
+      Items = new PackingItem[] {
+        new PackingItem(3,  8, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0}
+      },
+    };
+    #endregion
+
+    #region parameter properties
+    public IValueParameter<IPermutationDecoder> DecoderParameter {
+      get { return (IValueParameter<IPermutationDecoder>)Parameters["Decoder"]; }
+    }
+    public IValueParameter<BinPacking2D.IEvaluator> SolutionEvaluatorParameter {
+      get { return (IValueParameter<BinPacking2D.IEvaluator>)Parameters[SolutionEvaluatorParameterName]; }
+    }
+    public IValueParameter<ReadOnlyItemList<PackingItem>> ItemsParameter {
+      get { return (IValueParameter<ReadOnlyItemList<PackingItem>>)Parameters["Items"]; }
+    }
+    public IValueParameter<PackingShape> BinShapeParameter {
+      get { return (IValueParameter<PackingShape>)Parameters["BinShape"]; }
+    }
+    public IValueParameter<Solution> BestKnownSolutionParameter {
+      get { return (IValueParameter<Solution>)Parameters["BestKnownSolution"]; }
+    }
+    public IFixedValueParameter<IntValue> LowerBoundParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["LowerBound"]; }
+    }
+    #endregion
+
+    #region properties
+    public IPermutationDecoder Decoder {
+      get { return DecoderParameter.Value; }
+      set { DecoderParameter.Value = value; }
+    }
+    public new BinPacking2D.IEvaluator SolutionEvaluator {
+      get { return SolutionEvaluatorParameter.Value; }
+      set { SolutionEvaluatorParameter.Value = value; }
+    }
+    public ReadOnlyItemList<PackingItem> Items {
+      get { return ItemsParameter.Value; }
+      set { ItemsParameter.Value = value; }
+    }
+    public PackingShape BinShape {
+      get { return BinShapeParameter.Value; }
+      set { BinShapeParameter.Value = value; }
+    }
+    public Solution BestKnownSolution {
+      get { return BestKnownSolutionParameter.Value; }
+      set { BestKnownSolutionParameter.Value = value; }
+    }
+    public int LowerBound {
+      get { return LowerBoundParameter.Value.Value; }
+    }
+    public int NumberOfItems {
+      get { return Items == null ? 0 : Items.Count; }
+    }
+    #endregion
 
     // persistence
     [StorableConstructor]
-    protected PackingSequenceProblem(bool deserializing) : base(deserializing) { }
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() { }
-
-    public override bool Maximization {
-      get { return true; }
-    }
-
+    private PackingSequenceProblem(bool deserializing) : base(deserializing) { }
 
     // cloning
-    protected PackingSequenceProblem(PackingSequenceProblem original, Cloner cloner)
+    private PackingSequenceProblem(PackingSequenceProblem original, Cloner cloner)
       : base(original, cloner) {
-    }
-
-    protected PackingSequenceProblem() : base() { }
-
-
+      RegisterEventHandlers();
+    }
+
+    public PackingSequenceProblem()
+      : base() {
+      var defaultEvaluator = new PackingRatioEvaluator();
+      var defaultDecoder = new ExtremePointPermutationDecoder();
+      Parameters.Add(new ValueParameter<IPermutationDecoder>("Decoder", "The decoder translates a permutation to a packing solution candidiates", defaultDecoder));
+      Parameters.Add(new ValueParameter<BinPacking2D.IEvaluator>(SolutionEvaluatorParameterName, "The evaluator calculates qualities of solution candidates", defaultEvaluator));
+      Parameters.Add(new ValueParameter<ReadOnlyItemList<PackingItem>>("Items", "The items which must be packed into bins"));
+      Parameters.Add(new ValueParameter<PackingShape>("BinShape", "The size of bins into which items must be packed"));
+      Parameters.Add(new OptionalValueParameter<Solution>("BestKnownSolution", "The best solution found so far"));
+      Parameters.Add(new FixedValueParameter<IntValue>("LowerBound", "A lower bound for the number of bins that is necessary to pack all items"));
+
+      Load(DefaultInstance);
+
+      Encoding = new PermutationEncoding("PackingSequence", Items.Count, PermutationTypes.Absolute);
+      AddOperators();
+      RegisterEventHandlers();
+    }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new PackingSequenceProblem(this, cloner);
     }
 
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEventHandlers();
+    }
+
+
+    private void AddOperators() {
+      Operators.Add(new StochasticInsertionMultiMoveGenerator());
+      Operators.Add(new ExhaustiveInsertionMoveGenerator());
+      Operators.Add(new TranslocationMoveMaker());
+      Operators.Add(new TranslocationMoveEvaluator());
+      Operators.Add(new TranslocationMoveTabuMaker());
+
+      Operators.RemoveAll(x => x is SingleObjectiveMoveGenerator);
+      Operators.RemoveAll(x => x is SingleObjectiveMoveMaker);
+      Operators.RemoveAll(x => x is SingleObjectiveMoveEvaluator);
+
+      Encoding.ConfigureOperators(Operators.OfType<IOperator>());
+    }
+
+    private void RegisterEventHandlers() {
+      // update encoding length when number of items is changed
+      ItemsParameter.ValueChanged += (sender, args) => Encoding.Length = Items.Count;
+    }
+
+    public override bool Maximization { get { return true; } }
+
 
     public override double Evaluate(Individual individual, IRandom random) {
-      var permutation = individual.Permutation();
-      var decoder = new ExtremePointPackingSequenceDecoder2D();
-      var packingPlan = decoder.CreatePackingPlanFromEncoding(permutation, Bin, Items);
-      var ratio = PackingRatioEvaluator.CalculatePackingRatio(packingPlan);
-      return ratio.Value;
+      var permutation = individual.Permutation("PackingSequence");
+      var decoder = Decoder;
+      var solution = decoder.Decode(permutation, BinShape, Items);
+      return SolutionEvaluator.Evaluate(solution);
     }
 
     public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
       base.Analyze(individuals, qualities, results, random);
-      Analyze(individuals.Select(i => i.Permutation()).ToArray(), qualities, results, random);
-    }
+      Analyze(individuals.Select(i => i.Permutation("PackingSequence")).ToArray(), qualities, results, random);
+    }
+
+    public void Analyze(Permutation[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      var bestSolutionResultName = "Best Packing Solution";
+      var numContainersResultName = "Nr of Containers";
+      var binUtilResultName = "Overall Bin Utilization";
+
+      if (!results.ContainsKey(bestSolutionResultName)) results.Add(new Result(bestSolutionResultName, typeof(Solution)));
+      if (!results.ContainsKey(numContainersResultName)) results.Add(new Result(numContainersResultName, typeof(IntValue)));
+      if (!results.ContainsKey(binUtilResultName)) results.Add(new Result(binUtilResultName, typeof(DoubleValue)));
+
+
+      // find index of item with max quality
+      int bestIdx = 0;
+      for (int j = 1; j < qualities.Length; j++)
+        if (qualities[j] > qualities[bestIdx]) bestIdx = j;
+
+
+      // update best solution so far
+      var bestSolution = results[bestSolutionResultName].Value as Solution;
+      if (bestSolution == null ||
+        bestSolution.Quality.Value < qualities[bestIdx]) {
+
+        var newBestSolution = Decoder.Decode(individuals[bestIdx], BinShape, Items);
+        newBestSolution.Quality = new DoubleValue(qualities[bestIdx]);
+        results[bestSolutionResultName].Value = newBestSolution;
+        results[numContainersResultName].Value = new IntValue(newBestSolution.NrOfBins);
+        results[binUtilResultName].Value = new DoubleValue(BinUtilizationEvaluator.CalculateBinUtilization(newBestSolution));
+
+        // update best known solution
+        var bestKnownQuality = BestKnownQualityParameter.Value;
+        if (bestKnownQuality == null ||
+            bestKnownQuality.Value < qualities[bestIdx]) {
+          BestKnownQualityParameter.ActualValue = new DoubleValue(qualities[bestIdx]);
+          BestKnownSolutionParameter.ActualValue = newBestSolution;
+        }
+      }
+    }
+
+
+    #region Problem instance handling
+    public void Load(BPPData data) {
+      BestKnownSolutionParameter.Value = null;
+      BestKnownQualityParameter.Value = null;
+
+      if (data.BestKnownQuality.HasValue)
+        BestKnownQuality = data.BestKnownQuality.Value;
+
+      BinShape = data.BinShape;
+      var items = new ItemList<PackingItem>(data.Items);
+      items.Sort((x, y) => y.CompareTo(x));
+      Items = items.AsReadOnly();
+
+      ApplyHorizontalOrientation();
+      LowerBoundParameter.Value.Value = CalculateLowerBound();
+    }
+
+
+    public BPPData Export() {
+      return new BPPData {
+        Name = Name,
+        Description = Description,
+        BinShape = BinShape,
+        Items = Items.ToArray()
+      };
+    }
+    #endregion
+
+
+    #region helpers
+    private void ApplyHorizontalOrientation() {
+      BinShape.ApplyHorizontalOrientation();
+      foreach (var shape in Items) {
+        shape.ApplyHorizontalOrientation();
+      }
+    }
+
+    private int CalculateLowerBound() {
+      //This is the obvious continuous lower bound calculation; Martello and Vigo proposed a better way but it has not been implemented yet;
+      int itemsVol = Items.Select(x => x.Volume).Sum();
+      int binVol = BinShape.Volume;
+      return (itemsVol + binVol - 1) / (binVol);
+    }
+
+    #endregion
   }
 }
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Problem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.2D/3.3/Problem.cs	(revision 14145)
+++ 	(revision )
@@ -1,154 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.PluginInfrastructure;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Problems.Instances;
-using HeuristicLab.Data;
-using HeuristicLab.Problems.BinPacking;
-
-namespace HeuristicLab.Problems.BinPacking2D {
-  [Item("Bin Packing Problem (2D, identical rectangles) (BPP)", "Represents a two-dimensional bin-packing problem using only bins with identical measures and bins/items with rectangular shapes.")]
-  [StorableClass]
-  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 300)]
-  public class Problem : Problem<PackingPosition, PackingShape, PackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
-
-    #region Default Instance
-    private static readonly BPPData DefaultInstance = new BPPData() {
-      Name = "2D BPP Default Instance",
-      Description = "The default instance for 2D Bin Packing.",
-      BinShape = new PackingShape(20, 16),
-      Items = new PackingItem[] {
-        new PackingItem(3,  8, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
-        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0}
-      },
-    };
-    #endregion
-
-    [StorableConstructor]
-    protected Problem(bool deserializing) : base(deserializing) { }
-    protected Problem(Problem original, Cloner cloner)
-          : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Problem(this, cloner);
-    }
-    public Problem() : base(
-          new DecodingEvaluator<Permutation, PackingPosition, PackingShape, PackingItem>()) {
-    }
-
-    #region Problem instance handling
-    public void Load(BPPData data) {
-
-      BestKnownQuality = data.BestKnownQuality.HasValue ? new DoubleValue(data.BestKnownQuality.Value) : null;
-
-      PackingBinMeasures = data.BinShape;
-      PackingItemMeasures = new ItemList<PackingItem>(data.Items);
-
-      ApplyHorizontalOrientation();
-      SortItems();
-      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
-      LowerBoundParameter.Value.Value = CalculateLowerBound();
-    }
-
-
-    public BPPData Export() {
-      return new BPPData {
-        Name = Name,
-        Description = Description,
-        BinShape = PackingBinMeasures,
-        Items = PackingItemMeasures.ToArray()
-      };
-    }
-    #endregion
-
-    #region Helpers
-    protected override void InitializeDecoder() {
-      // Operators.RemoveAll(op => op is I3DOperator); TODO
-
-      PackingSolutionDecoderParameter.ValidValues.Clear();
-      if (SolutionCreator is PackingSequenceRandomCreator) {
-        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DPSDecoder>());
-      } /*else if (SolutionCreator is GroupingVectorRandomCreator) {
-        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DGVDecoder>());
-      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
-        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DMCVDecoder>());
-      } */ else {
-        string error = "The given problem does not support the selected solution-creator.";
-        ErrorHandling.ShowErrorDialog(error, null);
-      }
-    }
-
-    protected override IEvaluator CreateDefaultEvaluator() {
-      return new PackingRatioEvaluator();
-    }
-
-    protected override void InitializeProblemData() {
-      Load(DefaultInstance);
-    }
-
-    protected override void RemoveTooBigItems() {
-      PackingItemMeasures.RemoveAll(pi =>
-        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, false), pi) &&
-        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, true), pi));
-    }
-    #endregion
-  }
-}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs	(revision 14145)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/BinPacking3D.cs	(revision 14146)
@@ -197,5 +197,5 @@
     }
 
-    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures) {
+    public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> itemMeasures) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
@@ -208,5 +208,5 @@
       }
     }
-    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
+    public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
@@ -219,5 +219,5 @@
       }
     }
-    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures, bool stackingConstraints) {
+    public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> itemMeasures, bool stackingConstraints) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
@@ -230,5 +230,5 @@
       }
     }
-    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<PackingItem> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
+    public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj	(revision 14145)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/HeuristicLab.Problems.BinPacking3D-3.3.csproj	(revision 14146)
@@ -163,19 +163,10 @@
   <ItemGroup>
     <Compile Include="BinPacking3D.cs" />
-    <Compile Include="DecoderInterfaces\I3DGVDecoder.cs" />
-    <Compile Include="DecoderInterfaces\I3DMCVDecoder.cs" />
-    <Compile Include="DecoderInterfaces\I3DPSDecoder.cs" />
-    <Compile Include="Decoders\DBL\DeepestBottomLeftPackingSequenceDecoder.cs" />
-    <Compile Include="Decoders\EP\ExtremePointPackingSequenceDecoder3D.cs" />
     <Compile Include="I3DOperator.cs" />
     <Compile Include="Instances\BPPData.cs" />
     <Compile Include="Instances\RandomDataDescriptor.cs" />
     <Compile Include="Instances\RandomInstanceProvider.cs" />
-    <Compile Include="MoveEvaluators\PackingMoveEvaluator3DGV.cs" />
-    <Compile Include="MoveEvaluators\PackingMoveEvaluator3DMCV.cs" />
-    <Compile Include="MoveEvaluators\PackingMoveEvaluator3DPS.cs" />
     <Compile Include="PackingItem.cs" />
     <Compile Include="PackingPosition.cs" />
-    <Compile Include="PackingRatioEvaluator.cs" />
     <Compile Include="PackingShape.cs" />
     <Compile Include="Plugin.cs" />
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Problem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.3D/3.3/Problem.cs	(revision 14145)
+++ 	(revision )
@@ -1,156 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Joseph Helm and 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.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Problems.Instances;
-using HeuristicLab.PluginInfrastructure;
-using HeuristicLab.Data;
-using HeuristicLab.Problems.BinPacking;
-
-namespace HeuristicLab.Problems.BinPacking3D {
-  [Item("Bin Packing Problem (3D, identical cuboids) (BPP)", "Represents a three-dimensional bin-packing problem using only bins with identical measures and bins/items with cuboidic shapes.")]
-  [StorableClass]
-  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 310)]
-  public class Problem : Problem<PackingPosition, PackingShape, PackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
-    #region Default Instance
-    private static readonly BPPData DefaultInstance = new BPPData() {
-      Name = "3D BPP Default Instance",
-      Description = "The default instance for 3D Bin Packing.",
-      BinShape = new PackingShape(25, 25, 35),
-      Items = new PackingItem[] {
-        new PackingItem(12,5,10, new PackingShape(25,25,35)),
-        new PackingItem(10,18,20, new PackingShape(25,25,35)),
-        new PackingItem(9,7,7, new PackingShape(25,25,35)),
-        new PackingItem(21,12,4, new PackingShape(25,25,35)),
-        new PackingItem(8,8,12, new PackingShape(25,25,35)),
-        new PackingItem(3,6,14, new PackingShape(25,25,35)),
-        new PackingItem(20,4,9, new PackingShape(25,25,35)),
-        new PackingItem(5,9,8, new PackingShape(25,25,35)),
-        new PackingItem(7,17,3, new PackingShape(25,25,35)),
-        new PackingItem(13,20,15, new PackingShape(25,25,35)),
-        new PackingItem(9,11,9, new PackingShape(25,25,35)),
-        new PackingItem(10,18,20, new PackingShape(25,25,35)),
-        new PackingItem(9,7,7, new PackingShape(25,25,35)),
-        new PackingItem(21,12,4, new PackingShape(25,25,35)),
-        new PackingItem(8,8,12, new PackingShape(25,25,35)),
-        new PackingItem(3,6,14, new PackingShape(25,25,35)),
-        new PackingItem(20,4,9, new PackingShape(25,25,35)),
-        new PackingItem(5,9,8, new PackingShape(25,25,35)),
-        new PackingItem(7,17,3, new PackingShape(25,25,35)),
-        new PackingItem(13,20,15, new PackingShape(25,25,35)),
-        new PackingItem(9,11,9, new PackingShape(25,25,35)),
-        new PackingItem(10,18,20, new PackingShape(25,25,35)),
-        new PackingItem(9,7,7, new PackingShape(25,25,35)),
-        new PackingItem(21,12,4, new PackingShape(25,25,35)),
-        new PackingItem(8,8,12, new PackingShape(25,25,35)),
-        new PackingItem(3,6,14, new PackingShape(25,25,35)),
-        new PackingItem(20,4,9, new PackingShape(25,25,35)),
-        new PackingItem(5,9,8, new PackingShape(25,25,35)),
-        new PackingItem(7,17,3, new PackingShape(25,25,35)),
-        new PackingItem(13,20,15, new PackingShape(25,25,35)),
-        new PackingItem(9,11, 9,new PackingShape(25,25,35)),
-        new PackingItem(10,18,20, new PackingShape(25,25,35)),
-        new PackingItem(9,7,7, new PackingShape(25,25,35)),
-        new PackingItem(21,12,4, new PackingShape(25,25,35)),
-        new PackingItem(8,8,12, new PackingShape(25,25,35)),
-        new PackingItem(3,6,14, new PackingShape(25,25,35)),
-        new PackingItem(20,4,9, new PackingShape(25,25,35)),
-        new PackingItem(5,9,8, new PackingShape(25,25,35)),
-        new PackingItem(7,17,3, new PackingShape(25,25,35)),
-        new PackingItem(13,20,15, new PackingShape(25,25,35)),
-        new PackingItem(9,11,9, new PackingShape(25,25,35))
-      },
-    };
-    #endregion
-
-    [StorableConstructor]
-    protected Problem(bool deserializing) : base(deserializing) { }
-    protected Problem(Problem original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Problem(this, cloner);
-    }
-    public Problem() : base(
-      new DecodingEvaluator<Permutation, PackingPosition, PackingShape, PackingItem>()) {
-    }
-
-    public void Load(BPPData data) {
-
-
-      BestKnownQuality = data.BestKnownQuality.HasValue ? new DoubleValue(data.BestKnownQuality.Value) : null;
-
-      PackingBinMeasures = data.BinShape;
-      PackingItemMeasures = new ItemList<PackingItem>(data.Items);
-
-      ApplyHorizontalOrientation();
-      SortItems();
-      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
-      LowerBoundParameter.Value.Value = CalculateLowerBound();
-    }
-
-    public BPPData Export() {
-      return new BPPData {
-        Name = Name,
-        Description = Description,
-        BinShape = PackingBinMeasures,
-        Items = PackingItemMeasures.ToArray()
-      };
-    }
-
-    #region Helpers
-    protected override void InitializeDecoder() {
-      // Operators.RemoveAll(op => op is I2DOperator); TODO
-
-      PackingSolutionDecoderParameter.ValidValues.Clear();
-      if (SolutionCreator is PackingSequenceRandomCreator) {
-        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DPSDecoder>());
-      } /* else if (SolutionCreator is GroupingVectorRandomCreator) {
-        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DGVDecoder>());
-      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
-        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DMCVDecoder>());
-      } */ else {
-        string error = "The given problem does not support the selected solution-creator.";
-        ErrorHandling.ShowErrorDialog(error, null);
-      }
-    }
-
-    protected override IEvaluator CreateDefaultEvaluator() {
-      return new PackingRatioEvaluator();
-    }
-
-    protected override void InitializeProblemData() {
-      Load(DefaultInstance);
-    }
-
-    protected override void RemoveTooBigItems() {
-      PackingItemMeasures.RemoveAll(pi =>
-        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, 0, false), pi) &&
-        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, 0, true), pi));
-    }
-    #endregion
-  }
-}
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking.cs	(revision 14145)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking.cs	(revision 14146)
@@ -31,11 +31,11 @@
   [Item("BinPacking", "Represents a single-bin packing for a bin-packing problem.")]
   [StorableClass]
-  public abstract class BinPacking<D,B,I>  : Item
+  public abstract class BinPacking<D, B, I> : Item
     where D : class, IPackingPosition
     where B : PackingShape<D>
-    where I : PackingShape<D>, IPackingItem {
+    where I : PackingShape<D> {
     #region Properties
     [Storable]
-    public ObservableDictionary<int, D> ItemPositions { get; private set; } 
+    public ObservableDictionary<int, D> ItemPositions { get; private set; }
 
     [Storable]
@@ -43,5 +43,5 @@
 
     [Storable]
-    public B BinMeasures { get; private set; } 
+    public B BinMeasures { get; private set; }
 
     [Storable]
@@ -53,5 +53,6 @@
     #endregion Properties
 
-    protected BinPacking(B binMeasures) : base() {   
+    protected BinPacking(B binMeasures)
+      : base() {
       ItemPositions = new ObservableDictionary<int, D>();
       ItemMeasures = new ObservableDictionary<int, I>();
@@ -64,12 +65,12 @@
     [StorableConstructor]
     protected BinPacking(bool deserializing) : base(deserializing) { }
-    protected BinPacking(BinPacking<D,B,I> original, Cloner cloner)
+    protected BinPacking(BinPacking<D, B, I> original, Cloner cloner)
       : base(original, cloner) {
       this.ItemPositions = new ObservableDictionary<int, D>(original.ItemPositions);
       this.ItemMeasures = new ObservableDictionary<int, I>(original.ItemMeasures);
-        this.BinMeasures = (B)original.BinMeasures.Clone(cloner);
-        this.OccupationLayers = new Dictionary<int, List<int>>(original.OccupationLayers);
+      this.BinMeasures = (B)original.BinMeasures.Clone(cloner);
+      this.OccupationLayers = new Dictionary<int, List<int>>(original.OccupationLayers);
     }
-   
+
     protected abstract void GenerateNewExtremePointsForNewItem(I measures, D position);
 
@@ -77,8 +78,8 @@
     public abstract D FindPositionBySliding(I measures, bool rotated);
 
-    public abstract void SlidingBasedPacking(ref List<int> sequence, ItemList<I> itemMeasures);
-    public abstract void SlidingBasedPacking(ref List<int> sequence, ItemList<I> itemMeasures, Dictionary<int, bool> rotationArray);
-    public abstract void ExtremePointBasedPacking(ref List<int> sequence, ItemList<I> itemMeasures, bool stackingConstraints);
-    public abstract void ExtremePointBasedPacking(ref List<int> sequence, ItemList<I> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray);
+    public abstract void SlidingBasedPacking(ref IList<int> sequence, IList<I> itemMeasures);
+    public abstract void SlidingBasedPacking(ref IList<int> sequence, IList<I> itemMeasures, Dictionary<int, bool> rotationArray);
+    public abstract void ExtremePointBasedPacking(ref IList<int> sequence, IList<I> itemMeasures, bool stackingConstraints);
+    public abstract void ExtremePointBasedPacking(ref IList<int> sequence, IList<I> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray);
 
     public void PackItem(int itemID, I measures, D position) {
@@ -88,13 +89,9 @@
       foreach (int id in ItemMeasures.Select(x => x.Key))
         GenerateNewExtremePointsForNewItem(ItemMeasures[id], ItemPositions[id]);
-      
-       
-      //GenerateNewExtremePointsForNewItem(measures, position);
-      //OccupiedPoints.OccupyPoints(measures, position, itemID);
 
       AddNewItemToOccupationLayers(itemID, measures, position);
     }
 
-    public double PackingDensity { 
+    public double PackingDensity {
       get {
         double result = 0;
@@ -108,8 +105,4 @@
 
     public int PointOccupation(D position) {
-      //foreach (var ipEntry in ItemPositions) {
-      //  if (ItemMeasures[ipEntry.Key].EnclosesPoint(ipEntry.Value, position))
-      //    return ipEntry.Key;
-      //}
       foreach (var id in GetLayerItemIDs(position)) {
         if (ItemMeasures[id].EnclosesPoint(ItemPositions[id], position))
@@ -120,8 +113,4 @@
 
     public bool IsPointOccupied(D position) {
-      //foreach (var ipEntry in ItemPositions) {
-      //  if (ItemMeasures[ipEntry.Key].EnclosesPoint(ipEntry.Value, position))
-      //    return true;
-      //}      
       foreach (var id in GetLayerItemIDs(position)) {
         if (ItemMeasures[id].EnclosesPoint(ItemPositions[id], position))
@@ -135,8 +124,4 @@
         return false;
 
-      //foreach (var ipEntry in ItemPositions) {
-      //  if (ItemMeasures[ipEntry.Key].Overlaps(ipEntry.Value, position, measures))
-      //    return false;
-      //} 
       foreach (var id in GetLayerItemIDs(measures, position)) {
         if (ItemMeasures[id].Overlaps(ItemPositions[id], position, measures))
@@ -146,6 +131,6 @@
       return true;
     }
-    public abstract int ShortestPossibleSideFromPoint (D position);
-    public abstract bool IsStaticStable (I measures, D position);
+    public abstract int ShortestPossibleSideFromPoint(D position);
+    public abstract bool IsStaticStable(I measures, D position);
 
 
@@ -154,4 +139,4 @@
     protected abstract List<int> GetLayerItemIDs(D position);
     protected abstract List<int> GetLayerItemIDs(I measures, D position);
-  }   
+  }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs	(revision 14145)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs	(revision 14146)
@@ -21,5 +21,4 @@
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -28,7 +27,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Collections;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Problems.BinPacking;
-using HeuristicLab.Encodings.PermutationEncoding;
 
 namespace HeuristicLab.Encodings.PackingEncoding {
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/DecodingEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/DecodingEvaluator.cs	(revision 14145)
+++ 	(revision )
@@ -1,84 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Joseph Helm and 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.Operators;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-
-
-namespace HeuristicLab.Problems.BinPacking {
-  [Item("Bin Packing Evaluator (with decoder)", "Represents a composition of a decoder and an evaluator for bin-packing problems.")]
-  [StorableClass]
-  public class DecodingEvaluator<E, D, B, I> : SingleSuccessorOperator, IDecodingEvaluator
-    where E : Item //E defines the used Encoding
-    where D : class, IPackingPosition
-    where B : PackingShape<D>
-    where I : PackingShape<D>, IPackingItem {
-
-    public IValueLookupParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
-      get { return (IValueLookupParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
-    }
-    ILookupParameter<IPackingSolutionDecoder> IDecodingEvaluator.PackingSolutionDecoderParameter {
-      get { return PackingSolutionDecoderParameter; }
-    }
-    public IValueLookupParameter<IEvaluator> PackingPlanEvaluatorParameter {
-      get { return (IValueLookupParameter<IEvaluator>)Parameters["PackingPlanEvaluator"]; }
-    }
-    ILookupParameter<IEvaluator> IDecodingEvaluator.PackingPlanEvaluatorParameter {
-      get { return PackingPlanEvaluatorParameter; }
-    }
-    public ILookupParameter<DoubleValue> QualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
-    }
-
-    [StorableConstructor]
-    protected DecodingEvaluator(bool deserializing) : base(deserializing) { }
-    protected DecodingEvaluator(DecodingEvaluator<E, D, B, I> original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public DecodingEvaluator ()
-      : base() {
-        Parameters.Add(new ValueLookupParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The decoding operator that is used to calculate a packing plan from the used representation."));
-        Parameters.Add(new ValueLookupParameter<IEvaluator>("PackingPlanEvaluator", "The actual packing plan evaluation operator."));
-        Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value aka fitness value of the solution."));
-        QualityParameter.Hidden = true;
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new DecodingEvaluator<E, D, B, I>(this, cloner);
-    }
-
-    public override IOperation Apply() {
-      var decoder = PackingSolutionDecoderParameter.ActualValue;
-      var evaluator = PackingPlanEvaluatorParameter.ActualValue;
-      if (evaluator == null) throw new InvalidOperationException("A PackingPlanEvaluator could not be found.");
-
-      var operations = new OperationCollection(base.Apply());
-      operations.Insert(0, ExecutionContext.CreateChildOperation(evaluator));
-      if (decoder != null) // decode before evaluating
-        operations.Insert(0, ExecutionContext.CreateChildOperation(decoder));
-      return operations;
-    }
-  }
-}
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/EvaluatorBase.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/EvaluatorBase.cs	(revision 14145)
+++ 	(revision )
@@ -1,83 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-
-using HeuristicLab.Core;
-using HeuristicLab.Operators;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Parameters;
-using HeuristicLab.Data;
-using HeuristicLab.Collections;
-
-namespace HeuristicLab.Problems.BinPacking {
-  [Item("Packingplan Evaluator", "Represents a evaluator class for standard bin-packing problems.")]
-  [StorableClass]
-  public abstract class EvaluatorBase<D,B,I> : SingleSuccessorOperator, IEvaluator
-    where D : class, IPackingPosition
-    where B : PackingShape<D>
-    where I : PackingShape<D>, IPackingItem {
-
-    #region Parameters
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public ILookupParameter<DoubleValue> QualityParameter {
-      get {
-        if (Parameters.ContainsKey("Quality"))
-          return (ILookupParameter<DoubleValue>)Parameters["Quality"];
-        else
-          return null;
-      }
-    }
-    public ILookupParameter<IPackingPlan> PackingPlanParameter {
-      get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlan"]; }
-    }
-    public ILookupParameter<ItemList<I>> PackingItemMeasuresParameter {
-      get { return (ILookupParameter<ItemList<I>>)Parameters["PackingItemMeasures"]; }
-    }
-    public ILookupParameter<B> PackingBinMeasuresParameter {
-      get { return (ILookupParameter<B>)Parameters["PackingBinMeasures"]; }
-    }
-    #endregion
-
-    [StorableConstructor]
-    protected EvaluatorBase(bool deserializing) : base(deserializing) { }
-    protected EvaluatorBase(EvaluatorBase<D,B,I> original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public EvaluatorBase()
-      : base() {
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value of the solution."));
-      Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlan", "The decoded bin-packing solution represented as generalized packing-plan."));
-      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
-      Parameters.Add(new LookupParameter<ItemList<I>>("PackingItemMeasures", "Packing-item data taken from the bin-packing problem-instance."));
-      Parameters.Add(new LookupParameter<B>("PackingBinMeasures", "Packing-bin data taken from the bin-packing problem-instance."));
-
-    }
-
-    protected abstract double Evaluate();                                                                        
-    public override IOperation Apply() {
-      QualityParameter.ActualValue = new DoubleValue(Evaluate());
-      return base.Apply();
-    }
-  }
-}
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 14145)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 14146)
@@ -158,6 +158,4 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Analyzers\BestBinPackingSolutionAnalyzer.cs" />
-    <Compile Include="Analyzers\BinPackingAnalyzer.cs" />
     <Compile Include="Encodings\PackingPlans\BinPacking.cs" />
     <Compile Include="Encodings\PackingPlans\PackingPlan.cs" />
@@ -165,10 +163,5 @@
     <Compile Include="Encodings\PackingSolutionCrossover.cs" />
     <Compile Include="Encodings\PackingSolutionManipulator.cs" />
-    <Compile Include="Evaluators\BinUtilizationEvaluator.cs" />
-    <Compile Include="Evaluators\DecodingEvaluator.cs" />
-    <Compile Include="Evaluators\EvaluatorBase.cs" />
-    <Compile Include="Evaluators\PackingRatioEvaluator.cs" />
     <Compile Include="Interfaces\IDecodingEvaluator.cs" />
-    <Compile Include="Interfaces\IEvaluator.cs" />
     <Compile Include="Interfaces\IPackingPosition.cs" />
     <Compile Include="Interfaces\IPackingSequenceMoveOperator.cs" />
@@ -188,5 +181,4 @@
     <Compile Include="Interfaces\IPackingShape.cs" />
     <Compile Include="PackingDimensions.cs" />
-    <Compile Include="PackingMoveEvaluator.cs" />
     <Compile Include="Interfaces\IPackingItem.cs" />
     <Compile Include="Interfaces\IPackingPlan.cs" />
@@ -194,5 +186,4 @@
     <Compile Include="PackingSolutionDecoder.cs" />
     <Compile Include="Plugin.cs" />
-    <Compile Include="PackingSequenceProblem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
@@ -202,5 +193,7 @@
     <None Include="Plugin.cs.frame" />
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <Folder Include="Evaluators\" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IEvaluator.cs	(revision 14145)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IEvaluator.cs	(revision 14146)
@@ -24,6 +24,6 @@
 
 namespace HeuristicLab.Problems.BinPacking {
-  public interface IEvaluator : ISingleObjectiveEvaluator {
-     ILookupParameter<IPackingPlan> PackingPlanParameter { get; }
+  public interface IEvaluator : IItem {
+     double Evaluate(Solution )
   }
 }
Index: /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingMoveEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingMoveEvaluator.cs	(revision 14145)
+++ /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingMoveEvaluator.cs	(revision 14146)
@@ -103,4 +103,6 @@
       return base.Apply();
     }
+
+
   }
 }
Index: anches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem.cs	(revision 14145)
+++ 	(revision )
@@ -1,251 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Joseph Helm and 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.Optimization;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Parameters;
-using HeuristicLab.Data;
-using HeuristicLab.PluginInfrastructure;
-using System.Linq;
-using System;
-using HeuristicLab.Encodings.PackingEncoding;
-
-namespace HeuristicLab.Problems.BinPacking {
-  [StorableClass]
-  public abstract class Problem<D, B, I> : SingleObjectiveHeuristicOptimizationProblem<IDecodingEvaluator, IPackingSolutionCreator>
-    where D : class, IPackingPosition
-    where B : PackingShape<D>, new()
-    where I : PackingShape<D>, IPackingItem, new() {
-
-
-    #region Parameter Properties
-    public OptionalValueParameter<PackingPlan<D, B, I>> BestKnownSolutionParameter {
-      get { return (OptionalValueParameter<PackingPlan<D, B, I>>)Parameters["BestKnownSolution"]; }
-    }
-    public ValueParameter<ItemList<I>> PackingItemMeasuresParameter {
-      get { return (ValueParameter<ItemList<I>>)Parameters["PackingItemMeasures"]; }
-    }
-    public IFixedValueParameter<IntValue> PackingItemsParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["PackingItems"]; }
-    }
-    public IFixedValueParameter<IntValue> LowerBoundParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["LowerBound"]; }
-    }
-    public ValueParameter<IEvaluator> PackingPlanEvaluatorParameter {
-      get { return (ValueParameter<IEvaluator>)Parameters["PackingPlanEvaluator"]; }
-    }
-    public IValueParameter<B> PackingBinMeasuresParameter {
-      get { return (IValueParameter<B>)Parameters["PackingBinMeasures"]; }
-    }
-    public IConstrainedValueParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
-      get { return (IConstrainedValueParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
-    }
-    #endregion
-
-    #region Properties
-    public PackingPlan<D, B, I> BestKnownSolution {
-      get { return BestKnownSolutionParameter.Value; }
-      set { BestKnownSolutionParameter.Value = value; }
-    }
-    public ItemList<I> PackingItemMeasures {
-      get { return PackingItemMeasuresParameter.Value; }
-      set { PackingItemMeasuresParameter.Value = value; }
-    }
-    public IEvaluator PackingPlanEvaluator {
-      get { return PackingPlanEvaluatorParameter.Value; }
-      set { PackingPlanEvaluatorParameter.Value = value; }
-    }
-    public B PackingBinMeasures {
-      get { return PackingBinMeasuresParameter.Value; }
-      set { PackingBinMeasuresParameter.Value = value; }
-    }
-    public PackingSolutionDecoder<D, B, I> PackingSolutionDecoder {
-      get { return PackingSolutionDecoderParameter.Value as PackingSolutionDecoder<D, B, I>; }
-      set { PackingSolutionDecoderParameter.Value = value; }
-    }
-    #endregion
-
-
-    [StorableConstructor]
-    protected Problem(bool deserializing) : base(deserializing) { }
-    protected Problem(Problem<D, B, I> original, Cloner cloner)
-      : base(original, cloner) {
-      InitializeEventHandlers();
-    }
-
-    protected Problem(IDecodingEvaluator e) : this(e, new PackingSequenceRandomCreator()) { }
-
-    protected Problem(IDecodingEvaluator e, IPackingSolutionCreator c)
-      : base(e, c) {
-      Parameters.Add(new OptionalValueParameter<PackingPlan<D, B, I>>("BestKnownSolution", "The best known solution of this bin-packing instance."));
-      Parameters.Add(new ValueParameter<ItemList<I>>("PackingItemMeasures", "Packing-item data defining the measures of the different items that need to be packed.", new ItemList<I>()));
-
-      Parameters.Add(new FixedValueParameter<IntValue>("PackingItems", "The number of packing-items used in this bin packing instance.", new IntValue()));
-      Parameters.Add(new FixedValueParameter<IntValue>("LowerBound", "The lower possible number of bins needed to solve this problem (taken from Dell'Amico, Martello and Vigo; 2002)", new IntValue()));
-      Parameters.Add(new ValueParameter<B>("PackingBinMeasures", "Packing-bin data defining the measures of the used bins.", new B()));
-      Parameters.Add(new ValueParameter<IEvaluator>("PackingPlanEvaluator", "The evaluator is used to determine the quality of a solution.", CreateDefaultEvaluator()));
-      Parameters.Add(new ConstrainedValueParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The operator that decodes the representation and creates a packing plan."));
-      this.Maximization.Value = true;
-      InitializeProblemInstance(); // TODO
-      InitializeOperators();
-      InitializeEventHandlers();
-    }
-
-    protected abstract void InitializeDecoder();
-    protected virtual void InitializeProblemInstance() {
-      InitializeProblemData();
-      ApplyHorizontalOrientation();
-      SortItems();
-      RemoveTooBigItems();
-      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
-      LowerBoundParameter.Value.Value = CalculateLowerBound();
-    }
-    protected virtual void InitializeOperators() {
-      Operators.Clear();
-      Operators.Add(new BestBinPackingSolutionAnalyzer<D, B, I>());
-
-      ApplyEncoding();
-      ParameterizeOperators();
-    }
-    protected virtual void InitializeEventHandlers() {
-      PackingPlanEvaluatorParameter.ValueChanged += PackingPlanEvaluatorParameter_ValueChanged;
-      PackingPlanEvaluator.QualityParameter.ActualNameChanged += PackingPlanEvaluator_QualityParameter_ActualNameChanged;
-      SolutionCreatorParameter.ValueChanged += SolutionCreatorParameter_ValueChanged;
-      SolutionCreator.EncodedSolutionParameter.ActualNameChanged += SolutionCreator_EncodedSolutionParameter_ActualNameChanged;
-      PackingSolutionDecoderParameter.ValueChanged += PackingSolutionDecoderParameter_ValueChanged;
-      if (PackingSolutionDecoder != null) PackingSolutionDecoder.PackingPlanParameter.ActualNameChanged += PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged;
-    }
-
-
-    protected abstract void RemoveTooBigItems();
-    protected abstract void InitializeProblemData();
-    protected abstract IEvaluator CreateDefaultEvaluator();
-    protected void ApplyHorizontalOrientation() {
-      PackingBinMeasures.ApplyHorizontalOrientation();
-      foreach (IPackingShape shape in PackingItemMeasures) {
-        shape.ApplyHorizontalOrientation();
-      }
-    }
-    protected void SortItems() {
-      PackingItemMeasures.Sort((x, y) => y.CompareTo(x));
-    }
-    protected int CalculateLowerBound() {
-      //This is the obvious continuous lower bound calculation; Martello and Vigo proposed a better way but it has not been implemented yet;
-      int items = PackingItemMeasures.Select(x => x.Volume).Sum();
-      int bin = PackingBinMeasures.Volume;
-      return (items + bin - 1) / (bin);
-    }
-
-    private void ApplyEncoding() {
-      if (SolutionCreator.GetType() == typeof(PackingSequenceRandomCreator)) {
-        Operators.AddRange(ApplicationManager.Manager.GetInstances<IPackingSequenceOperator>());
-        InitializeDecoder();
-      } /* else if (SolutionCreator.GetType() == typeof(GroupingVectorRandomCreator)) {
-        Operators.AddRange(ApplicationManager.Manager.GetInstances<IGroupingVectorOperator>());
-        InitializeDecoder();
-      } else if (SolutionCreator.GetType() == typeof(MultiComponentVectorRandomCreator)) {
-        Operators.AddRange(ApplicationManager.Manager.GetInstances<IMultiComponentVectorOperator>());
-        InitializeDecoder();
-      } */
-    }
-    private void ParameterizeOperators() {
-      foreach (var op in Operators.OfType<BestBinPackingSolutionAnalyzer<D, B, I>>()) {
-        op.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
-      }
-
-      Evaluator.PackingSolutionDecoderParameter.ActualName = PackingSolutionDecoderParameter.Name;
-      Evaluator.PackingSolutionDecoderParameter.Hidden = true;
-      Evaluator.PackingPlanEvaluatorParameter.ActualName = PackingPlanEvaluatorParameter.Name;
-      Evaluator.PackingPlanEvaluatorParameter.Hidden = true;
-      Evaluator.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
-      Evaluator.QualityParameter.Hidden = true;
-
-      if (PackingSolutionDecoder != null)
-        PackingSolutionDecoder.EncodedSolutionParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
-
-      if (PackingSolutionDecoder != null) {
-        PackingPlanEvaluator.PackingPlanParameter.ActualName = PackingSolutionDecoder.PackingPlanParameter.ActualName;
-        PackingPlanEvaluator.PackingPlanParameter.Hidden = true;
-      } else {
-        PackingPlanEvaluator.PackingPlanParameter.ActualName = PackingPlanEvaluator.PackingPlanParameter.Name;
-        PackingPlanEvaluator.PackingPlanParameter.Hidden = false;
-      }
-      /*
-
-      foreach (var op in Operators.OfType<IPackingSolutionManipulator>()) {
-        op.EncodedSolutionParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
-        op.EncodedSolutionParameter.Hidden = true;
-      }
-
-      foreach (var op in Operators.OfType<IPackingSolutionCrossover>()) {
-        op.ChildParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
-        op.ChildParameter.Hidden = true;
-        op.ParentsParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
-        op.ParentsParameter.Hidden = true;
-      }
-      */
-      foreach (var op in Operators.OfType<BestBinPackingSolutionAnalyzer<D, B, I>>()) {
-        op.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
-        if (PackingSolutionDecoder != null) {
-          op.PackingPlanParameter.ActualName = PackingSolutionDecoder.PackingPlanParameter.ActualName;
-          op.PackingPlanParameter.Hidden = true;
-        } else {
-          op.PackingPlanParameter.ActualName = op.PackingPlanParameter.Name;
-          op.PackingPlanParameter.Hidden = false;
-        }
-      }
-
-    }
-
-    #region Events
-    protected override void OnSolutionCreatorChanged() {
-      InitializeOperators();
-    }
-    protected override void OnEvaluatorChanged() {
-      base.OnEvaluatorChanged();
-      ParameterizeOperators();
-    }
-    private void PackingPlanEvaluatorParameter_ValueChanged(object sender, EventArgs eventArgs) {
-      PackingPlanEvaluator.QualityParameter.ActualNameChanged += PackingPlanEvaluator_QualityParameter_ActualNameChanged;
-      ParameterizeOperators();
-    }
-    private void PackingPlanEvaluator_QualityParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
-      ParameterizeOperators();
-    }
-    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs eventArgs) {
-      SolutionCreator.EncodedSolutionParameter.ActualNameChanged += SolutionCreator_EncodedSolutionParameter_ActualNameChanged;
-      ParameterizeOperators();
-    }
-    private void SolutionCreator_EncodedSolutionParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
-      ParameterizeOperators();
-    }
-    private void PackingSolutionDecoderParameter_ValueChanged(object sender, EventArgs eventArgs) {
-      if (PackingSolutionDecoder != null) PackingSolutionDecoder.PackingPlanParameter.ActualNameChanged += PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged;
-      ParameterizeOperators();
-    }
-    private void PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
-      ParameterizeOperators();
-    }
-    #endregion
-  }
-}
Index: /branches/HeuristicLab.BinPacking/old files/DecoderInterfaces/I3DGVDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/DecoderInterfaces/I3DGVDecoder.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/DecoderInterfaces/I3DGVDecoder.cs	(revision 14146)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  public interface I3DGVDecoder : IOperator, IPackingSolutionDecoder {
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/DecoderInterfaces/I3DMCVDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/DecoderInterfaces/I3DMCVDecoder.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/DecoderInterfaces/I3DMCVDecoder.cs	(revision 14146)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  public interface I3DMCVDecoder : IOperator, IPackingSolutionDecoder {
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/DecoderInterfaces/I3DPSDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/DecoderInterfaces/I3DPSDecoder.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/DecoderInterfaces/I3DPSDecoder.cs	(revision 14146)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Core;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  public interface I3DPSDecoder : IOperator, IPackingSolutionDecoder {
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Decoders/DBL/DeepestBottomLeftGroupingVectorDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Decoders/DBL/DeepestBottomLeftGroupingVectorDecoder.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Decoders/DBL/DeepestBottomLeftGroupingVectorDecoder.cs	(revision 14146)
@@ -0,0 +1,52 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Encodings.PackingEncoding;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Identical bin, three dimensional, GroupingVector-decoder", "<Description missing...>")]
+  [StorableClass]
+  public class DeepestBottomLeftGroupingVectorDecoder : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DGVDecoder {
+    public DeepestBottomLeftGroupingVectorDecoder() : base() {}
+    [StorableConstructor]
+    protected DeepestBottomLeftGroupingVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected DeepestBottomLeftGroupingVectorDecoder(DeepestBottomLeftGroupingVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DeepestBottomLeftGroupingVectorDecoder(this, cloner);
+    }
+
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
+      var solution = encodedSolution as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
+      Solution result = new Solution(binMeasures);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Decoders/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Decoders/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Decoders/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs	(revision 14146)
@@ -0,0 +1,52 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Encodings.PackingEncoding;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Identical bin, three dimensional, MultiComponentVector-decoder", "<Description missing...>")]
+  [StorableClass]
+  public class DeepestBottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DMCVDecoder {
+    public DeepestBottomLeftMultiComponentVectorDecoder() : base() { }
+    [StorableConstructor]
+    protected DeepestBottomLeftMultiComponentVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected DeepestBottomLeftMultiComponentVectorDecoder(DeepestBottomLeftMultiComponentVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DeepestBottomLeftMultiComponentVectorDecoder(this, cloner);
+    }
+
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
+      var solution = encodedSolution as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponent Vector");
+      Solution result = new Solution(binMeasures);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Decoders/DBL/DeepestBottomLeftPackingSequenceDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Decoders/DBL/DeepestBottomLeftPackingSequenceDecoder.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Decoders/DBL/DeepestBottomLeftPackingSequenceDecoder.cs	(revision 14146)
@@ -0,0 +1,52 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Encodings.PackingEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Identical bin, three dimensional, PackingSequence-decoder", "<Description missing...>")]
+  [StorableClass]
+  public class DeepestBottomLeftPackingSequenceDecoder : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DPSDecoder {
+    public DeepestBottomLeftPackingSequenceDecoder() : base() { }
+    [StorableConstructor]
+    protected DeepestBottomLeftPackingSequenceDecoder(bool deserializing) : base(deserializing) { }
+    protected DeepestBottomLeftPackingSequenceDecoder(DeepestBottomLeftPackingSequenceDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DeepestBottomLeftPackingSequenceDecoder(this, cloner);
+    }
+
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
+      var solution = encodedSolution as Permutation;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type Permutation");
+      Solution result = new Solution(binMeasures);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Decoders/EP/ExtremePointGroupingVectorDecoder3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Decoders/EP/ExtremePointGroupingVectorDecoder3D.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Decoders/EP/ExtremePointGroupingVectorDecoder3D.cs	(revision 14146)
@@ -0,0 +1,56 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Encodings.PackingEncoding;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Identical bin, three dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointGroupingVectorDecoder3D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DGVDecoder {
+    public ExtremePointGroupingVectorDecoder3D() : base() { }
+    [StorableConstructor]
+    protected ExtremePointGroupingVectorDecoder3D(bool deserializing) : base(deserializing) { }
+    protected ExtremePointGroupingVectorDecoder3D(ExtremePointGroupingVectorDecoder3D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointGroupingVectorDecoder3D(this, cloner);
+    }
+
+    public static PackingPlan<PackingPosition, PackingShape, PackingItem> Decode(GroupingVectorEncoding solution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures, bool stackingConstraints) {
+      Solution result = new Solution(binMeasures, true, stackingConstraints);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
+      var solution = encodedSolution as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
+      return Decode(solution, binMeasures, itemMeasures, StackingConstraintsParameter.Value.Value);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Decoders/EP/ExtremePointMultiComponentVectorDecoder3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Decoders/EP/ExtremePointMultiComponentVectorDecoder3D.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Decoders/EP/ExtremePointMultiComponentVectorDecoder3D.cs	(revision 14146)
@@ -0,0 +1,56 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Encodings.PackingEncoding;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Identical bin, three dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointMultiComponentVectorDecoder3D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DMCVDecoder {
+    public ExtremePointMultiComponentVectorDecoder3D () : base() { }
+    [StorableConstructor]
+    protected ExtremePointMultiComponentVectorDecoder3D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointMultiComponentVectorDecoder3D(ExtremePointMultiComponentVectorDecoder3D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointMultiComponentVectorDecoder3D(this, cloner);
+    }
+
+    public static PackingPlan<PackingPosition, PackingShape, PackingItem> Decode(MultiComponentVectorEncoding solution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures, bool stackingConstraints) {
+      Solution result = new Solution(binMeasures, true, stackingConstraints);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
+      var solution = encodedSolution as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
+      return Decode(solution, binMeasures, itemMeasures, StackingConstraintsParameter.Value.Value);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Decoders/EP/ExtremePointPackingSequenceDecoder3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Decoders/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Decoders/EP/ExtremePointPackingSequenceDecoder3D.cs	(revision 14146)
@@ -0,0 +1,54 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Encodings.PackingEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Identical bin, three dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointPackingSequenceDecoder3D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I3DPSDecoder {
+    public ExtremePointPackingSequenceDecoder3D () : base() {}
+    [StorableConstructor]
+    protected ExtremePointPackingSequenceDecoder3D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointPackingSequenceDecoder3D(ExtremePointPackingSequenceDecoder3D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointPackingSequenceDecoder3D(this, cloner);
+    }
+
+
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
+      var solution = encodedSolution as Permutation;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type Permutation");
+      Solution result = new Solution(binMeasures, true, StackingConstraintsParameter.Value.Value);
+      result.Pack(solution, itemMeasures); 
+      return result;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Decoders2d/BL/BottomLeftGroupingVectorDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Decoders2d/BL/BottomLeftGroupingVectorDecoder.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Decoders2d/BL/BottomLeftGroupingVectorDecoder.cs	(revision 14146)
@@ -0,0 +1,52 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Encodings.PackingEncoding;
+
+namespace HeuristicLab.Problems.BinPacking2D {
+  [Item("Identical bin two dimensional grouping vector decoder", "<Description missing...>")]
+  [StorableClass]
+  public class BottomLeftGroupingVectorDecoder : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I2DGVDecoder {
+    public BottomLeftGroupingVectorDecoder() : base() {}
+    [StorableConstructor]
+    protected BottomLeftGroupingVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected BottomLeftGroupingVectorDecoder(BottomLeftGroupingVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BottomLeftGroupingVectorDecoder(this, cloner);
+    }
+
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
+      var solution = encodedSolution as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
+      Solution result = new Solution(binMeasures);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Decoders2d/BL/BottomLeftMultiComponentVectorDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Decoders2d/BL/BottomLeftMultiComponentVectorDecoder.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Decoders2d/BL/BottomLeftMultiComponentVectorDecoder.cs	(revision 14146)
@@ -0,0 +1,52 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Encodings.PackingEncoding;
+
+namespace HeuristicLab.Problems.BinPacking2D {
+  [Item("Identical bin two dimensional multi component vector decoder", "<Description missing...>")]
+  [StorableClass]
+  public class BottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder<PackingPosition,PackingShape, PackingItem>, I2DMCVDecoder {
+    public BottomLeftMultiComponentVectorDecoder() : base() {}
+    [StorableConstructor]
+    protected BottomLeftMultiComponentVectorDecoder(bool deserializing) : base(deserializing) { }
+    protected BottomLeftMultiComponentVectorDecoder(BottomLeftMultiComponentVectorDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BottomLeftMultiComponentVectorDecoder(this, cloner);
+    }
+
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
+      var solution = encodedSolution as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponent Vector");
+      Solution result = new Solution(binMeasures);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Decoders2d/BL/BottomLeftPackingSequenceDecoder.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Decoders2d/BL/BottomLeftPackingSequenceDecoder.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Decoders2d/BL/BottomLeftPackingSequenceDecoder.cs	(revision 14146)
@@ -0,0 +1,54 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Encodings.PackingEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
+
+namespace HeuristicLab.Problems.BinPacking2D {
+  [Item("Identical bin, two dimensional, direct permutation decoder", "<Description missing...>")]
+  [StorableClass]
+  public class BottomLeftPackingSequenceDecoder : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I2DPSDecoder {
+
+    public BottomLeftPackingSequenceDecoder(): base() { }
+    [StorableConstructor]
+    protected BottomLeftPackingSequenceDecoder(bool deserializing) : base(deserializing) { }
+    protected BottomLeftPackingSequenceDecoder(BottomLeftPackingSequenceDecoder original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new BottomLeftPackingSequenceDecoder(this, cloner);
+    }
+
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
+      var solution = encodedSolution as Permutation;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type PackingSequence");
+      Solution result = new Solution(binMeasures);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Decoders2d/EP/ExtremePointGroupingVectorDecoder2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Decoders2d/EP/ExtremePointGroupingVectorDecoder2D.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Decoders2d/EP/ExtremePointGroupingVectorDecoder2D.cs	(revision 14146)
@@ -0,0 +1,57 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Encodings.PackingEncoding;
+
+namespace HeuristicLab.Problems.BinPacking2D {
+  [Item("Identical bin, two dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")]
+  [StorableClass]
+  public class ExtremePointGroupingVectorDecoder2D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I2DGVDecoder {
+    public ExtremePointGroupingVectorDecoder2D () : base() {}
+    [StorableConstructor]
+    protected ExtremePointGroupingVectorDecoder2D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointGroupingVectorDecoder2D(ExtremePointGroupingVectorDecoder2D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointGroupingVectorDecoder2D(this, cloner);
+    }
+
+    public static PackingPlan<PackingPosition, PackingShape, PackingItem> Decode(GroupingVectorEncoding solution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
+      Solution result = new Solution(binMeasures, true, false);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
+      var solution = encodedSolution as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector");
+      return Decode(solution, binMeasures, itemMeasures);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Decoders2d/EP/ExtremePointMultiComponentVectorDecoder2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Decoders2d/EP/ExtremePointMultiComponentVectorDecoder2D.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Decoders2d/EP/ExtremePointMultiComponentVectorDecoder2D.cs	(revision 14146)
@@ -0,0 +1,55 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Encodings.PackingEncoding;
+
+namespace HeuristicLab.Problems.BinPacking2D {
+  [Item("Identical bin, two dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")] // TODO
+  [StorableClass]
+  public class ExtremePointMultiComponentVectorDecoder2D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I2DMCVDecoder {
+    public ExtremePointMultiComponentVectorDecoder2D () : base() {}
+    [StorableConstructor]
+    protected ExtremePointMultiComponentVectorDecoder2D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointMultiComponentVectorDecoder2D(ExtremePointMultiComponentVectorDecoder2D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointMultiComponentVectorDecoder2D(this, cloner);
+    }
+
+    public static PackingPlan<PackingPosition, PackingShape, PackingItem> Decode(MultiComponentVectorEncoding solution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
+      Solution result = new Solution(binMeasures, true, false);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
+      var solution = encodedSolution as MultiComponentVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector");
+      return Decode(solution, binMeasures, itemMeasures);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Decoders2d/EP/ExtremePointPackingSequenceDecoder2D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Decoders2d/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Decoders2d/EP/ExtremePointPackingSequenceDecoder2D.cs	(revision 14146)
@@ -0,0 +1,54 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Encodings.PackingEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
+
+namespace HeuristicLab.Problems.BinPacking2D {
+  [Item("Identical bin, two dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")] // TODO
+  [StorableClass]
+  public class ExtremePointPackingSequenceDecoder2D : PackingSolutionDecoder<PackingPosition, PackingShape, PackingItem>, I2DPSDecoder {
+    public ExtremePointPackingSequenceDecoder2D () : base() {}
+    [StorableConstructor]
+    protected ExtremePointPackingSequenceDecoder2D (bool deserializing) : base(deserializing) { }
+    protected ExtremePointPackingSequenceDecoder2D(ExtremePointPackingSequenceDecoder2D original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExtremePointPackingSequenceDecoder2D(this, cloner);
+    }
+
+
+    public override PackingPlan<PackingPosition, PackingShape, PackingItem> CreatePackingPlanFromEncoding(IItem encodedSolution, PackingShape binMeasures, ItemList<PackingItem> itemMeasures) {
+      var solution = encodedSolution as Permutation;
+      if (solution == null) throw new InvalidOperationException("Encoding is not of type Permutation");
+      Solution result = new Solution(binMeasures, true, false);
+      result.Pack(solution, itemMeasures);
+      return result;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorCrossover.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorCrossover.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorCrossover.cs	(revision 14146)
@@ -0,0 +1,52 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Grouping Vector Crossover", "An operator which crosses two GroupingVector representations.")]
+  [StorableClass]
+  public abstract class GroupingVectorCrossover : PackingSolutionCrossover, IGroupingVectorOperator {
+
+    [StorableConstructor]
+    protected GroupingVectorCrossover(bool deserializing) : base(deserializing) { }
+    protected GroupingVectorCrossover(GroupingVectorCrossover original, Cloner cloner) : base(original, cloner) { }
+    public GroupingVectorCrossover()
+      : base() {
+        ParentsParameter.ActualName = "GroupingVector";
+        ChildParameter.ActualName = "GroupingVector";
+    }
+
+    public abstract GroupingVectorEncoding Cross(IRandom random, GroupingVectorEncoding parent1, GroupingVectorEncoding parent2);
+
+    public override IOperation Apply() {
+      var parents = ParentsParameter.ActualValue;
+
+      ChildParameter.ActualValue =
+        Cross(RandomParameter.ActualValue, parents[0] as GroupingVectorEncoding, parents[1] as GroupingVectorEncoding);
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorDiscreteCrossover.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorDiscreteCrossover.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorDiscreteCrossover.cs	(revision 14146)
@@ -0,0 +1,51 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Grouping Vector Discrete Crossover", "An operator which crosses two GroupingVector representations.")]
+  [StorableClass]
+  public class GroupingVectorDiscreteCrossover : GroupingVectorCrossover, IGroupingVectorOperator {
+
+    [StorableConstructor]
+    protected GroupingVectorDiscreteCrossover (bool deserializing) : base(deserializing) { }
+    protected GroupingVectorDiscreteCrossover(GroupingVectorDiscreteCrossover original, Cloner cloner) : base(original, cloner) { }
+    public GroupingVectorDiscreteCrossover()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingVectorDiscreteCrossover(this, cloner);
+    }
+
+    public override GroupingVectorEncoding Cross(IRandom random, GroupingVectorEncoding parent1, GroupingVectorEncoding parent2) {
+      GroupingVectorEncoding result = new GroupingVectorEncoding();
+      result.GroupingVector = DiscreteCrossover.Apply(
+        random, new ItemArray<IntegerVector> (new IntegerVector[]{parent1.GroupingVector, parent2.GroupingVector}));
+      return result;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorEncoding.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorEncoding.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorEncoding.cs	(revision 14146)
@@ -0,0 +1,100 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Linq;
+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;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Grouping Vector Encoding", "Represents an encoding for a bin packing problem using an array of group-assignments for every packing-item.")]
+  [StorableClass]
+  public class GroupingVectorEncoding : Item, IPackingSolutionEncoding {
+
+    [Storable]
+    public IntegerVector GroupingVector { get; set; }
+
+    [StorableConstructor]
+    protected GroupingVectorEncoding(bool deserializing) : base(deserializing) { }
+    protected GroupingVectorEncoding(GroupingVectorEncoding original, Cloner cloner)
+      : base(original, cloner) {
+        this.GroupingVector = cloner.Clone(original.GroupingVector);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingVectorEncoding(this, cloner);
+    }
+
+    public GroupingVectorEncoding()
+      : base() {
+        GroupingVector = new IntegerVector();
+    }
+
+    public List<List<int>> GenerateSequenceMatrix() {
+      List<List<int>> result = new List<List<int>>();
+      int nrOfBins = GroupingVector.Max() + 1;
+      for (int i = 0; i < nrOfBins; i++)
+        result.Add(new List<int>());
+      for (int i = 0; i < GroupingVector.Length; i++) {
+        result[GroupingVector[i]].Add(i);
+      }
+      return result;
+    }
+    
+
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      sb.Append("[ ");
+      sb.Append(GroupingVector.ToString());         
+      sb.Append("]");
+      return sb.ToString();
+    }
+
+
+    public override bool Equals(object obj) {
+      if (obj.GetType() == typeof(GroupingVectorEncoding))
+        return AreEqual(this, obj as GroupingVectorEncoding);
+
+      return false;
+    }
+    public override int GetHashCode() {
+      return GroupingVector.GetHashCode();
+    }
+    private static bool AreEqual(GroupingVectorEncoding groupingVectorEncoding1, GroupingVectorEncoding groupingVectorEncoding2) {
+      return AreEqual(groupingVectorEncoding1.GroupingVector, groupingVectorEncoding2.GroupingVector);
+    }
+
+    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/old files/GroupingVector/GroupingVectorManipulator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorManipulator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorManipulator.cs	(revision 14146)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Grouping Vector Manipulator", "An operator which manipulates a PackingSequence representation.")]
+  [StorableClass]
+  public abstract class GroupingVectorManipulator : PackingSolutionManipulator, IGroupingVectorOperator {
+    [StorableConstructor]
+    protected GroupingVectorManipulator(bool deserializing) : base(deserializing) { }
+    protected GroupingVectorManipulator(GroupingVectorManipulator original, Cloner cloner) : base(original, cloner) { }
+    public GroupingVectorManipulator()
+      : base() {
+        EncodedSolutionParameter.ActualName = "GroupingVector";
+    }
+
+    protected abstract void Manipulate(IRandom random, GroupingVectorEncoding individual);
+    public override IOperation Apply() {
+      var solution = EncodedSolutionParameter.ActualValue as GroupingVectorEncoding;
+      if (solution == null) throw new InvalidOperationException("PackingSolutionEncoding was not found or is not of type GroupingVectorEncoding.");
+      Manipulate(RandomParameter.ActualValue, solution);
+      return base.Apply();
+    }
+
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorOnePositionManipulator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorOnePositionManipulator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorOnePositionManipulator.cs	(revision 14146)
@@ -0,0 +1,50 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Grouping Vector One Position Manipulator", "An operator which manipulates a PackingSequence representation.")]
+  [StorableClass]
+  public class GroupingVectorOnePositionManipulator :  GroupingVectorManipulator {
+    [StorableConstructor]
+    protected GroupingVectorOnePositionManipulator(bool deserializing) : base(deserializing) { }
+    protected GroupingVectorOnePositionManipulator(GroupingVectorOnePositionManipulator original, Cloner cloner) : base(original, cloner) { }
+    public GroupingVectorOnePositionManipulator()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingVectorOnePositionManipulator(this, cloner);
+    }
+
+    protected override void Manipulate(IRandom random, GroupingVectorEncoding individual) {
+      int max = 0;
+      foreach (int i in individual.GroupingVector)
+        if (i > max) max = i;
+
+      int index = random.Next(individual.GroupingVector.Length);
+      individual.GroupingVector[index] = random.Next(max);
+    }
+
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorRandomCreator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorRandomCreator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorRandomCreator.cs	(revision 14146)
@@ -0,0 +1,73 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+	[Item("Grouping Vector Creator", "Creator class used to create GroupingVector solutions for bin packing problems.")]
+	[StorableClass]
+	public class GroupingVectorRandomCreator : PackingSolutionCreator, IStochasticOperator {
+
+		public ILookupParameter<IRandom> RandomParameter {
+			get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+		}
+		public IValueLookupParameter<IntValue> PackingItemsParameter {
+			get { return (IValueLookupParameter<IntValue>)Parameters["PackingItems"]; }
+		}
+		public IValueLookupParameter<IntValue> LowerBoundParameter {
+			get { return (IValueLookupParameter<IntValue>)Parameters["LowerBound"]; }
+		}
+
+		[StorableConstructor]
+		protected GroupingVectorRandomCreator(bool deserializing) : base(deserializing) { }
+		protected GroupingVectorRandomCreator(GroupingVectorRandomCreator original, Cloner cloner) : base(original, cloner) {
+		}
+		public override IDeepCloneable Clone(Cloner cloner) {
+			return new GroupingVectorRandomCreator(this, cloner);
+		}
+
+		public GroupingVectorRandomCreator()
+			: base() {
+			Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
+			Parameters.Add(new ValueLookupParameter<IntValue>("PackingItems", "The number of packing-items handled in this problem instance."));
+			Parameters.Add(new ValueLookupParameter<IntValue>("LowerBound", "The lower possible number of bins needed to solve this problem (taken from Dell'Amico, Martello and Vigo; 2002)"));
+
+			EncodedSolutionParameter.ActualName = "GroupingVector";
+		}
+
+
+		public static GroupingVectorEncoding Apply(int items, int lowerBound, IRandom random) {
+			var solution = new GroupingVectorEncoding();
+      solution.GroupingVector = new IntegerVector(items, random, 0, lowerBound + 1);
+			return solution;
+		}
+
+		protected override IItem CreateSolution() {
+			return Apply(PackingItemsParameter.ActualValue.Value, LowerBoundParameter.ActualValue.Value, RandomParameter.ActualValue);
+		}
+	}
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorSinglePointCrossover.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorSinglePointCrossover.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorSinglePointCrossover.cs	(revision 14146)
@@ -0,0 +1,50 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Grouping Vector Single Point Crossover", "An operator which crosses two GroupingVector representations.")]
+  [StorableClass]
+  public class GroupingVectorSinglePointCrossover : GroupingVectorCrossover, IGroupingVectorOperator {
+
+    [StorableConstructor]
+    protected GroupingVectorSinglePointCrossover (bool deserializing) : base(deserializing) { }
+    protected GroupingVectorSinglePointCrossover(GroupingVectorSinglePointCrossover original, Cloner cloner) : base(original, cloner) { }
+    public GroupingVectorSinglePointCrossover()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingVectorSinglePointCrossover(this, cloner);
+    }
+
+    public override GroupingVectorEncoding Cross(IRandom random, GroupingVectorEncoding parent1, GroupingVectorEncoding parent2) {
+      GroupingVectorEncoding result = new GroupingVectorEncoding();
+      result.GroupingVector = SinglePointCrossover.Apply(random, parent1.GroupingVector, parent2.GroupingVector);
+      return result;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorSwap2Manipulator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorSwap2Manipulator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/GroupingVectorSwap2Manipulator.cs	(revision 14146)
@@ -0,0 +1,61 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Grouping Vector Swap2 Manipulator", "An operator which manipulates a PackingSequence representation.")]
+  [StorableClass]
+  public class GroupingVectorSwap2Manipulator :  GroupingVectorManipulator {
+    [StorableConstructor]
+    protected GroupingVectorSwap2Manipulator (bool deserializing) : base(deserializing) { }
+    protected GroupingVectorSwap2Manipulator(GroupingVectorSwap2Manipulator original, Cloner cloner) : base(original, cloner) { }
+    public GroupingVectorSwap2Manipulator()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingVectorSwap2Manipulator(this, cloner);
+    }
+
+    protected override void Manipulate(IRandom random, GroupingVectorEncoding individual) {
+
+      int index1 = 0;
+      int index2 = 1;
+
+      if (individual.GroupingVector.Length <= 1)
+        return;
+      else if (individual.GroupingVector.Length != 2) {
+        index1 = random.Next(individual.GroupingVector.Length);
+        index2 = random.Next(individual.GroupingVector.Length);
+        while (index2.Equals(index1)) {
+          index2 = random.Next(individual.GroupingVector.Length);
+        }
+      }
+
+      int temp = individual.GroupingVector [index1];
+      individual.GroupingVector[index1] = individual.GroupingVector[index2];
+      individual.GroupingVector[index2] = temp;
+    }
+
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMove.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMove.cs	(revision 14146)
@@ -0,0 +1,86 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Change Grouping Move", "A move on a grouping vector that is specified by a single group-assignment-index.")]
+  [StorableClass]
+  public class ChangeGroupingMove : GroupingMove, IPackingMove {
+    [Storable]
+    public int Index { get; protected set; }
+    [Storable]
+    public int NewGroup { get; protected set; }
+
+    [StorableConstructor]
+    protected ChangeGroupingMove(bool deserializing) : base(deserializing) { }
+    protected ChangeGroupingMove(ChangeGroupingMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index = original.Index;
+      this.NewGroup = original.NewGroup;
+    }
+    public ChangeGroupingMove(int index, int newGroup, GroupingVectorEncoding groupingVector)
+      : base(groupingVector) {
+      Index = index;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ChangeGroupingMove(this, cloner);
+    }
+
+    public override IPackingSolutionEncoding GetSolutionAfterMove() {
+      GroupingVectorEncoding newSolution = new GroupingVectorEncoding();
+      newSolution.GroupingVector = new IntegerVector(GroupingVector.GroupingVector);
+      newSolution.GroupingVector[Index] = NewGroup;
+      return newSolution;
+    }
+
+    public override Type GetMoveAttributeType() {
+      return typeof(ChangeGroupingMoveAttribute);
+    }
+
+    public override GroupingMoveAttribute GetAttribute(double quality) {
+      return new ChangeGroupingMoveAttribute(Index, NewGroup, quality);
+    }
+
+    public override bool BelongsToAttribute(GroupingMoveAttribute attribute, bool hardCriterion) {
+      var attr = attribute as ChangeGroupingMoveAttribute;
+      if (attr != null) {
+        if (hardCriterion) {
+          if (Index == attr.ItemIndex) //|| GroupingVector.GroupingVector[Index] == attr.AssignedBin)
+            return true;
+        } else
+          if (Index == attr.ItemIndex && GroupingVector.GroupingVector[Index] == attr.AssignedBin)
+            return true;
+      }
+      return false;
+    }
+
+    public override string ToString() {
+      return "CGM(i=" + Index + ", g=" + NewGroup + ")";
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMoveAttribute.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMoveAttribute.cs	(revision 14146)
@@ -0,0 +1,53 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("ChangeGroupingMoveAttribute", "Specifies the tabu attributes for a ChangeGrouping move on a grouping vector.")]
+  [StorableClass]
+  public class ChangeGroupingMoveAttribute : GroupingMoveAttribute {
+    [Storable]
+    public int ItemIndex { get; protected set; }
+    [Storable]
+    public int AssignedBin { get; protected set; }
+
+    [StorableConstructor]
+    protected ChangeGroupingMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected ChangeGroupingMoveAttribute(ChangeGroupingMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.ItemIndex = original.ItemIndex;
+      this.AssignedBin = original.AssignedBin;
+    }
+    public ChangeGroupingMoveAttribute() : this(-1, -1, -1) { }
+    public ChangeGroupingMoveAttribute(int itemIndex, int assignedBin, double moveQuality)
+      : base(moveQuality) {
+      ItemIndex = itemIndex;
+      AssignedBin = assignedBin;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ChangeGroupingMoveAttribute(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMoveGenerator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/ChangeGroupingMoveGenerator.cs	(revision 14146)
@@ -0,0 +1,71 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Change Grouping Move Generator", "Base class for all ChangeGrouping move generators.")]
+  [StorableClass]
+  public abstract class ChangeGroupingMoveGenerator : SingleSuccessorOperator, IGroupingVectorMoveOperator, IMoveGenerator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (LookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    [StorableConstructor]
+    protected ChangeGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ChangeGroupingMoveGenerator(ChangeGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ChangeGroupingMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The grouping vector for which moves should be generated."));
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The moves that should be generated in subscopes."));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
+    }
+
+    public override IOperation Apply() {
+      GroupingVectorEncoding gv = GroupingVectorParameter.ActualValue;
+      ChangeGroupingMove[] moves = GenerateMoves(gv);
+      Scope[] moveScopes = new Scope[moves.Length];
+      for (int i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        moveScopes[i].Variables.Add(new Variable(PackingMoveParameter.ActualName, moves[i]));
+      }
+      CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
+      return base.Apply();
+    }
+
+    protected abstract ChangeGroupingMove[] GenerateMoves(GroupingVectorEncoding groupingVector);
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/ExhaustiveChangeGroupingMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/ExhaustiveChangeGroupingMoveGenerator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/ExhaustiveChangeGroupingMoveGenerator.cs	(revision 14146)
@@ -0,0 +1,70 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Exhaustive Change Grouping Move Generator", "Generates all possible ChangeGrouping moves from a given groupingVector.")]
+  [StorableClass]
+  public class ExhaustiveChangeGroupingMoveGenerator : ChangeGroupingMoveGenerator, IExhaustiveMoveGenerator {
+    [StorableConstructor]
+    protected ExhaustiveChangeGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ExhaustiveChangeGroupingMoveGenerator(ExhaustiveChangeGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveChangeGroupingMoveGenerator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveChangeGroupingMoveGenerator(this, cloner);
+    }
+
+    public static IEnumerable<ChangeGroupingMove> Generate(GroupingVectorEncoding groupingVector, int nrOfBins) {
+      for (int i = 0; i < groupingVector.GroupingVector.Length; i++)
+        for (int j = 0; j < nrOfBins; j++) {
+          if (j != groupingVector.GroupingVector[i])
+            yield return new ChangeGroupingMove(i, j, groupingVector);
+        }
+    }
+
+    public static ChangeGroupingMove[] Apply(GroupingVectorEncoding groupingVector) {
+      int nrOfBins = 0;
+      foreach (int binNr in groupingVector.GroupingVector) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+
+      int totalMoves = (groupingVector.GroupingVector.Length) * (nrOfBins - 1);
+      ChangeGroupingMove[] moves = new ChangeGroupingMove[totalMoves];
+      int count = 0;
+      foreach (ChangeGroupingMove move in Generate(groupingVector, nrOfBins)) {
+        moves[count++] = move;
+      }
+      return moves;
+    }
+
+    protected override ChangeGroupingMove[] GenerateMoves(GroupingVectorEncoding groupingVector) {
+      return Apply(groupingVector);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/StochasticChangeGroupingMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/StochasticChangeGroupingMoveGenerator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/ChangeGrouping/StochasticChangeGroupingMoveGenerator.cs	(revision 14146)
@@ -0,0 +1,82 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Stochastic ChangeGrouping Move Generator", "Generates a number of possible grouping moves from a given grouping vector.")]
+  [StorableClass]
+  public class StochasticChangeGroupingMoveGenerator : ChangeGroupingMoveGenerator, IMultiMoveGenerator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+
+    public IntValue SampleSize {
+      get { return SampleSizeParameter.Value; }
+      set { SampleSizeParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected StochasticChangeGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticChangeGroupingMoveGenerator(StochasticChangeGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticChangeGroupingMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StochasticChangeGroupingMoveGenerator(this, cloner);
+    }
+
+    public static ChangeGroupingMove[] Apply(GroupingVectorEncoding groupingVector, IRandom random, int sampleSize) {
+
+      int nrOfBins = 0;
+      foreach (int binNr in groupingVector.GroupingVector) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+      var generatedMoves = new List<ChangeGroupingMove>();
+      var moves = new List<ChangeGroupingMove>(ExhaustiveChangeGroupingMoveGenerator.Generate(groupingVector, nrOfBins));
+      int moveCount = moves.Count;
+      for (int i = 0; i < sampleSize; i++) {
+        generatedMoves.Add(moves[random.Next(moveCount)]);
+      }
+
+      return generatedMoves.ToArray();
+    }
+
+    protected override ChangeGroupingMove[] GenerateMoves(GroupingVectorEncoding groupingVector) {
+      IRandom random = RandomParameter.ActualValue;
+      return Apply(groupingVector, random, SampleSizeParameter.ActualValue.Value);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMove.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMove.cs	(revision 14146)
@@ -0,0 +1,52 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("GroupingMove", "An abstract move for a groupingVector encoded solution.")]
+  [StorableClass]
+  public abstract class GroupingMove : Item, IPackingMove {
+    [Storable]
+    public GroupingVectorEncoding GroupingVector { get; protected set; }
+
+    [StorableConstructor]
+    protected GroupingMove(bool deserializing) : base(deserializing) { }
+    protected GroupingMove(GroupingMove original, Cloner cloner)
+      : base(original, cloner) {
+        if (original.GroupingVector != null)
+          this.GroupingVector = cloner.Clone(original.GroupingVector);
+    }
+    public GroupingMove(GroupingVectorEncoding groupingVector)
+      : base() {
+        GroupingVector = groupingVector;
+    }
+
+    public abstract IPackingSolutionEncoding GetSolutionAfterMove();
+    public abstract Type GetMoveAttributeType();
+    public abstract GroupingMoveAttribute GetAttribute(double quality);
+    public abstract bool BelongsToAttribute (GroupingMoveAttribute attribute, bool hardCriterion);
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMoveAttribute.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMoveAttribute.cs	(revision 14146)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("GroupingMoveAttribute", "Base class for specifying a move attribute for grouping vector moves.")]
+  [StorableClass]
+  public class GroupingMoveAttribute : Item {
+    [Storable]
+    public double MoveQuality { get; protected set; }
+
+    [StorableConstructor]
+    protected GroupingMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected GroupingMoveAttribute(GroupingMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.MoveQuality = original.MoveQuality;
+    }
+    public GroupingMoveAttribute() : this(0) { }
+    public GroupingMoveAttribute( double moveQuality)
+      : base() {
+      MoveQuality = moveQuality;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingMoveAttribute(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMoveHardTabuCriterion.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMoveHardTabuCriterion.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMoveHardTabuCriterion.cs	(revision 14146)
@@ -0,0 +1,111 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("GroupingMoveHardTabuCriterion", "<Missing>")]
+  [StorableClass]
+  public class GroupingMoveHardTabuCriterion : SingleSuccessorOperator, IGroupingVectorMoveOperator, ITabuChecker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+    public ILookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (ILookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MoveTabu"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ValueParameter<BoolValue> UseAspirationCriterionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseAspirationCriterion"]; }
+    }
+
+    [StorableConstructor]
+    protected GroupingMoveHardTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected GroupingMoveHardTabuCriterion(GroupingMoveHardTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public GroupingMoveHardTabuCriterion()
+      : base() {
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution to evaluate."));
+      Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the current move."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseAspirationCriterion", "Whether to use the aspiration criterion or not.", new BoolValue(true)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingMoveHardTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      GroupingMove move = PackingMoveParameter.ActualValue as GroupingMove;
+      GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue;
+      int length = groupingVector.GroupingVector.Length;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool maximization = MaximizationParameter.ActualValue.Value;   
+      bool useAspiration = UseAspirationCriterionParameter.Value.Value;
+      bool isTabu = IsMoveTabu(tabuList, move, groupingVector, moveQuality, maximization, useAspiration);
+
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+
+    private bool IsMoveTabu(ItemList<IItem> tabuList, GroupingMove move, GroupingVectorEncoding groupingVector, double moveQuality, bool maximization, bool useAspiration) {
+      bool isTabu = false;
+      var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType()));
+
+      foreach (IItem attr in attributes) {
+        GroupingMoveAttribute gvAttr = attr as GroupingMoveAttribute;
+        if (gvAttr != null
+          && (!useAspiration
+              || maximization && moveQuality <= gvAttr.MoveQuality
+              || !maximization && moveQuality >= gvAttr.MoveQuality)) {
+
+          isTabu = move.BelongsToAttribute(gvAttr, true);
+        }
+        if (isTabu) break;
+      }
+
+      return isTabu;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMoveMaker.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMoveMaker.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMoveMaker.cs	(revision 14146)
@@ -0,0 +1,89 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Grouping Move Maker", "Peforms a grouping move on a given grouping vector and updates the quality.")]
+  [StorableClass]
+  public class GroupingMoveMaker : SingleSuccessorOperator, IMoveMaker, IGroupingVectorMoveOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+    public ILookupParameter<IPackingPlan> PackingPlanParameter {
+      get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlan"]; }
+    }
+    public ILookupParameter<IPackingPlan> PackingPlanAfterMoveParameter {
+      get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlanAfterMove"]; }
+    }
+
+    [StorableConstructor]
+    protected GroupingMoveMaker(bool deserializing) : base(deserializing) { }
+    protected GroupingMoveMaker(GroupingMoveMaker original, Cloner cloner) : base(original, cloner) { }
+    public GroupingMoveMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The relative quality of the move."));
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution as grouping vector."));
+      Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlan", "The currently best performing, decoded bin-packing solution represented as generalized packing-plan."));
+      Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlanAfterMove", "The moved and decoded bin-packing solution represented as generalized packing-plan."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingMoveMaker(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      IPackingMove move = PackingMoveParameter.ActualValue;
+      GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue;
+      DoubleValue moveQuality = MoveQualityParameter.ActualValue;
+      DoubleValue quality = QualityParameter.ActualValue;
+
+      groupingVector.GroupingVector = (move.GetSolutionAfterMove() as GroupingVectorEncoding).GroupingVector;
+      PackingPlanParameter.ActualValue = PackingPlanAfterMoveParameter.ActualValue;
+
+      quality.Value = moveQuality.Value;
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMoveSoftTabuCriterion.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMoveSoftTabuCriterion.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingMoveSoftTabuCriterion.cs	(revision 14146)
@@ -0,0 +1,111 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("GroupingMoveSoftTabuCriterion", "<Missing>")]
+  [StorableClass]
+  public class GroupingMoveSoftTabuCriterion : SingleSuccessorOperator, IGroupingVectorMoveOperator, ITabuChecker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+    public ILookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (ILookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MoveTabu"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ValueParameter<BoolValue> UseAspirationCriterionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseAspirationCriterion"]; }
+    }
+
+    [StorableConstructor]
+    protected GroupingMoveSoftTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected GroupingMoveSoftTabuCriterion(GroupingMoveSoftTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public GroupingMoveSoftTabuCriterion()
+      : base() {
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution to evaluate."));
+      Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the current move."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseAspirationCriterion", "Whether to use the aspiration criterion or not.", new BoolValue(true)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingMoveSoftTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      GroupingMove move = PackingMoveParameter.ActualValue as GroupingMove;
+      GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue;
+      int length = groupingVector.GroupingVector.Length;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool maximization = MaximizationParameter.ActualValue.Value;   
+      bool useAspiration = UseAspirationCriterionParameter.Value.Value;
+      bool isTabu = IsMoveTabu(tabuList, move, groupingVector, moveQuality, maximization, useAspiration);
+
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+
+    private bool IsMoveTabu(ItemList<IItem> tabuList, GroupingMove move, GroupingVectorEncoding groupingVector, double moveQuality, bool maximization, bool useAspiration) {
+      bool isTabu = false;
+      var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType()));
+
+      foreach (IItem attr in attributes) {
+        GroupingMoveAttribute gvAttr = attr as GroupingMoveAttribute;
+        if (gvAttr != null
+          && (!useAspiration
+              || maximization && moveQuality <= gvAttr.MoveQuality
+              || !maximization && moveQuality >= gvAttr.MoveQuality)) {
+
+          isTabu = move.BelongsToAttribute(gvAttr, false);
+        }
+        if (isTabu) break;
+      }
+
+      return isTabu;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingTabuMaker.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingTabuMaker.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/GroupingTabuMaker.cs	(revision 14146)
@@ -0,0 +1,69 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Grouping tabu maker", "Declares a given grouping move as tabu, by adding its attributes to the tabu list and also store the solution quality or the move quality (whichever is better).")]
+  [StorableClass]
+  public class GroupingTabuMaker : TabuMaker, IGroupingVectorMoveOperator {
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+
+    [StorableConstructor]
+    protected GroupingTabuMaker(bool deserializing) : base(deserializing) { }
+    protected GroupingTabuMaker(GroupingTabuMaker original, Cloner cloner) : base(original, cloner) { }
+    public GroupingTabuMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GroupingTabuMaker(this, cloner);
+    }
+
+    protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) {
+      IPackingMove move = PackingMoveParameter.ActualValue;
+      GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue;
+      double baseQuality = moveQuality;
+      if (maximization && quality > moveQuality || !maximization && quality < moveQuality)
+        baseQuality = quality; // we make an uphill move, the lower bound is the solution quality
+
+      var gMove = move as GroupingMove;
+
+      if (gMove != null)
+        return gMove.GetAttribute(baseQuality);
+      else
+        return move.GetSolutionAfterMove();
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/ExhaustiveSwapGroupingMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/ExhaustiveSwapGroupingMoveGenerator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/ExhaustiveSwapGroupingMoveGenerator.cs	(revision 14146)
@@ -0,0 +1,69 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Exhaustive Swap Grouping Move Generator", "Generates all possible Swap grouping moves from a given groupingVector.")]
+  [StorableClass]
+  public class ExhaustiveSwapGroupingMoveGenerator : SwapGroupingMoveGenerator, IExhaustiveMoveGenerator {
+    [StorableConstructor]
+    protected ExhaustiveSwapGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ExhaustiveSwapGroupingMoveGenerator(ExhaustiveSwapGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveSwapGroupingMoveGenerator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveSwapGroupingMoveGenerator(this, cloner);
+    }
+    public static IEnumerable<SwapGroupingMove> Generate(GroupingVectorEncoding groupingVector, int nrOfBins) {
+      for (int i = 0; i < groupingVector.GroupingVector.Length - 1; i++)
+        for (int j = i + 1; j < groupingVector.GroupingVector.Length; j++) {
+          if (j != i)
+            yield return new SwapGroupingMove(i, j, groupingVector);
+        }
+    }
+
+    public static SwapGroupingMove[] Apply(GroupingVectorEncoding groupingVector) {
+      int nrOfBins = 0;
+      foreach (int binNr in groupingVector.GroupingVector) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+
+      int totalMoves = (groupingVector.GroupingVector.Length * (groupingVector.GroupingVector.Length - 1)) / 2;
+      SwapGroupingMove[] moves = new SwapGroupingMove[totalMoves];
+      int count = 0;
+      foreach (SwapGroupingMove move in Generate(groupingVector, nrOfBins)) {
+        moves[count++] = move;
+      }
+      return moves;
+    }
+
+    protected override SwapGroupingMove[] GenerateMoves(GroupingVectorEncoding groupingVector) {
+      return Apply(groupingVector);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/StochasticSwapGroupingMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/StochasticSwapGroupingMoveGenerator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/StochasticSwapGroupingMoveGenerator.cs	(revision 14146)
@@ -0,0 +1,82 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Stochastic SwapGrouping Move Generator", "Generates a number of possible grouping moves from a given grouping vector.")]
+  [StorableClass]
+  public class StochasticSwapGroupingMoveGenerator : SwapGroupingMoveGenerator, IMultiMoveGenerator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+
+    public IntValue SampleSize {
+      get { return SampleSizeParameter.Value; }
+      set { SampleSizeParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected StochasticSwapGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticSwapGroupingMoveGenerator(StochasticSwapGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticSwapGroupingMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StochasticSwapGroupingMoveGenerator(this, cloner);
+    }
+
+    public static SwapGroupingMove[] Apply(GroupingVectorEncoding groupingVector, IRandom random, int sampleSize) {
+
+      int nrOfBins = 0;
+      foreach (int binNr in groupingVector.GroupingVector) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+      var generatedMoves = new List<SwapGroupingMove>();
+      var moves = new List<SwapGroupingMove>(ExhaustiveSwapGroupingMoveGenerator.Generate(groupingVector, nrOfBins));
+      int moveCount = moves.Count;
+      for (int i = 0; i < sampleSize; i++) {
+        generatedMoves.Add(moves[random.Next(moveCount)]);
+      }
+
+      return generatedMoves.ToArray();
+    }
+
+    protected override SwapGroupingMove[] GenerateMoves(GroupingVectorEncoding SwapGrouping) {
+      IRandom random = RandomParameter.ActualValue;
+      return Apply(SwapGrouping, random, SampleSizeParameter.ActualValue.Value);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/SwapGroupingMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/SwapGroupingMove.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/SwapGroupingMove.cs	(revision 14146)
@@ -0,0 +1,89 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Swap Grouping Move", "A move on a grouping vector that is specified by two group-assignment-indexes.")]
+  [StorableClass]
+  public class SwapGroupingMove : GroupingMove, IPackingMove {
+    [Storable]
+    public int Index1 { get; protected set; }
+    [Storable]
+    public int Index2 { get; protected set; }
+
+    [StorableConstructor]
+    protected SwapGroupingMove(bool deserializing) : base(deserializing) { }
+    protected SwapGroupingMove(SwapGroupingMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index1 = original.Index1;
+      this.Index2 = original.Index2;
+    }
+    public SwapGroupingMove(int index1, int index2, GroupingVectorEncoding groupingVector)
+      : base(groupingVector) {
+      Index1 = index1;
+      Index2 = index2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SwapGroupingMove(this, cloner);
+    }
+
+    public override IPackingSolutionEncoding GetSolutionAfterMove() {
+      GroupingVectorEncoding newSolution = new GroupingVectorEncoding();
+      newSolution.GroupingVector = new IntegerVector(GroupingVector.GroupingVector);
+      newSolution.GroupingVector[Index1] = GroupingVector.GroupingVector[Index2];
+      newSolution.GroupingVector[Index2] = GroupingVector.GroupingVector[Index1];
+      return newSolution;
+    }
+
+    public override Type GetMoveAttributeType() {
+      return typeof(SwapGroupingMoveAttribute);
+    }
+
+    public override GroupingMoveAttribute GetAttribute(double quality) {
+      return new SwapGroupingMoveAttribute(Index1, Index2, GroupingVector.GroupingVector[Index1], GroupingVector.GroupingVector[Index2], quality);
+    }
+
+    public override bool BelongsToAttribute(GroupingMoveAttribute attribute, bool hardCriterion) {
+      var attr = attribute as SwapGroupingMoveAttribute;
+      if (attr != null) {
+        if (hardCriterion) {
+          if (Index1 == attr.ItemIndex1 || Index2 == attr.ItemIndex2)// || GroupingVector.GroupingVector[Index1] == attr.AssignedBin1 || GroupingVector.GroupingVector[Index2] == attr.AssignedBin2)
+            return true;
+        } else
+          if (Index1 == attr.ItemIndex1 && Index2 == attr.ItemIndex2)// && GroupingVector.GroupingVector[Index1] == attr.AssignedBin1 && GroupingVector.GroupingVector[Index2] == attr.AssignedBin2)
+            return true;
+      }
+      return false;
+    }
+
+    public override string ToString() {
+      return "SGM(i1="+Index1 + ", i2=" + Index2  +")";
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/SwapGroupingMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/SwapGroupingMoveAttribute.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/SwapGroupingMoveAttribute.cs	(revision 14146)
@@ -0,0 +1,61 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("SwapGroupingMoveAttribute", "Specifies the tabu attributes for a Swap grouping move on a grouping vector.")]
+  [StorableClass]
+  public class SwapGroupingMoveAttribute : GroupingMoveAttribute {
+    [Storable]
+    public int ItemIndex1 { get; protected set; }
+    [Storable]
+    public int ItemIndex2 { get; protected set; }
+    [Storable]
+    public int AssignedBin1 { get; protected set; }
+    [Storable]
+    public int AssignedBin2 { get; protected set; }
+
+    [StorableConstructor]
+    protected SwapGroupingMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected SwapGroupingMoveAttribute(SwapGroupingMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.ItemIndex1 = original.ItemIndex1;
+      this.ItemIndex2 = original.ItemIndex2;
+      this.AssignedBin1 = original.AssignedBin1;
+      this.AssignedBin2 = original.AssignedBin2;
+    }
+    public SwapGroupingMoveAttribute() : this(-1, -1, -1, -1, -1) { }
+    public SwapGroupingMoveAttribute(int itemIndex1, int itemIndex2, int assignedBin1, int assignedBin2, double moveQuality)
+      : base(moveQuality) {
+      ItemIndex1 = itemIndex1;
+      ItemIndex2 = itemIndex2;
+      AssignedBin1 = assignedBin1;
+      AssignedBin2 = assignedBin2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SwapGroupingMoveAttribute(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/SwapGroupingMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/SwapGroupingMoveGenerator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/GroupingVector/Moves/SwapGrouping/SwapGroupingMoveGenerator.cs	(revision 14146)
@@ -0,0 +1,72 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+
+namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector {
+  [Item("Swap Grouping Move Generator", "Base class for all Swap grouping move generators.")]
+  [StorableClass]
+  public abstract class SwapGroupingMoveGenerator : SingleSuccessorOperator, IGroupingVectorMoveOperator, IMoveGenerator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter {
+      get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (LookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    [StorableConstructor]
+    protected SwapGroupingMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected SwapGroupingMoveGenerator(SwapGroupingMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public SwapGroupingMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The grouping vector for which moves should be generated."));
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The moves that should be generated in subscopes."));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
+    }
+
+    public override IOperation Apply() {
+      GroupingVectorEncoding gv = GroupingVectorParameter.ActualValue;
+      SwapGroupingMove[] moves = GenerateMoves(gv);
+      Scope[] moveScopes = new Scope[moves.Length];
+      for (int i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        moveScopes[i].Variables.Add(new Variable(PackingMoveParameter.ActualName, moves[i]));
+      }
+      CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
+      return base.Apply();
+    }
+
+    protected abstract SwapGroupingMove[] GenerateMoves(GroupingVectorEncoding groupingVector);
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Encoding.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Encoding.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Encoding.cs	(revision 14146)
@@ -0,0 +1,77 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [StorableClass]
+  public class Encoding : HeuristicLab.Optimization.Encoding<IPackingSolutionCreator> {
+    [StorableConstructor]
+    private Encoding(bool deserializing) : base(deserializing) { }
+    public Encoding()
+      : base("PackingSequence") {
+      SolutionCreator = new PackingSequenceRandomCreator();
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    private Encoding(Encoding original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterParameterEvents();
+    }
+
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Encoding(this, cloner);
+    }
+
+    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+      // TODO
+    }
+
+    #region Operator discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static Encoding() {
+      encodingSpecificOperatorTypes = new List<Type>
+      {
+        typeof(IPackingSequenceOperator),         // TODO move (also namespace)
+      };
+    }
+    private void DiscoverOperators() {
+      var assembly = typeof(IPackingSequenceCreator).Assembly;
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, assembly, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
+      var newOperators = operators.Except(Operators, new TypeEqualityComparer<IOperator>()).ToList();
+
+      ConfigureOperators(newOperators);
+      foreach (var @operator in newOperators)
+        AddOperator(@operator);
+    }
+    #endregion
+
+    private void RegisterParameterEvents() {
+      // nothing to do
+    }
+
+
+  }
+
+  public static class IndividualExtensionMethods {
+    public static Permutation PackingSequence(this Individual individual) {
+      var encoding = individual.GetEncoding<Encoding>();
+      return individual.PackingSequence(encoding.Name);
+    }
+
+    public static Permutation PackingSequence(this Individual individual, string name) {
+      return (Permutation)individual[name];
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/IPackingSequenceCreator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/IPackingSequenceCreator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/IPackingSequenceCreator.cs	(revision 14146)
@@ -0,0 +1,34 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  interface IPackingSequenceCreator : ISolutionCreator, IPackingSequenceOperator {
+    ILookupParameter<IntValue> NumberOfPackingItemsParameter { get; }
+    ILookupParameter<Permutation> SolutionParameter { get; }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/GroupingMoveHardTabuCriterion.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/GroupingMoveHardTabuCriterion.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/GroupingMoveHardTabuCriterion.cs	(revision 14146)
@@ -0,0 +1,111 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.PermutationEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("SequenceMoveHardTabuCriterion", "<Missing>")]
+  [StorableClass]
+  public class SequenceMoveHardTabuCriterion : SingleSuccessorOperator, IPackingSequenceMoveOperator, ITabuChecker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
+    }
+    public ILookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (ILookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MoveTabu"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ValueParameter<BoolValue> UseAspirationCriterionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseAspirationCriterion"]; }
+    }
+
+    [StorableConstructor]
+    protected SequenceMoveHardTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected SequenceMoveHardTabuCriterion(SequenceMoveHardTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public SequenceMoveHardTabuCriterion()
+      : base() {
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The solution candidate to evaluate."));
+      Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the current move."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseAspirationCriterion", "Whether to use the aspiration criterion or not.", new BoolValue(true)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SequenceMoveHardTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      SequenceMove move = PackingMoveParameter.ActualValue as SequenceMove;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool maximization = MaximizationParameter.ActualValue.Value;
+      bool useAspiration = UseAspirationCriterionParameter.Value.Value;
+      bool isTabu = IsMoveTabu(tabuList, move, moveQuality, maximization, useAspiration);
+
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+
+    private bool IsMoveTabu(ItemList<IItem> tabuList, SequenceMove move, double moveQuality, bool maximization, bool useAspiration) {
+      bool isTabu = false;
+      var attributes = tabuList.FindAll(ta => ta.GetType() == move.GetMoveAttributeType());
+
+      foreach (IItem attr in attributes) {
+        SequenceMoveAttribute gvAttr = attr as SequenceMoveAttribute;
+        if (gvAttr != null
+          && (!useAspiration
+              || maximization && moveQuality <= gvAttr.MoveQuality
+              || !maximization && moveQuality >= gvAttr.MoveQuality)) {
+
+          isTabu = move.BelongsToAttribute(gvAttr, true); // only difference to soft tabu criterion
+        }
+        if (isTabu) break;
+      }
+
+      return isTabu;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/GroupingMoveMaker.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/GroupingMoveMaker.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/GroupingMoveMaker.cs	(revision 14146)
@@ -0,0 +1,87 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.PermutationEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Sequence Move Maker", "Peforms a Sequence move on a given Sequence vector and updates the quality.")]
+  [StorableClass]
+  public class SequenceMoveMaker : SingleSuccessorOperator, IMoveMaker, IPackingSequenceMoveOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
+    }
+    public ILookupParameter<IPackingPlan> PackingPlanParameter {
+      get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlan"]; }
+    }
+    public ILookupParameter<IPackingPlan> PackingPlanAfterMoveParameter {
+      get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlanAfterMove"]; }
+    }
+
+    [StorableConstructor]
+    protected SequenceMoveMaker(bool deserializing) : base(deserializing) { }
+    protected SequenceMoveMaker(SequenceMoveMaker original, Cloner cloner) : base(original, cloner) { }
+    public SequenceMoveMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The relative quality of the move."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The solution as Sequence vector."));
+      Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlan", "The currently best performing, decoded bin-packing solution represented as generalized packing-plan."));
+      Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlanAfterMove", "The moved and decoded bin-packing solution represented as generalized packing-plan."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SequenceMoveMaker(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      DoubleValue moveQuality = MoveQualityParameter.ActualValue;
+      DoubleValue quality = QualityParameter.ActualValue;
+
+      PackingPlanParameter.ActualValue = PackingPlanAfterMoveParameter.ActualValue;
+
+      quality.Value = moveQuality.Value;
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/GroupingMoveSoftTabuCriterion.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/GroupingMoveSoftTabuCriterion.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/GroupingMoveSoftTabuCriterion.cs	(revision 14146)
@@ -0,0 +1,112 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.PermutationEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("SequenceMoveSoftTabuCriterion", "<Missing>")]
+  [StorableClass]
+  public class SequenceMoveSoftTabuCriterion : SingleSuccessorOperator, IPackingSequenceMoveOperator, ITabuChecker {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
+    }
+    public ILookupParameter<ItemList<IItem>> TabuListParameter {
+      get { return (ILookupParameter<ItemList<IItem>>)Parameters["TabuList"]; }
+    }
+    public ILookupParameter<BoolValue> MoveTabuParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MoveTabu"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ValueParameter<BoolValue> UseAspirationCriterionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["UseAspirationCriterion"]; }
+    }
+
+    [StorableConstructor]
+    protected SequenceMoveSoftTabuCriterion(bool deserializing) : base(deserializing) { }
+    protected SequenceMoveSoftTabuCriterion(SequenceMoveSoftTabuCriterion original, Cloner cloner) : base(original, cloner) { }
+    public SequenceMoveSoftTabuCriterion()
+      : base() {
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The solution to evaluate."));
+      Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
+      Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, else if it is a minimization problem."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the current move."));
+      Parameters.Add(new ValueParameter<BoolValue>("UseAspirationCriterion", "Whether to use the aspiration criterion or not.", new BoolValue(true)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SequenceMoveSoftTabuCriterion(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      ItemList<IItem> tabuList = TabuListParameter.ActualValue;
+      SequenceMove move = PackingMoveParameter.ActualValue as SequenceMove;
+      double moveQuality = MoveQualityParameter.ActualValue.Value;
+      bool maximization = MaximizationParameter.ActualValue.Value;
+      bool useAspiration = UseAspirationCriterionParameter.Value.Value;
+      bool isTabu = IsMoveTabu(tabuList, move, moveQuality, maximization, useAspiration);
+
+      MoveTabuParameter.ActualValue = new BoolValue(isTabu);
+      return base.Apply();
+    }
+
+    private bool IsMoveTabu(ItemList<IItem> tabuList, SequenceMove move, double moveQuality, bool maximization, bool useAspiration) {
+      bool isTabu = false;
+      var attributes = tabuList.FindAll(ta => ta.GetType() == move.GetMoveAttributeType());
+
+      foreach (IItem attr in attributes) {
+        SequenceMoveAttribute gvAttr = attr as SequenceMoveAttribute;
+        if (gvAttr != null
+          && (!useAspiration
+              || maximization && moveQuality <= gvAttr.MoveQuality
+              || !maximization && moveQuality >= gvAttr.MoveQuality)) {
+
+          isTabu = move.BelongsToAttribute(gvAttr, false); // only difference to hard tabu criterion 
+        }
+        if (isTabu) break;
+      }
+
+      return isTabu;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/ExhaustiveInsertionMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/ExhaustiveInsertionMoveGenerator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/ExhaustiveInsertionMoveGenerator.cs	(revision 14146)
@@ -0,0 +1,71 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Exhaustive Insertion Move Generator", "Generates all possible Swap Sequence moves from a given PackingSequence.")]
+  [StorableClass]
+  public class ExhaustiveInsertionMoveGenerator : InsertionMoveGenerator, IExhaustiveMoveGenerator {
+    [StorableConstructor]
+    protected ExhaustiveInsertionMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ExhaustiveInsertionMoveGenerator(ExhaustiveInsertionMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveInsertionMoveGenerator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveInsertionMoveGenerator(this, cloner);
+    }
+    public static IEnumerable<InsertionMove> Generate(Permutation packingSequence, int nrOfBins) {
+      for (int i = 0; i < packingSequence.Length - 1; i++)
+        for (int j = i + 1; j < packingSequence.Length; j++) {
+          if (j != i)
+            yield return new InsertionMove(i, j, packingSequence);
+        }
+    }
+
+    public static InsertionMove[] Apply(Permutation packingSequence) {
+      int nrOfBins = 0;
+      foreach (int binNr in packingSequence) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+
+      int totalMoves = (packingSequence.Length * (packingSequence.Length - 1)) / 2;
+      InsertionMove[] moves = new InsertionMove[totalMoves];
+      int count = 0;
+      foreach (InsertionMove move in Generate(packingSequence, nrOfBins)) {
+        moves[count++] = move;
+      }
+      return moves;
+    }
+
+    protected override InsertionMove[] GenerateMoves(Permutation packingSequence) {
+      return Apply(packingSequence);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/InsertionMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/InsertionMove.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/InsertionMove.cs	(revision 14146)
@@ -0,0 +1,111 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Insertion Move", "A move on a Sequence vector that is specified by two group-assignment-indexes.")]
+  [StorableClass]
+  public class InsertionMove : SequenceMove {
+    [Storable]
+    public int Index1 { get; protected set; }
+    [Storable]
+    public int Index2 { get; protected set; }
+
+    [StorableConstructor]
+    protected InsertionMove(bool deserializing) : base(deserializing) { }
+    protected InsertionMove(InsertionMove original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index1 = original.Index1;
+      this.Index2 = original.Index2;
+    }
+    public InsertionMove(int index1, int index2, Permutation packingSequence)
+      : base(packingSequence) {
+      Index1 = index1;
+      Index2 = index2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new InsertionMove(this, cloner);
+    }
+
+    public override Permutation GetSolutionAfterMove() {
+      Permutation original = PackingSequence;
+      Permutation resultingPermutation = (Permutation)PackingSequence.Clone();
+      int cutIndex, insertIndex, number;
+
+      cutIndex = Index1;
+      insertIndex = Index2;
+      number = original[cutIndex];
+
+      int i = 0;  // index in new permutation
+      int j = 0;  // index in old permutation
+      while (i < PackingSequence.Length) {
+        if (j == cutIndex) {
+          j++;
+        }
+        if (i == insertIndex) {
+          resultingPermutation[i] = number;
+          i++;
+        }
+        if ((i < original.Length) && (j < original.Length)) {
+          resultingPermutation[i] = original[j];
+          i++;
+          j++;
+        }
+      }
+
+      return resultingPermutation;
+    }
+
+    public override Type GetMoveAttributeType() {
+      return typeof(InsertionMoveAttribute);
+    }
+
+    public override SequenceMoveAttribute GetAttribute(double quality) {
+      return new InsertionMoveAttribute(Index1, Index2, PackingSequence[Index1], PackingSequence[Index2], quality);
+    }
+
+    public override bool BelongsToAttribute(SequenceMoveAttribute attribute, bool hardCriterion) {
+      var attr = attribute as InsertionMoveAttribute;
+      if (attr != null) {
+        if (hardCriterion) {
+          if (Index1 == attr.Index1 || Index2 == attr.Index2)
+            return true;
+        } else
+          if (Index1 == attr.Index1 && Index2 == attr.Index2)
+            return true;
+      }
+      return false;
+    }
+
+    public override string ToString() {
+      return "IM(i1=" + Index1 + ", i2=" + Index2 + ")";
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/InsertionMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/InsertionMoveAttribute.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/InsertionMoveAttribute.cs	(revision 14146)
@@ -0,0 +1,61 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("InsertionMoveAttribute", "Specifies the tabu attributes for a Insertion move on a packingSequence.")]
+  [StorableClass]
+  public class InsertionMoveAttribute : SequenceMoveAttribute {
+    [Storable]
+    public int Index1 { get; protected set; }
+    [Storable]
+    public int Index2 { get; protected set; }
+    [Storable]
+    public int ItemID1 { get; protected set; }
+    [Storable]
+    public int ItemID2 { get; protected set; }
+
+    [StorableConstructor]
+    protected InsertionMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected InsertionMoveAttribute(InsertionMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index1 = original.Index1;
+      this.Index2 = original.Index2;
+      this.ItemID1 = original.ItemID1;
+      this.ItemID2 = original.ItemID2;
+    }
+    public InsertionMoveAttribute() : this(-1, -1, -1, -1, -1) { }
+    public InsertionMoveAttribute(int index1, int index2, int itemID1, int itemID2, double moveQuality)
+      : base(moveQuality) {
+      Index1 = index1;
+      Index2 = index2;
+      ItemID1 = itemID1;
+      ItemID2 = itemID2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new InsertionMoveAttribute(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/InsertionMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/InsertionMoveGenerator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/InsertionMoveGenerator.cs	(revision 14146)
@@ -0,0 +1,74 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Insertion Move Generator", "Base class for all Swap Sequence move generators.")]
+  [StorableClass]
+  public abstract class InsertionMoveGenerator : SingleSuccessorOperator, IPackingSequenceMoveOperator, IMoveGenerator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
+    }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (LookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
+    }
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    [StorableConstructor]
+    protected InsertionMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected InsertionMoveGenerator(InsertionMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public InsertionMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The Sequence vector for which moves should be generated."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The moves that should be generated in subscopes."));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
+    }
+
+    public override IOperation Apply() {
+      Permutation ps = PackingSequenceParameter.ActualValue;
+      InsertionMove[] moves = GenerateMoves(ps);
+      Scope[] moveScopes = new Scope[moves.Length];
+      for (int i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        moveScopes[i].Variables.Add(new Variable(PackingMoveParameter.ActualName, moves[i]));
+      }
+      CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
+      return base.Apply();
+    }
+
+    protected abstract InsertionMove[] GenerateMoves(Permutation packingSequence);
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/StochasticInsertionMoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/StochasticInsertionMoveGenerator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Insertion/StochasticInsertionMoveGenerator.cs	(revision 14146)
@@ -0,0 +1,84 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Stochastic Insertion Move Generator", "Generates a number of possible Sequence moves from a given Sequence vector.")]
+  [StorableClass]
+  public class StochasticInsertionMoveGenerator : InsertionMoveGenerator, IMultiMoveGenerator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+
+    public IntValue SampleSize {
+      get { return SampleSizeParameter.Value; }
+      set { SampleSizeParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected StochasticInsertionMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticInsertionMoveGenerator(StochasticInsertionMoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticInsertionMoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StochasticInsertionMoveGenerator(this, cloner);
+    }
+
+    public static InsertionMove[] Apply(Permutation packingSequence, IRandom random, int sampleSize) {
+
+      int nrOfBins = 0;
+      foreach (int binNr in packingSequence) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+      var generatedMoves = new List<InsertionMove>();
+      var moves = new List<InsertionMove>(ExhaustiveInsertionMoveGenerator.Generate(packingSequence, nrOfBins));
+      int moveCount = moves.Count;
+      for (int i = 0; i < sampleSize; i++) {
+        generatedMoves.Add(moves[random.Next(moveCount)]);
+      }
+
+      return generatedMoves.ToArray();
+    }
+
+    protected override InsertionMove[] GenerateMoves(Permutation packingSequence) {
+      IRandom random = RandomParameter.ActualValue;
+      return Apply(packingSequence, random, SampleSizeParameter.ActualValue.Value);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/SequenceMove.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/SequenceMove.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/SequenceMove.cs	(revision 14146)
@@ -0,0 +1,54 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("SequenceMove", "An abstract move for a packing sequence encoded solution.")]
+  [StorableClass]
+  public abstract class SequenceMove : Item, IPackingMove<Permutation> {
+    [Storable]
+    public Permutation PackingSequence { get; protected set; }
+
+    [StorableConstructor]
+    protected SequenceMove(bool deserializing) : base(deserializing) { }
+    protected SequenceMove(SequenceMove original, Cloner cloner)
+      : base(original, cloner) {
+        if (original.PackingSequence != null)
+          this.PackingSequence = cloner.Clone(original.PackingSequence);
+    }
+    public SequenceMove(Permutation packingSequence)
+      : base() {
+        PackingSequence = packingSequence;
+    }
+
+    public abstract Permutation GetSolutionAfterMove();
+    public abstract Type GetMoveAttributeType();
+    public abstract SequenceMoveAttribute GetAttribute(double quality);
+    public abstract bool BelongsToAttribute (SequenceMoveAttribute attribute, bool hardCriterion);
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/SequenceMoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/SequenceMoveAttribute.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/SequenceMoveAttribute.cs	(revision 14146)
@@ -0,0 +1,50 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence{
+  [Item("SequenceMoveAttribute", "Base class for specifying a move attribute for sequence moves.")]
+  [StorableClass]
+  public class SequenceMoveAttribute : Item {
+    [Storable]
+    public double MoveQuality { get; protected set; }
+
+    [StorableConstructor]
+    protected SequenceMoveAttribute(bool deserializing) : base(deserializing) { }
+    protected SequenceMoveAttribute(SequenceMoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.MoveQuality = original.MoveQuality;
+    }
+    public SequenceMoveAttribute() : this(0) { }
+    public SequenceMoveAttribute( double moveQuality)
+      : base() {
+      MoveQuality = moveQuality;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SequenceMoveAttribute(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/SequenceTabuMaker.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/SequenceTabuMaker.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/SequenceTabuMaker.cs	(revision 14146)
@@ -0,0 +1,69 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Sequence tabu maker", "Declares a given Sequence move as tabu, by adding its attributes to the tabu list and also store the solution quality or the move quality (whichever is better).")]
+  [StorableClass]
+  public class SequenceTabuMaker : TabuMaker, IPackingSequenceMoveOperator {
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
+    }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
+    }
+
+    [StorableConstructor]
+    protected SequenceTabuMaker(bool deserializing) : base(deserializing) { }
+    protected SequenceTabuMaker(SequenceTabuMaker original, Cloner cloner) : base(original, cloner) { }
+    public SequenceTabuMaker()
+      : base() {
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The solution to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SequenceTabuMaker(this, cloner);
+    }
+
+    protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) {
+      var move = PackingMoveParameter.ActualValue;
+      double baseQuality = moveQuality;
+      if (maximization && quality > moveQuality || !maximization && quality < moveQuality)
+        baseQuality = quality; // we make an uphill move, the lower bound is the solution quality
+
+      var sMove = move as SequenceMove;
+
+      if (sMove != null)
+        return sMove.GetAttribute(baseQuality);
+      else
+        return move.GetSolutionAfterMove();
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/ExhaustiveSwap2MoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/ExhaustiveSwap2MoveGenerator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/ExhaustiveSwap2MoveGenerator.cs	(revision 14146)
@@ -0,0 +1,71 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Exhaustive Swap2 Move Generator", "Generates all possible Swap Sequence moves from a given PackingSequence.")]
+  [StorableClass]
+  public class ExhaustiveSwap2MoveGenerator : Swap2MoveGenerator, IExhaustiveMoveGenerator {
+    [StorableConstructor]
+    protected ExhaustiveSwap2MoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ExhaustiveSwap2MoveGenerator(ExhaustiveSwap2MoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public ExhaustiveSwap2MoveGenerator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExhaustiveSwap2MoveGenerator(this, cloner);
+    }
+    public static IEnumerable<Swap2Move> Generate(Permutation packingSequence, int nrOfBins) {
+      for (int i = 0; i < packingSequence.Length - 1; i++)
+        for (int j = i + 1; j < packingSequence.Length; j++) {
+          if (j != i)
+            yield return new Swap2Move(i, j, packingSequence);
+        }
+    }
+
+    public static Swap2Move[] Apply(Permutation packingSequence) {
+      int nrOfBins = 0;
+      foreach (int binNr in packingSequence) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+
+      int totalMoves = (packingSequence.Length * (packingSequence.Length - 1)) / 2;
+      Swap2Move[] moves = new Swap2Move[totalMoves];
+      int count = 0;
+      foreach (Swap2Move move in Generate(packingSequence, nrOfBins)) {
+        moves[count++] = move;
+      }
+      return moves;
+    }
+
+    protected override Swap2Move[] GenerateMoves(Permutation packingSequence) {
+      return Apply(packingSequence);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/StochasticSwap2MoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/StochasticSwap2MoveGenerator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/StochasticSwap2MoveGenerator.cs	(revision 14146)
@@ -0,0 +1,84 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Stochastic Swap2 Move Generator", "Generates a number of possible Sequence moves from a given Sequence vector.")]
+  [StorableClass]
+  public class StochasticSwap2MoveGenerator : Swap2MoveGenerator, IMultiMoveGenerator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+
+    public IntValue SampleSize {
+      get { return SampleSizeParameter.Value; }
+      set { SampleSizeParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected StochasticSwap2MoveGenerator(bool deserializing) : base(deserializing) { }
+    protected StochasticSwap2MoveGenerator(StochasticSwap2MoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public StochasticSwap2MoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to generate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StochasticSwap2MoveGenerator(this, cloner);
+    }
+
+    public static Swap2Move[] Apply(Permutation packingSequence, IRandom random, int sampleSize) {
+
+      int nrOfBins = 0;
+      foreach (int binNr in packingSequence) {
+        if (binNr > nrOfBins)
+          nrOfBins = binNr;
+      }
+      nrOfBins++;
+      var generatedMoves = new List<Swap2Move>();
+      var moves = new List<Swap2Move>(ExhaustiveSwap2MoveGenerator.Generate(packingSequence, nrOfBins));
+      int moveCount = moves.Count;
+      for (int i = 0; i < sampleSize; i++) {
+        generatedMoves.Add(moves[random.Next(moveCount)]);
+      }
+
+      return generatedMoves.ToArray();
+    }
+
+    protected override Swap2Move[] GenerateMoves(Permutation packingSequence) {
+      IRandom random = RandomParameter.ActualValue;
+      return Apply(packingSequence, random, SampleSizeParameter.ActualValue.Value);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/Swap2Move.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/Swap2Move.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/Swap2Move.cs	(revision 14146)
@@ -0,0 +1,89 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Swap2 Move", "A move on a Sequence vector that is specified by two group-assignment-indexes.")]
+  [StorableClass]
+  public class Swap2Move : SequenceMove, IPackingMove<Permutation> {
+    [Storable]
+    public int Index1 { get; protected set; }
+    [Storable]
+    public int Index2 { get; protected set; }
+
+    [StorableConstructor]
+    protected Swap2Move(bool deserializing) : base(deserializing) { }
+    protected Swap2Move(Swap2Move original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index1 = original.Index1;
+      this.Index2 = original.Index2;
+    }
+    public Swap2Move(int index1, int index2, Permutation packingSequence)
+      : base(packingSequence) {
+      Index1 = index1;
+      Index2 = index2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Swap2Move(this, cloner);
+    }
+
+    public override Permutation GetSolutionAfterMove() {
+      Permutation newSolution = (Permutation)PackingSequence.Clone(new Cloner());
+      newSolution[Index1] = PackingSequence[Index2];
+      newSolution[Index2] = PackingSequence[Index1];
+      return newSolution;
+    }
+
+    public override Type GetMoveAttributeType() {
+      return typeof(Swap2MoveAttribute);
+    }
+
+    public override SequenceMoveAttribute GetAttribute(double quality) {
+      return new Swap2MoveAttribute(Index1, Index2, PackingSequence[Index1], PackingSequence[Index2], quality);
+    }
+
+    public override bool BelongsToAttribute(SequenceMoveAttribute attribute, bool hardCriterion) {
+      var attr = attribute as Swap2MoveAttribute;
+      if (attr != null) {
+        if (hardCriterion) {
+          if (Index1 == attr.Index1 || Index2 == attr.Index2)// || PackingSequence.PackingSequence[Index1] == attr.AssignedBin1 || PackingSequence.PackingSequence[Index2] == attr.AssignedBin2)
+            return true;
+        } else
+          if (Index1 == attr.Index1 && Index2 == attr.Index2)// && PackingSequence.PackingSequence[Index1] == attr.AssignedBin1 && PackingSequence.PackingSequence[Index2] == attr.AssignedBin2)
+            return true;
+      }
+      return false;
+    }
+
+    public override string ToString() {
+      return "SGM(i1="+Index1 + ", i2=" + Index2  +")";
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/Swap2MoveAttribute.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/Swap2MoveAttribute.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/Swap2MoveAttribute.cs	(revision 14146)
@@ -0,0 +1,62 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Swap2MoveAttribute", "Specifies the tabu attributes for a Swap2 move on a packingSequence.")]
+  [StorableClass]
+  public class Swap2MoveAttribute : SequenceMoveAttribute {
+    [Storable]
+    public int Index1 { get; protected set; }
+    [Storable]
+    public int Index2 { get; protected set; }
+    [Storable]
+    public int ItemID1 { get; protected set; }
+    [Storable]
+    public int ItemID2 { get; protected set; }
+
+    [StorableConstructor]
+    protected Swap2MoveAttribute(bool deserializing) : base(deserializing) { }
+    protected Swap2MoveAttribute(Swap2MoveAttribute original, Cloner cloner)
+      : base(original, cloner) {
+      this.Index1 = original.Index1;
+      this.Index2 = original.Index2;
+      this.ItemID1 = original.ItemID1;
+      this.ItemID2 = original.ItemID2;
+    }
+    public Swap2MoveAttribute() : this(-1, -1, -1, -1, -1) { }
+    public Swap2MoveAttribute(int index1, int index2, int itemID1, int itemID2, double moveQuality)
+      : base(moveQuality) {
+      Index1 = index1;
+      Index2 = index2;
+      ItemID1 = itemID1;
+      ItemID2 = itemID2;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Swap2MoveAttribute(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/Swap2MoveGenerator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/Swap2MoveGenerator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/Moves/Swap2/Swap2MoveGenerator.cs	(revision 14146)
@@ -0,0 +1,73 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Swap2 Move Generator", "Base class for all Swap Sequence move generators.")]
+  [StorableClass]
+  public abstract class Swap2MoveGenerator : SingleSuccessorOperator, IPackingSequenceMoveOperator, IMoveGenerator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
+    }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (LookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
+    }
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    [StorableConstructor]
+    protected Swap2MoveGenerator(bool deserializing) : base(deserializing) { }
+    protected Swap2MoveGenerator(Swap2MoveGenerator original, Cloner cloner) : base(original, cloner) { }
+    public Swap2MoveGenerator()
+      : base() {
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The Sequence vector for which moves should be generated."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The moves that should be generated in subscopes."));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
+    }
+
+    public override IOperation Apply() {
+      Permutation ps = PackingSequenceParameter.ActualValue;
+      Swap2Move[] moves = GenerateMoves(ps);
+      Scope[] moveScopes = new Scope[moves.Length];
+      for (int i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        moveScopes[i].Variables.Add(new Variable(PackingMoveParameter.ActualName, moves[i]));
+      }
+      CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes);
+      return base.Apply();
+    }
+
+    protected abstract Swap2Move[] GenerateMoves(Permutation packingSequence);
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequence.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequence.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequence.cs	(revision 14146)
@@ -0,0 +1,25 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("PackingSequence", "Represents a packing sequence (permutation).")]
+  [StorableClass]
+  public class PackingSequence : Permutation {
+
+    [StorableConstructor]
+    private PackingSequence(bool deserializing) : base(deserializing) { }
+    private PackingSequence(PackingSequence original, Cloner cloner) : base(original, cloner) { }
+    public PackingSequence() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingSequence(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceCrossover.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceCrossover.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceCrossover.cs	(revision 14146)
@@ -0,0 +1,54 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("PackingSequenceCrossover", "An operator which crosses two PackingSequence representations.")]
+  [StorableClass]
+  public abstract class PackingSequenceCrossover : PackingSolutionCrossover<Permutation>, IPackingSequenceOperator {
+
+    [StorableConstructor]
+    protected PackingSequenceCrossover(bool deserializing) : base(deserializing) { }
+    protected PackingSequenceCrossover(PackingSequenceCrossover original, Cloner cloner) : base(original, cloner) { }
+    public PackingSequenceCrossover()
+      : base() {
+      ParentsParameter.ActualName = "PackingSequence";
+      ChildParameter.ActualName = "PackingSequence";
+    }
+
+    public abstract Permutation Cross(IRandom random, Permutation parent1, Permutation parent2);
+
+    public override IOperation Apply() {
+      var parents = ParentsParameter.ActualValue;
+
+      ChildParameter.ActualValue =
+        Cross(RandomParameter.ActualValue, parents[0], parents[1]);
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceEncoding.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceEncoding.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceEncoding.cs	(revision 14146)
@@ -0,0 +1,86 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Text;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("Packing Sequence Encoding", "Represents an encoding for a bin packing problem using permutation of item-indexes to define the packing sequence.")]
+  [StorableClass]
+  public class PackingSequenceEncoding : Item, IPackingSolutionEncoding {
+
+    [Storable]
+    public Permutation PackingSequence { get; set; }
+
+    [StorableConstructor]
+    protected PackingSequenceEncoding(bool deserializing) : base(deserializing) { }
+    protected PackingSequenceEncoding(PackingSequenceEncoding original, Cloner cloner)
+      : base(original, cloner) {
+      this.PackingSequence = cloner.Clone(original.PackingSequence);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingSequenceEncoding(this, cloner);
+    }
+
+    public PackingSequenceEncoding()
+      : base() {
+      PackingSequence = new Permutation();
+    }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      sb.Append("[ ");
+      sb.Append(PackingSequence.ToString() + " \n");
+      sb.Append("]");
+      return sb.ToString();
+    }
+
+
+    public override bool Equals(object obj) {
+      if (obj.GetType() == typeof(PackingSequenceEncoding))
+        return AreEqual(this, obj as PackingSequenceEncoding);
+
+      return false;
+    }
+    public override int GetHashCode() {
+      return PackingSequence.GetHashCode();
+    }
+    private static bool AreEqual(PackingSequenceEncoding packingSequenceEncoding1, PackingSequenceEncoding packingSequenceEncoding2) {
+      return AreEqual(packingSequenceEncoding1.PackingSequence, packingSequenceEncoding2.PackingSequence);
+    }
+
+    private static bool AreEqual(Permutation p1, Permutation p2) {
+      if (p1.Length != p2.Length)
+        return false;
+      for (int i = 0; i < p1.Length; i++) {
+        if (p1[i] != p2[i])
+          return false;
+      }
+      return true;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceInversionManipulator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceInversionManipulator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceInversionManipulator.cs	(revision 14146)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("PackingSequence Inversion Manipulator", "An operator which manipulates a PackingSequence representation.")]
+  [StorableClass]
+  public class PackingSequenceInversionManipulator : PackingSequenceManipulator, IPackingSequenceOperator {
+    [StorableConstructor]
+    protected PackingSequenceInversionManipulator(bool deserializing) : base(deserializing) { }
+    protected PackingSequenceInversionManipulator(PackingSequenceInversionManipulator original, Cloner cloner) : base(original, cloner) { }
+    public PackingSequenceInversionManipulator()
+      : base() {
+      EncodedSolutionParameter.ActualName = "PackingSequence";
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingSequenceInversionManipulator(this, cloner);
+    }
+
+    protected override void Manipulate(IRandom random, Permutation individual) {
+      InversionManipulator.Apply(random, individual);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceManipulator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceManipulator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceManipulator.cs	(revision 14146)
@@ -0,0 +1,52 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("PackingSequenceManipulator", "An operator which manipulates a PackingSequence representation.")]
+  [StorableClass]
+  public abstract class PackingSequenceManipulator : PackingSolutionManipulator<Permutation>, IPackingSequenceOperator {
+    [StorableConstructor]
+    protected PackingSequenceManipulator(bool deserializing) : base(deserializing) { }
+    protected PackingSequenceManipulator(PackingSequenceManipulator original, Cloner cloner) : base(original, cloner) { }
+    public PackingSequenceManipulator()
+      : base() {
+      EncodedSolutionParameter.ActualName = "PackingSequence";
+    }
+
+    protected abstract void Manipulate(IRandom random, Permutation individual);
+
+    public override IOperation Apply() {
+      var solution = EncodedSolutionParameter.ActualValue;
+      if (solution == null) throw new InvalidOperationException("PackingSolutionEncoding was not found or is not of type PackingSequenceEncoding.");
+      Manipulate(RandomParameter.ActualValue, solution);
+      return base.Apply();
+    }
+
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceOrderCrossover.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceOrderCrossover.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceOrderCrossover.cs	(revision 14146)
@@ -0,0 +1,48 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("PackingSequence OX", "An operator which crosses two PackingSequence representations using the OX-strategy.")]
+  [StorableClass]
+  public class PackingSequenceOrderCrossover : PackingSequenceCrossover {
+
+    [StorableConstructor]
+    protected PackingSequenceOrderCrossover(bool deserializing) : base(deserializing) { }
+    protected PackingSequenceOrderCrossover(PackingSequenceOrderCrossover original, Cloner cloner) : base(original, cloner) { }
+    public PackingSequenceOrderCrossover()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingSequenceOrderCrossover(this, cloner);
+    }
+
+    public override Permutation Cross(IRandom random, Permutation parent1, Permutation parent2) {
+      return OrderCrossover.Apply(random, parent1, parent2);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequencePartiallyMatchedCrossover.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequencePartiallyMatchedCrossover.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequencePartiallyMatchedCrossover.cs	(revision 14146)
@@ -0,0 +1,49 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("PackingSequence PMX", "An operator which crosses two PackingSequence representations using the OX-strategy.")]
+  [StorableClass]
+  public class PackingSequencePartiallyMatchedCrossover : PackingSequenceCrossover {
+
+    [StorableConstructor]
+    protected PackingSequencePartiallyMatchedCrossover(bool deserializing) : base(deserializing) { }
+    protected PackingSequencePartiallyMatchedCrossover(PackingSequencePartiallyMatchedCrossover original, Cloner cloner) : base(original, cloner) { }
+    public PackingSequencePartiallyMatchedCrossover()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingSequencePartiallyMatchedCrossover(this, cloner);
+    }
+
+    public override Permutation Cross(IRandom random, Permutation parent1, Permutation parent2) {
+      return PartiallyMatchedCrossover.Apply(random, parent1, parent2);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceRandomCreator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceRandomCreator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceRandomCreator.cs	(revision 14146)
@@ -0,0 +1,76 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.PermutationEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("PackingSequenceCreator", "Creator class used to create PackingSequence solutions for bin packing problems.")]
+  [StorableClass]
+  public class PackingSequenceRandomCreator : PackingSolutionCreator, IPackingSequenceCreator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<IntValue> NumberOfPackingItemsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["NumberOfItems"]; }
+    }
+
+    public ILookupParameter<Permutation> SolutionParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
+    }
+
+    [StorableConstructor]
+    protected PackingSequenceRandomCreator(bool deserializing) : base(deserializing) { }
+    protected PackingSequenceRandomCreator(PackingSequenceRandomCreator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingSequenceRandomCreator(this, cloner);
+    }
+
+    public PackingSequenceRandomCreator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfPackingItems", "The number of packing-items handled in this problem instance."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The randomly created solution candidate."));
+    }
+
+    public override IOperation Apply() {
+      Apply(NumberOfPackingItemsParameter.ActualValue.Value, RandomParameter.ActualValue);
+      return base.Apply();
+    }
+
+    public static Permutation Apply(int items, IRandom random) {
+      return new Permutation(PermutationTypes.Absolute, items, random);
+    }
+    protected override IItem CreateSolution() {
+      return Apply(NumberOfPackingItemsParameter.ActualValue.Value, RandomParameter.ActualValue);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceScrambleManipulator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceScrambleManipulator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/PackingSequence/PackingSequenceScrambleManipulator.cs	(revision 14146)
@@ -0,0 +1,47 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
+  [Item("PackingSequence Scramble Manipulator", "An operator which manipulates a PackingSequence representation.")]
+  [StorableClass]
+  public class PackingSequenceScrambleManipulator : PackingSequenceManipulator, IPackingSequenceOperator {
+    [StorableConstructor]
+    protected PackingSequenceScrambleManipulator(bool deserializing) : base(deserializing) { }
+    protected PackingSequenceScrambleManipulator(PackingSequenceScrambleManipulator original, Cloner cloner) : base(original, cloner) { }
+    public PackingSequenceScrambleManipulator()
+      : base() {
+      EncodedSolutionParameter.ActualName = "PackingSequence";
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PackingSequenceScrambleManipulator(this, cloner);
+    }
+
+    protected override void Manipulate(IRandom random, Permutation individual) {
+      ScrambleManipulator.Apply(random, individual);
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Problem.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Problem.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Problem.cs	(revision 14146)
@@ -0,0 +1,251 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Optimization;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+using HeuristicLab.PluginInfrastructure;
+using System.Linq;
+using System;
+using HeuristicLab.Encodings.PackingEncoding;
+
+namespace HeuristicLab.Problems.BinPacking {
+  [StorableClass]
+  public abstract class Problem<D, B, I> : SingleObjectiveHeuristicOptimizationProblem<IDecodingEvaluator, IPackingSolutionCreator>
+    where D : class, IPackingPosition
+    where B : PackingShape<D>, new()
+    where I : PackingShape<D>, IPackingItem, new() {
+
+
+    #region Parameter Properties
+    public OptionalValueParameter<PackingPlan<D, B, I>> BestKnownSolutionParameter {
+      get { return (OptionalValueParameter<PackingPlan<D, B, I>>)Parameters["BestKnownSolution"]; }
+    }
+    public ValueParameter<ItemList<I>> PackingItemMeasuresParameter {
+      get { return (ValueParameter<ItemList<I>>)Parameters["PackingItemMeasures"]; }
+    }
+    public IFixedValueParameter<IntValue> PackingItemsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["PackingItems"]; }
+    }
+    public IFixedValueParameter<IntValue> LowerBoundParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["LowerBound"]; }
+    }
+    public ValueParameter<IEvaluator> PackingPlanEvaluatorParameter {
+      get { return (ValueParameter<IEvaluator>)Parameters["PackingPlanEvaluator"]; }
+    }
+    public IValueParameter<B> PackingBinMeasuresParameter {
+      get { return (IValueParameter<B>)Parameters["PackingBinMeasures"]; }
+    }
+    public IConstrainedValueParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
+      get { return (IConstrainedValueParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
+    }
+    #endregion
+
+    #region Properties
+    public PackingPlan<D, B, I> BestKnownSolution {
+      get { return BestKnownSolutionParameter.Value; }
+      set { BestKnownSolutionParameter.Value = value; }
+    }
+    public ItemList<I> PackingItemMeasures {
+      get { return PackingItemMeasuresParameter.Value; }
+      set { PackingItemMeasuresParameter.Value = value; }
+    }
+    public IEvaluator PackingPlanEvaluator {
+      get { return PackingPlanEvaluatorParameter.Value; }
+      set { PackingPlanEvaluatorParameter.Value = value; }
+    }
+    public B PackingBinMeasures {
+      get { return PackingBinMeasuresParameter.Value; }
+      set { PackingBinMeasuresParameter.Value = value; }
+    }
+    public PackingSolutionDecoder<D, B, I> PackingSolutionDecoder {
+      get { return PackingSolutionDecoderParameter.Value as PackingSolutionDecoder<D, B, I>; }
+      set { PackingSolutionDecoderParameter.Value = value; }
+    }
+    #endregion
+
+
+    [StorableConstructor]
+    protected Problem(bool deserializing) : base(deserializing) { }
+    protected Problem(Problem<D, B, I> original, Cloner cloner)
+      : base(original, cloner) {
+      InitializeEventHandlers();
+    }
+
+    protected Problem(IDecodingEvaluator e) : this(e, new PackingSequenceRandomCreator()) { }
+
+    protected Problem(IDecodingEvaluator e, IPackingSolutionCreator c)
+      : base(e, c) {
+      Parameters.Add(new OptionalValueParameter<PackingPlan<D, B, I>>("BestKnownSolution", "The best known solution of this bin-packing instance."));
+      Parameters.Add(new ValueParameter<ItemList<I>>("PackingItemMeasures", "Packing-item data defining the measures of the different items that need to be packed.", new ItemList<I>()));
+
+      Parameters.Add(new FixedValueParameter<IntValue>("PackingItems", "The number of packing-items used in this bin packing instance.", new IntValue()));
+      Parameters.Add(new FixedValueParameter<IntValue>("LowerBound", "The lower possible number of bins needed to solve this problem (taken from Dell'Amico, Martello and Vigo; 2002)", new IntValue()));
+      Parameters.Add(new ValueParameter<B>("PackingBinMeasures", "Packing-bin data defining the measures of the used bins.", new B()));
+      Parameters.Add(new ValueParameter<IEvaluator>("PackingPlanEvaluator", "The evaluator is used to determine the quality of a solution.", CreateDefaultEvaluator()));
+      Parameters.Add(new ConstrainedValueParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The operator that decodes the representation and creates a packing plan."));
+      this.Maximization.Value = true;
+      InitializeProblemInstance(); // TODO
+      InitializeOperators();
+      InitializeEventHandlers();
+    }
+
+    protected abstract void InitializeDecoder();
+    protected virtual void InitializeProblemInstance() {
+      InitializeProblemData();
+      ApplyHorizontalOrientation();
+      SortItems();
+      RemoveTooBigItems();
+      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
+      LowerBoundParameter.Value.Value = CalculateLowerBound();
+    }
+    protected virtual void InitializeOperators() {
+      Operators.Clear();
+      Operators.Add(new BestBinPackingSolutionAnalyzer<D, B, I>());
+
+      ApplyEncoding();
+      ParameterizeOperators();
+    }
+    protected virtual void InitializeEventHandlers() {
+      PackingPlanEvaluatorParameter.ValueChanged += PackingPlanEvaluatorParameter_ValueChanged;
+      PackingPlanEvaluator.QualityParameter.ActualNameChanged += PackingPlanEvaluator_QualityParameter_ActualNameChanged;
+      SolutionCreatorParameter.ValueChanged += SolutionCreatorParameter_ValueChanged;
+      SolutionCreator.EncodedSolutionParameter.ActualNameChanged += SolutionCreator_EncodedSolutionParameter_ActualNameChanged;
+      PackingSolutionDecoderParameter.ValueChanged += PackingSolutionDecoderParameter_ValueChanged;
+      if (PackingSolutionDecoder != null) PackingSolutionDecoder.PackingPlanParameter.ActualNameChanged += PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged;
+    }
+
+
+    protected abstract void RemoveTooBigItems();
+    protected abstract void InitializeProblemData();
+    protected abstract IEvaluator CreateDefaultEvaluator();
+    protected void ApplyHorizontalOrientation() {
+      PackingBinMeasures.ApplyHorizontalOrientation();
+      foreach (IPackingShape shape in PackingItemMeasures) {
+        shape.ApplyHorizontalOrientation();
+      }
+    }
+    protected void SortItems() {
+      PackingItemMeasures.Sort((x, y) => y.CompareTo(x));
+    }
+    protected int CalculateLowerBound() {
+      //This is the obvious continuous lower bound calculation; Martello and Vigo proposed a better way but it has not been implemented yet;
+      int items = PackingItemMeasures.Select(x => x.Volume).Sum();
+      int bin = PackingBinMeasures.Volume;
+      return (items + bin - 1) / (bin);
+    }
+
+    private void ApplyEncoding() {
+      if (SolutionCreator.GetType() == typeof(PackingSequenceRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IPackingSequenceOperator>());
+        InitializeDecoder();
+      } /* else if (SolutionCreator.GetType() == typeof(GroupingVectorRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IGroupingVectorOperator>());
+        InitializeDecoder();
+      } else if (SolutionCreator.GetType() == typeof(MultiComponentVectorRandomCreator)) {
+        Operators.AddRange(ApplicationManager.Manager.GetInstances<IMultiComponentVectorOperator>());
+        InitializeDecoder();
+      } */
+    }
+    private void ParameterizeOperators() {
+      foreach (var op in Operators.OfType<BestBinPackingSolutionAnalyzer<D, B, I>>()) {
+        op.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
+      }
+
+      Evaluator.PackingSolutionDecoderParameter.ActualName = PackingSolutionDecoderParameter.Name;
+      Evaluator.PackingSolutionDecoderParameter.Hidden = true;
+      Evaluator.PackingPlanEvaluatorParameter.ActualName = PackingPlanEvaluatorParameter.Name;
+      Evaluator.PackingPlanEvaluatorParameter.Hidden = true;
+      Evaluator.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
+      Evaluator.QualityParameter.Hidden = true;
+
+      if (PackingSolutionDecoder != null)
+        PackingSolutionDecoder.EncodedSolutionParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+
+      if (PackingSolutionDecoder != null) {
+        PackingPlanEvaluator.PackingPlanParameter.ActualName = PackingSolutionDecoder.PackingPlanParameter.ActualName;
+        PackingPlanEvaluator.PackingPlanParameter.Hidden = true;
+      } else {
+        PackingPlanEvaluator.PackingPlanParameter.ActualName = PackingPlanEvaluator.PackingPlanParameter.Name;
+        PackingPlanEvaluator.PackingPlanParameter.Hidden = false;
+      }
+      /*
+
+      foreach (var op in Operators.OfType<IPackingSolutionManipulator>()) {
+        op.EncodedSolutionParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+        op.EncodedSolutionParameter.Hidden = true;
+      }
+
+      foreach (var op in Operators.OfType<IPackingSolutionCrossover>()) {
+        op.ChildParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+        op.ChildParameter.Hidden = true;
+        op.ParentsParameter.ActualName = SolutionCreator.EncodedSolutionParameter.ActualName;
+        op.ParentsParameter.Hidden = true;
+      }
+      */
+      foreach (var op in Operators.OfType<BestBinPackingSolutionAnalyzer<D, B, I>>()) {
+        op.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;
+        if (PackingSolutionDecoder != null) {
+          op.PackingPlanParameter.ActualName = PackingSolutionDecoder.PackingPlanParameter.ActualName;
+          op.PackingPlanParameter.Hidden = true;
+        } else {
+          op.PackingPlanParameter.ActualName = op.PackingPlanParameter.Name;
+          op.PackingPlanParameter.Hidden = false;
+        }
+      }
+
+    }
+
+    #region Events
+    protected override void OnSolutionCreatorChanged() {
+      InitializeOperators();
+    }
+    protected override void OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
+      ParameterizeOperators();
+    }
+    private void PackingPlanEvaluatorParameter_ValueChanged(object sender, EventArgs eventArgs) {
+      PackingPlanEvaluator.QualityParameter.ActualNameChanged += PackingPlanEvaluator_QualityParameter_ActualNameChanged;
+      ParameterizeOperators();
+    }
+    private void PackingPlanEvaluator_QualityParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs eventArgs) {
+      SolutionCreator.EncodedSolutionParameter.ActualNameChanged += SolutionCreator_EncodedSolutionParameter_ActualNameChanged;
+      ParameterizeOperators();
+    }
+    private void SolutionCreator_EncodedSolutionParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+    private void PackingSolutionDecoderParameter_ValueChanged(object sender, EventArgs eventArgs) {
+      if (PackingSolutionDecoder != null) PackingSolutionDecoder.PackingPlanParameter.ActualNameChanged += PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged;
+      ParameterizeOperators();
+    }
+    private void PackingSolutionDecoder_PackingPlanParameter_ActualNameChanged(object sender, EventArgs eventArgs) {
+      ParameterizeOperators();
+    }
+    #endregion
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Problem2d.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Problem2d.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Problem2d.cs	(revision 14146)
@@ -0,0 +1,154 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.Instances;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Problems.BinPacking2D {
+  [Item("Bin Packing Problem (2D, identical rectangles) (BPP)", "Represents a two-dimensional bin-packing problem using only bins with identical measures and bins/items with rectangular shapes.")]
+  [StorableClass]
+  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 300)]
+  public class Problem : Problem<PackingPosition, PackingShape, PackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
+
+    #region Default Instance
+    private static readonly BPPData DefaultInstance = new BPPData() {
+      Name = "2D BPP Default Instance",
+      Description = "The default instance for 2D Bin Packing.",
+      BinShape = new PackingShape(20, 16),
+      Items = new PackingItem[] {
+        new PackingItem(3,  8, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(5,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(9,  3, new PackingShape(20, 16)) { Material = 1, Weight = 1.0},
+        new PackingItem(2,  7, new PackingShape(20, 16)) { Material = 1, Weight = 1.0}
+      },
+    };
+    #endregion
+
+    [StorableConstructor]
+    protected Problem(bool deserializing) : base(deserializing) { }
+    protected Problem(Problem original, Cloner cloner)
+          : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Problem(this, cloner);
+    }
+    public Problem() : base(
+          new DecodingEvaluator<Permutation, PackingPosition, PackingShape, PackingItem>()) {
+    }
+
+    #region Problem instance handling
+    public void Load(BPPData data) {
+
+      BestKnownQuality = data.BestKnownQuality.HasValue ? new DoubleValue(data.BestKnownQuality.Value) : null;
+
+      PackingBinMeasures = data.BinShape;
+      PackingItemMeasures = new ItemList<PackingItem>(data.Items);
+
+      ApplyHorizontalOrientation();
+      SortItems();
+      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
+      LowerBoundParameter.Value.Value = CalculateLowerBound();
+    }
+
+
+    public BPPData Export() {
+      return new BPPData {
+        Name = Name,
+        Description = Description,
+        BinShape = PackingBinMeasures,
+        Items = PackingItemMeasures.ToArray()
+      };
+    }
+    #endregion
+
+    #region Helpers
+    protected override void InitializeDecoder() {
+      // Operators.RemoveAll(op => op is I3DOperator); TODO
+
+      PackingSolutionDecoderParameter.ValidValues.Clear();
+      if (SolutionCreator is PackingSequenceRandomCreator) {
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DPSDecoder>());
+      } /*else if (SolutionCreator is GroupingVectorRandomCreator) {
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DGVDecoder>());
+      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I2DMCVDecoder>());
+      } */ else {
+        string error = "The given problem does not support the selected solution-creator.";
+        ErrorHandling.ShowErrorDialog(error, null);
+      }
+    }
+
+    protected override IEvaluator CreateDefaultEvaluator() {
+      return new PackingRatioEvaluator();
+    }
+
+    protected override void InitializeProblemData() {
+      Load(DefaultInstance);
+    }
+
+    protected override void RemoveTooBigItems() {
+      PackingItemMeasures.RemoveAll(pi =>
+        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, false), pi) &&
+        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, true), pi));
+    }
+    #endregion
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/Problem3D.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/Problem3D.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/Problem3D.cs	(revision 14146)
@@ -0,0 +1,156 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Problems.Instances;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.BinPacking;
+
+namespace HeuristicLab.Problems.BinPacking3D {
+  [Item("Bin Packing Problem (3D, identical cuboids) (BPP)", "Represents a three-dimensional bin-packing problem using only bins with identical measures and bins/items with cuboidic shapes.")]
+  [StorableClass]
+  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 310)]
+  public class Problem : Problem<PackingPosition, PackingShape, PackingItem>, IProblemInstanceConsumer<BPPData>, IProblemInstanceExporter<BPPData> {
+    #region Default Instance
+    private static readonly BPPData DefaultInstance = new BPPData() {
+      Name = "3D BPP Default Instance",
+      Description = "The default instance for 3D Bin Packing.",
+      BinShape = new PackingShape(25, 25, 35),
+      Items = new PackingItem[] {
+        new PackingItem(12,5,10, new PackingShape(25,25,35)),
+        new PackingItem(10,18,20, new PackingShape(25,25,35)),
+        new PackingItem(9,7,7, new PackingShape(25,25,35)),
+        new PackingItem(21,12,4, new PackingShape(25,25,35)),
+        new PackingItem(8,8,12, new PackingShape(25,25,35)),
+        new PackingItem(3,6,14, new PackingShape(25,25,35)),
+        new PackingItem(20,4,9, new PackingShape(25,25,35)),
+        new PackingItem(5,9,8, new PackingShape(25,25,35)),
+        new PackingItem(7,17,3, new PackingShape(25,25,35)),
+        new PackingItem(13,20,15, new PackingShape(25,25,35)),
+        new PackingItem(9,11,9, new PackingShape(25,25,35)),
+        new PackingItem(10,18,20, new PackingShape(25,25,35)),
+        new PackingItem(9,7,7, new PackingShape(25,25,35)),
+        new PackingItem(21,12,4, new PackingShape(25,25,35)),
+        new PackingItem(8,8,12, new PackingShape(25,25,35)),
+        new PackingItem(3,6,14, new PackingShape(25,25,35)),
+        new PackingItem(20,4,9, new PackingShape(25,25,35)),
+        new PackingItem(5,9,8, new PackingShape(25,25,35)),
+        new PackingItem(7,17,3, new PackingShape(25,25,35)),
+        new PackingItem(13,20,15, new PackingShape(25,25,35)),
+        new PackingItem(9,11,9, new PackingShape(25,25,35)),
+        new PackingItem(10,18,20, new PackingShape(25,25,35)),
+        new PackingItem(9,7,7, new PackingShape(25,25,35)),
+        new PackingItem(21,12,4, new PackingShape(25,25,35)),
+        new PackingItem(8,8,12, new PackingShape(25,25,35)),
+        new PackingItem(3,6,14, new PackingShape(25,25,35)),
+        new PackingItem(20,4,9, new PackingShape(25,25,35)),
+        new PackingItem(5,9,8, new PackingShape(25,25,35)),
+        new PackingItem(7,17,3, new PackingShape(25,25,35)),
+        new PackingItem(13,20,15, new PackingShape(25,25,35)),
+        new PackingItem(9,11, 9,new PackingShape(25,25,35)),
+        new PackingItem(10,18,20, new PackingShape(25,25,35)),
+        new PackingItem(9,7,7, new PackingShape(25,25,35)),
+        new PackingItem(21,12,4, new PackingShape(25,25,35)),
+        new PackingItem(8,8,12, new PackingShape(25,25,35)),
+        new PackingItem(3,6,14, new PackingShape(25,25,35)),
+        new PackingItem(20,4,9, new PackingShape(25,25,35)),
+        new PackingItem(5,9,8, new PackingShape(25,25,35)),
+        new PackingItem(7,17,3, new PackingShape(25,25,35)),
+        new PackingItem(13,20,15, new PackingShape(25,25,35)),
+        new PackingItem(9,11,9, new PackingShape(25,25,35))
+      },
+    };
+    #endregion
+
+    [StorableConstructor]
+    protected Problem(bool deserializing) : base(deserializing) { }
+    protected Problem(Problem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Problem(this, cloner);
+    }
+    public Problem() : base(
+      new DecodingEvaluator<Permutation, PackingPosition, PackingShape, PackingItem>()) {
+    }
+
+    public void Load(BPPData data) {
+
+
+      BestKnownQuality = data.BestKnownQuality.HasValue ? new DoubleValue(data.BestKnownQuality.Value) : null;
+
+      PackingBinMeasures = data.BinShape;
+      PackingItemMeasures = new ItemList<PackingItem>(data.Items);
+
+      ApplyHorizontalOrientation();
+      SortItems();
+      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
+      LowerBoundParameter.Value.Value = CalculateLowerBound();
+    }
+
+    public BPPData Export() {
+      return new BPPData {
+        Name = Name,
+        Description = Description,
+        BinShape = PackingBinMeasures,
+        Items = PackingItemMeasures.ToArray()
+      };
+    }
+
+    #region Helpers
+    protected override void InitializeDecoder() {
+      // Operators.RemoveAll(op => op is I2DOperator); TODO
+
+      PackingSolutionDecoderParameter.ValidValues.Clear();
+      if (SolutionCreator is PackingSequenceRandomCreator) {
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DPSDecoder>());
+      } /* else if (SolutionCreator is GroupingVectorRandomCreator) {
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DGVDecoder>());
+      } else if (SolutionCreator is MultiComponentVectorRandomCreator) {
+        PackingSolutionDecoderParameter.ValidValues.UnionWith(ApplicationManager.Manager.GetInstances<I3DMCVDecoder>());
+      } */ else {
+        string error = "The given problem does not support the selected solution-creator.";
+        ErrorHandling.ShowErrorDialog(error, null);
+      }
+    }
+
+    protected override IEvaluator CreateDefaultEvaluator() {
+      return new PackingRatioEvaluator();
+    }
+
+    protected override void InitializeProblemData() {
+      Load(DefaultInstance);
+    }
+
+    protected override void RemoveTooBigItems() {
+      PackingItemMeasures.RemoveAll(pi =>
+        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, 0, false), pi) &&
+        !PackingBinMeasures.Encloses(new PackingPosition(0, 0, 0, 0, true), pi));
+    }
+    #endregion
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/evaluators/DecodingEvaluator.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/evaluators/DecodingEvaluator.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/evaluators/DecodingEvaluator.cs	(revision 14146)
@@ -0,0 +1,84 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and 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.Operators;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+
+
+namespace HeuristicLab.Problems.BinPacking {
+  [Item("Bin Packing Evaluator (with decoder)", "Represents a composition of a decoder and an evaluator for bin-packing problems.")]
+  [StorableClass]
+  public class DecodingEvaluator<E, D, B, I> : SingleSuccessorOperator, IDecodingEvaluator
+    where E : Item //E defines the used Encoding
+    where D : class, IPackingPosition
+    where B : PackingShape<D>
+    where I : PackingShape<D>, IPackingItem {
+
+    public IValueLookupParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
+      get { return (IValueLookupParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
+    }
+    ILookupParameter<IPackingSolutionDecoder> IDecodingEvaluator.PackingSolutionDecoderParameter {
+      get { return PackingSolutionDecoderParameter; }
+    }
+    public IValueLookupParameter<IEvaluator> PackingPlanEvaluatorParameter {
+      get { return (IValueLookupParameter<IEvaluator>)Parameters["PackingPlanEvaluator"]; }
+    }
+    ILookupParameter<IEvaluator> IDecodingEvaluator.PackingPlanEvaluatorParameter {
+      get { return PackingPlanEvaluatorParameter; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    [StorableConstructor]
+    protected DecodingEvaluator(bool deserializing) : base(deserializing) { }
+    protected DecodingEvaluator(DecodingEvaluator<E, D, B, I> original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public DecodingEvaluator ()
+      : base() {
+        Parameters.Add(new ValueLookupParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The decoding operator that is used to calculate a packing plan from the used representation."));
+        Parameters.Add(new ValueLookupParameter<IEvaluator>("PackingPlanEvaluator", "The actual packing plan evaluation operator."));
+        Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value aka fitness value of the solution."));
+        QualityParameter.Hidden = true;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DecodingEvaluator<E, D, B, I>(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var decoder = PackingSolutionDecoderParameter.ActualValue;
+      var evaluator = PackingPlanEvaluatorParameter.ActualValue;
+      if (evaluator == null) throw new InvalidOperationException("A PackingPlanEvaluator could not be found.");
+
+      var operations = new OperationCollection(base.Apply());
+      operations.Insert(0, ExecutionContext.CreateChildOperation(evaluator));
+      if (decoder != null) // decode before evaluating
+        operations.Insert(0, ExecutionContext.CreateChildOperation(decoder));
+      return operations;
+    }
+  }
+}
Index: /branches/HeuristicLab.BinPacking/old files/evaluators/EvaluatorBase.cs
===================================================================
--- /branches/HeuristicLab.BinPacking/old files/evaluators/EvaluatorBase.cs	(revision 14146)
+++ /branches/HeuristicLab.BinPacking/old files/evaluators/EvaluatorBase.cs	(revision 14146)
@@ -0,0 +1,83 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Problems.BinPacking {
+  [Item("Packingplan Evaluator", "Represents a evaluator class for standard bin-packing problems.")]
+  [StorableClass]
+  public abstract class EvaluatorBase<D,B,I> : SingleSuccessorOperator, IEvaluator
+    where D : class, IPackingPosition
+    where B : PackingShape<D>
+    where I : PackingShape<D>, IPackingItem {
+
+    #region Parameters
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get {
+        if (Parameters.ContainsKey("Quality"))
+          return (ILookupParameter<DoubleValue>)Parameters["Quality"];
+        else
+          return null;
+      }
+    }
+    public ILookupParameter<IPackingPlan> PackingPlanParameter {
+      get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlan"]; }
+    }
+    public ILookupParameter<ItemList<I>> PackingItemMeasuresParameter {
+      get { return (ILookupParameter<ItemList<I>>)Parameters["PackingItemMeasures"]; }
+    }
+    public ILookupParameter<B> PackingBinMeasuresParameter {
+      get { return (ILookupParameter<B>)Parameters["PackingBinMeasures"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected EvaluatorBase(bool deserializing) : base(deserializing) { }
+    protected EvaluatorBase(EvaluatorBase<D,B,I> original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public EvaluatorBase()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value of the solution."));
+      Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlan", "The decoded bin-packing solution represented as generalized packing-plan."));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
+      Parameters.Add(new LookupParameter<ItemList<I>>("PackingItemMeasures", "Packing-item data taken from the bin-packing problem-instance."));
+      Parameters.Add(new LookupParameter<B>("PackingBinMeasures", "Packing-bin data taken from the bin-packing problem-instance."));
+
+    }
+
+    protected abstract double Evaluate();                                                                        
+    public override IOperation Apply() {
+      QualityParameter.ActualValue = new DoubleValue(Evaluate());
+      return base.Apply();
+    }
+  }
+}
