Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/BinPackingProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/BinPackingProblem.cs	(revision 13608)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/BinPackingProblem.cs	(revision 13608)
@@ -0,0 +1,93 @@
+﻿#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.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.Shapes;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Parameters;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.BinPacking.Problem {
+  [Item("BinPackingProblem", "Abstract class that represents a BinPacking Problem")]
+  [StorableClass]
+  public abstract class BinPackingProblem<D, B, I> : SingleObjectiveHeuristicOptimizationProblem<IPackingPlanEvaluationAlgorithm, IPackingSolutionCreator> 
+    where D : class, IPackingDimensions 
+    where B : PackingShape<D>, IPackingBin, 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<IPackingPlanEvaluator> PackingPlanEvaluatorParameter {
+      get { return (ValueParameter<IPackingPlanEvaluator>)Parameters["PackingPlanEvaluator"]; }
+    }
+    #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 IPackingPlanEvaluator PackingPlanEvaluator {
+      get { return PackingPlanEvaluatorParameter.Value; }
+      set { PackingPlanEvaluatorParameter.Value = value; }
+    }
+    #endregion
+
+
+    [StorableConstructor]
+    protected BinPackingProblem(bool deserializing) : base(deserializing) { }
+    protected BinPackingProblem(BinPackingProblem<D,B,I> original, Cloner cloner)
+      : base(original, cloner) {
+    }                 
+    protected BinPackingProblem(IPackingPlanEvaluationAlgorithm 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()));
+    }
+
+    protected abstract void InitializeDecoder(); 
+    protected abstract void InitializeProblemInstance();
+    protected abstract void InitializeOperators();
+    protected abstract void InitializeEventHandlers();
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/PackingSolutionDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/PackingSolutionDecoder.cs	(revision 13607)
+++ 	(revision )
@@ -1,85 +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.Problems.BinPacking.Interfaces;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Operators;
-using HeuristicLab.Parameters;
-using HeuristicLab.Problems.BinPacking.Shapes;
-using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Problems.BinPacking.Decoders {
-
-  [Item("Packing-Solution Decoder", "An operator to create a concrete bin packing solution from a given encoding-instance.")]
-  [StorableClass]
-  public abstract class PackingSolutionDecoder<D, B, I> : SingleSuccessorOperator, IPackingSolutionDecoder
-    where D : class, IPackingDimensions
-    where B : PackingShape<D>, IPackingBin
-    where I : PackingShape<D>, IPackingItem {
-
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    private ILookupParameter<ItemList<I>> PackingItemMeasuresParameter {
-      get { return (LookupParameter<ItemList<I>>)Parameters["PackingItemMeasures"]; }
-    }
-    private ILookupParameter<B> PackingBinMeasuresParameter {
-      get { return (LookupParameter<B>)Parameters["PackingBinMeasures"]; }
-    }
-    public ILookupParameter<IItem> EncodedSolutionParameter {
-      get { return (ILookupParameter<IItem>)Parameters["EncodedSolution"]; }
-    }
-    public ILookupParameter<PackingPlan<D,B,I>> PackingPlanParameter {
-      get { return (ILookupParameter<PackingPlan<D, B, I>>)Parameters["PackingPlan"]; }
-    }
-    public ValueParameter<BoolValue> StackingConstraintsParameter {
-      get { return (ValueParameter<BoolValue>)Parameters["StackingConstraint"]; }
-    }
-
-
-    public PackingSolutionDecoder() : base() {
-      Parameters.Add(new LookupParameter<IItem>("EncodedSolution", "The new bin-packing solution represented as encoding."));
-      Parameters.Add(new LookupParameter<PackingPlan<D, B, I>>("PackingPlan", "The decoded bin-packing solution represented as generalized packing plan."));
-      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new LookupParameter<ItemList<I>>("PackingItemMeasures", "Packing-item data taken from the bin-packing problem-instance."));
-      Parameters.Add(new LookupParameter<B>("PackingBinMeasures", "Packing-bin data taken from the bin-packing problem-instance."));
-      Parameters.Add(new ValueParameter<BoolValue>("StackingConstraint", "A flag determining whether stackingconstraints should be enforced or not.", new BoolValue(true)));
-    }
-
-    [StorableConstructor]
-    protected PackingSolutionDecoder(bool deserializing) : base(deserializing) { }
-    protected PackingSolutionDecoder(PackingSolutionDecoder<D,B,I> original, Cloner cloner)
-      : base(original, cloner) {
-    }
-
-    public abstract PackingPlan<D, B, I> CreatePackingPlanFromEncoding(IItem solution, B binMeasures, ItemList<I> itemMeasures);
-
-    public override IOperation Apply() {
-      PackingPlan<D, B, I> result = CreatePackingPlanFromEncoding(EncodedSolutionParameter.ActualValue, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
-      PackingPlanParameter.ActualValue = result;
-      return base.Apply();
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/PackingDimensions.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/PackingDimensions.cs	(revision 13607)
+++ 	(revision )
@@ -1,79 +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.Problems.BinPacking.Interfaces;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-
-namespace HeuristicLab.Problems.BinPacking.Dimensions {
-  [Item("Packing Dimensions", "Represents an abstract packing-position associated with a packing-problem.")]
-  [StorableClass]
-  // PackingDimensions is immutable (and handled as value types concerning Equals and GetHashCode)
-  public abstract class PackingDimensions : Item, IPackingDimensions {
-    /// <summary>
-    /// The number of the bin to which the current item is assigned is stored in this variable. Counting starts at 0 !!!
-    /// </summary>    
-    [Storable]
-    private readonly int assignedBin;
-    public int AssignedBin {
-      get { return assignedBin; }
-    }
-
-    [Storable]
-    private readonly bool rotated;
-    /// <summary>
-    /// Determines if the positioned item is to be rotate by 90 degrees or not. (TODO: which axis?)
-    /// </summary>
-    public bool Rotated {
-      get { return rotated; }
-    }
-
-    [StorableConstructor]
-    protected PackingDimensions(bool deserializing) : base(deserializing) { }
-    protected PackingDimensions(PackingDimensions original, Cloner cloner)
-      : base(original, cloner) {
-      assignedBin = original.AssignedBin;
-      rotated = original.Rotated;
-    }
-
-    protected PackingDimensions(int assignedBin, bool rotated) {
-      this.assignedBin = assignedBin;
-      this.rotated = rotated;
-    }
-
-    public override string ToString() {
-      return string.Format("[{0}-{1}]", AssignedBin, Rotated);
-    }
-
-    public override bool Equals(object obj) {
-      var other = obj as PackingDimensions;
-      if (other != null)
-        return (other.AssignedBin == this.AssignedBin && other.Rotated == this.Rotated);
-      else return false;
-    }
-
-    public override int GetHashCode() {
-      return 31 * AssignedBin * (Rotated ? 3 : 7);
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/ThreeDimensionalPacking.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Dimensions/ThreeDimensionalPacking.cs	(revision 13607)
+++ 	(revision )
@@ -1,98 +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.Text;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-
-namespace HeuristicLab.Problems.BinPacking.Dimensions {
-  [Item("Three Dimensional Packing", "Represents a packing-position associated with a three dimensional packing-problem.")]
-  [StorableClass]
-  // ThreeDimensionalPacking is immutable (and handled as value type concerning Equals and GetHashCode)
-  public class ThreeDimensionalPacking : PackingDimensions {
-    [Storable]
-    private readonly int x;
-    [Storable]
-    private readonly int y;
-    [Storable]
-    private readonly int z;
-
-    public int X { get { return x; } }
-    public int Y { get { return y; } }
-    public int Z { get { return z; } }
-
-    [StorableConstructor]
-    protected ThreeDimensionalPacking(bool deserializing) : base(deserializing) { }
-    protected ThreeDimensionalPacking(ThreeDimensionalPacking original, Cloner cloner)
-      : base(original, cloner) {
-      x = original.X;
-      y = original.Y;
-      z = original.Z;
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ThreeDimensionalPacking(this, cloner);
-    }
-
-    public ThreeDimensionalPacking(int assignedBin, int x, int y, int z, bool rotated = false)
-      : base(assignedBin, rotated) {
-      this.x = x;
-      this.y = y;
-      this.z = z;
-    }
-
-    public override string ToString() {
-      return string.Format("[AssignedBin: {0}; ({1},{2},{3})]", AssignedBin, X, Y, Z);
-    }
-
-
-    public override bool Equals(object obj) {
-      var tdp = obj as ThreeDimensionalPacking;
-      if (tdp != null)
-        return (tdp.X == this.X && tdp.Y == this.Y && tdp.Z == this.Z);
-      else return false;
-    }
-
-    public override int GetHashCode() {
-      return base.GetHashCode() + 13 * X + 17 * Y + 23 * Z;
-    }
-
-    public static ThreeDimensionalPacking MoveLeft(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X - 1, original.Y, original.Z, original.Rotated);
-    }
-    public static ThreeDimensionalPacking MoveDown(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y - 1, original.Z, original.Rotated);
-    }
-    public static ThreeDimensionalPacking MoveBack(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y, original.Z - 1, original.Rotated);
-    }
-
-    public static ThreeDimensionalPacking MoveRight(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X + 1, original.Y, original.Z, original.Rotated);
-    }
-    public static ThreeDimensionalPacking MoveUp(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y + 1, original.Z, original.Rotated);
-    }
-    public static ThreeDimensionalPacking MoveFront(ThreeDimensionalPacking original) {
-      return new ThreeDimensionalPacking(original.AssignedBin, original.X, original.Y, original.Z + 1, original.Rotated);
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking3D.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking3D.cs	(revision 13607)
+++ 	(revision )
@@ -1,382 +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.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-
-namespace HeuristicLab.Encodings.PackingEncoding.PackingPlan {
-  [Item("BinPacking3D", "Represents a single-bin packing for a 3D bin-packing problem.")]
-  [StorableClass]
-  public class BinPacking3D : BinPacking<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> {
-
-    public BinPacking3D(CuboidPackingBin binMeasures)
-      : base(binMeasures) {
-      //ExtremePoints = new HashSet<ThreeDimensionalPacking>();
-      ExtremePoints = new SortedSet<ThreeDimensionalPacking>(new EPComparer3D());
-      ExtremePoints.Add(binMeasures.Origin);
-    }
-    [StorableConstructor]
-    protected BinPacking3D(bool deserializing) : base(deserializing) { }
-    protected BinPacking3D(BinPacking3D original, Cloner cloner)
-      : base(original, cloner) {
-      this.depthWasDoubled = original.depthWasDoubled;
-      this.ExtremePoints = new SortedSet<ThreeDimensionalPacking>(original.ExtremePoints, new EPComparer3D());
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new BinPacking3D(this, cloner);
-    }
-
-    protected override void GenerateNewExtremePointsForNewItem(CuboidPackingItem newItem, ThreeDimensionalPacking position) {
-      int newWidth = position.Rotated ? newItem.Depth : newItem.Width;
-      int newDepth = position.Rotated ? newItem.Width : newItem.Depth;
-
-      //Find ExtremePoints beginning from sourcepointX
-      var sourcePointX = new ThreeDimensionalPacking(0, position.X + newWidth, position.Y, position.Z);
-      if (sourcePointX.X < BinMeasures.Width && sourcePointX.Y < BinMeasures.Height && sourcePointX.Z < BinMeasures.Depth) {
-        //Traversing down the y-axis  
-        ThreeDimensionalPacking current = new ThreeDimensionalPacking(0, sourcePointX.X, sourcePointX.Y, sourcePointX.Z);
-        while (current.Y > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveDown(current))) {
-          current = ThreeDimensionalPacking.MoveDown(current);
-        }
-        ExtremePoints.Add((ThreeDimensionalPacking)current.Clone());
-        while (current.X > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveLeft(current))) {
-          current = ThreeDimensionalPacking.MoveLeft(current);
-        }
-        ExtremePoints.Add(current);
-
-        //Traversing down the z-axis
-        current = new ThreeDimensionalPacking(0, sourcePointX.X, sourcePointX.Y, sourcePointX.Z);
-        while (current.Z > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveBack(current))) {
-          current = ThreeDimensionalPacking.MoveBack(current);
-        }
-        ExtremePoints.Add((ThreeDimensionalPacking)current.Clone());
-        while (current.Y > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveDown(current))) {
-          current = ThreeDimensionalPacking.MoveDown(current);
-        }
-        ExtremePoints.Add(current);
-      }
-
-
-
-
-      //Find ExtremePoints beginning from sourcepointY
-      var sourcePointY = new ThreeDimensionalPacking(0, position.X, position.Y + newItem.Height, position.Z);
-      if (sourcePointY.X < BinMeasures.Width && sourcePointY.Y < BinMeasures.Height && sourcePointY.Z < BinMeasures.Depth) {
-        //Traversing down the x-axis          
-        ThreeDimensionalPacking current = new ThreeDimensionalPacking(0, sourcePointY.X, sourcePointY.Y, sourcePointY.Z);
-        while (current.X > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveLeft(current))) {
-          current = ThreeDimensionalPacking.MoveLeft(current);
-        }
-        ExtremePoints.Add((ThreeDimensionalPacking)current.Clone());
-        while (current.Y > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveDown(current))) {
-          current = ThreeDimensionalPacking.MoveDown(current);
-        }
-        ExtremePoints.Add(current);
-
-        //Traversing down the z-axis                                                                   
-        current = new ThreeDimensionalPacking(0, sourcePointY.X, sourcePointY.Y, sourcePointY.Z);
-        while (current.Z > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveBack(current))) {
-          current = ThreeDimensionalPacking.MoveBack(current);
-        }
-        ExtremePoints.Add((ThreeDimensionalPacking)current.Clone());
-        while (current.Y > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveDown(current))) {
-          current = ThreeDimensionalPacking.MoveDown(current);
-        }
-        ExtremePoints.Add(current);
-      }
-
-
-
-
-
-      //Find ExtremePoints beginning from sourcepointZ
-      var sourcePointZ = new ThreeDimensionalPacking(0, position.X, position.Y, position.Z + newDepth);
-      if (sourcePointZ.X < BinMeasures.Width && sourcePointZ.Y < BinMeasures.Height && sourcePointZ.Z < BinMeasures.Depth) {
-        //Traversing down the x-axis                                                                             
-        ThreeDimensionalPacking current = new ThreeDimensionalPacking(0, sourcePointZ.X, sourcePointZ.Y, sourcePointZ.Z);
-        while (current.X > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveLeft(current))) {
-          current = ThreeDimensionalPacking.MoveLeft(current);
-        }
-        ExtremePoints.Add((ThreeDimensionalPacking)current.Clone());
-        while (current.Y > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveDown(current))) {
-          current = ThreeDimensionalPacking.MoveDown(current);
-        }
-        ExtremePoints.Add(current);
-
-        //Traversing down the y-axis                                                                     
-        current = new ThreeDimensionalPacking(0, sourcePointZ.X, sourcePointZ.Y, sourcePointZ.Z);
-        while (current.Y > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveDown(current))) {
-          current = ThreeDimensionalPacking.MoveDown(current);
-        }
-        ExtremePoints.Add((ThreeDimensionalPacking)current.Clone());
-        while (current.X > 0 && !IsPointOccupied(ThreeDimensionalPacking.MoveLeft(current))) {
-          current = ThreeDimensionalPacking.MoveLeft(current);
-        }
-        ExtremePoints.Add(current);
-      }
-
-      //ExtremePoints.RemoveWhere(ep => IsPointOccupied (ep));
-
-      //ExtremePoints = new HashSet<ThreeDimensionalPacking>(ExtremePoints.
-      //  OrderBy(ep => ep.Z).
-      //  ThenBy(ep => ep.X).
-      //  ThenBy(ep => ep.Y)//.ThenBy(ep => ShortestPossibleSideFromPoint(ep)) 
-      //  );
-    }
-
-    public override ThreeDimensionalPacking FindExtremePointForItem(CuboidPackingItem measures, bool rotated, bool stackingConstraints) {
-
-      CuboidPackingItem item = new CuboidPackingItem(
-        rotated ? measures.Depth : measures.Width,
-        measures.Height,
-        rotated ? measures.Width : measures.Depth,
-        measures.TargetBin);
-
-      int epIndex = 0;
-      while (epIndex < ExtremePoints.Count && (
-        !IsPositionFeasible(item, ExtremePoints.ElementAt(epIndex))
-        || !IsSupportedByAtLeastOnePoint(item, ExtremePoints.ElementAt(epIndex))
-        || (stackingConstraints && !IsStaticStable(item, ExtremePoints.ElementAt(epIndex)))
-        || (stackingConstraints && !IsWeightSupported(item, ExtremePoints.ElementAt(epIndex)))
-      )) { epIndex++; }
-
-      if (epIndex < ExtremePoints.Count) {
-        var result = ExtremePoints.ElementAt(epIndex);
-        result.Rotated = rotated;
-        return result;
-      }
-      return null;
-    }
-
-    public override ThreeDimensionalPacking FindPositionBySliding(CuboidPackingItem measures, bool rotated) {
-      //Starting-position at upper right corner (=left bottom point of item-rectangle is at position item.width,item.height)
-      ThreeDimensionalPacking currentPosition = new ThreeDimensionalPacking(0,
-        BinMeasures.Width - (rotated ? measures.Depth : measures.Width),
-        BinMeasures.Height - measures.Height,
-        BinMeasures.Depth - (rotated ? measures.Width : measures.Depth), rotated);
-      //Slide the item as far as possible to the bottom
-      while (IsPositionFeasible(measures, ThreeDimensionalPacking.MoveDown(currentPosition))
-        || IsPositionFeasible(measures, ThreeDimensionalPacking.MoveLeft(currentPosition))
-        || IsPositionFeasible(measures, ThreeDimensionalPacking.MoveBack(currentPosition))) {
-        //Slide the item as far as possible to the left
-        while (IsPositionFeasible(measures, ThreeDimensionalPacking.MoveLeft(currentPosition))
-      || IsPositionFeasible(measures, ThreeDimensionalPacking.MoveBack(currentPosition))) {
-          //Slide the item as far as possible to the back
-          while (IsPositionFeasible(measures, ThreeDimensionalPacking.MoveBack(currentPosition))) {
-            currentPosition = ThreeDimensionalPacking.MoveBack(currentPosition);
-          }
-          if (IsPositionFeasible(measures, ThreeDimensionalPacking.MoveLeft(currentPosition)))
-            currentPosition = ThreeDimensionalPacking.MoveLeft(currentPosition);
-        }
-        if (IsPositionFeasible(measures, ThreeDimensionalPacking.MoveDown(currentPosition)))
-          currentPosition = ThreeDimensionalPacking.MoveDown(currentPosition);
-      }
-
-      return IsPositionFeasible(measures, currentPosition) ? currentPosition : null;
-    }
-
-    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<CuboidPackingItem> itemMeasures) {
-      var temp = new List<int>(sequence);
-      for (int i = 0; i < temp.Count; i++) {
-        var item = itemMeasures[temp[i]];
-        var position = FindPositionBySliding(item, false);
-        if (position != null) {
-          PackItem(temp[i], item, position);
-          sequence.Remove(temp[i]);
-        }
-      }
-    }
-    public override void SlidingBasedPacking(ref List<int> sequence, ItemList<CuboidPackingItem> itemMeasures, Dictionary<int, bool> rotationArray) {
-      var temp = new List<int>(sequence);
-      for (int i = 0; i < temp.Count; i++) {
-        var item = itemMeasures[temp[i]];
-        var position = FindPositionBySliding(item, rotationArray[i]);
-        if (position != null) {
-          PackItem(temp[i], item, position);
-          sequence.Remove(temp[i]);
-        }
-      }
-    }
-    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints) {
-      var temp = new List<int>(sequence);
-      foreach (int itemID in temp) {
-        var item = itemMeasures[itemID];
-        var positionFound = FindExtremePointForItem(item, false, stackingConstraints);
-        if (positionFound != null) {
-          PackItem(itemID, item, positionFound);
-          sequence.Remove(itemID);
-        }
-      }
-    }
-    public override void ExtremePointBasedPacking(ref List<int> sequence, ItemList<CuboidPackingItem> itemMeasures, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
-      var temp = new List<int>(sequence);
-      foreach (int itemID in temp) {
-        var item = itemMeasures[itemID];
-        var positionFound = FindExtremePointForItem(item, rotationArray[itemID], stackingConstraints);
-        if (positionFound != null) {
-          PackItem(itemID, item, positionFound);
-          sequence.Remove(itemID);
-        }
-      }
-    }
-
-    public override int ShortestPossibleSideFromPoint(ThreeDimensionalPacking position) {
-
-      int shortestSide = int.MaxValue;
-      int width = BinMeasures.Width;
-      int height = BinMeasures.Height;
-      int depth = BinMeasures.Depth;
-
-      if (position.X >= width || position.Y >= height || position.Z >= depth)
-        return shortestSide;
-
-      ThreeDimensionalPacking current = new ThreeDimensionalPacking(0, position.X, position.Y, position.Z);
-      while (current.X < width && IsPointOccupied(current)) { current = ThreeDimensionalPacking.MoveRight(current); }
-      if (current.X - position.X < shortestSide)
-        shortestSide = current.X - position.X;
-
-
-      current = new ThreeDimensionalPacking(0, position.X, position.Y, position.Z);
-      while (current.Y < height && IsPointOccupied(current)) { current = ThreeDimensionalPacking.MoveUp(current); }
-      if (current.Y - position.Y < shortestSide)
-        shortestSide = current.Y - position.Y;
-
-
-      current = new ThreeDimensionalPacking(0, position.X, position.Y, position.Z);
-      while (current.Z < depth && IsPointOccupied(current)) { current = ThreeDimensionalPacking.MoveFront(current); }
-      if (current.Z - position.Z < shortestSide)
-        shortestSide = current.Z - position.Z;
-
-      return shortestSide;
-    }
-    public override bool IsStaticStable(CuboidPackingItem item, ThreeDimensionalPacking position) {
-      //Static stability is given, if item is placed on the ground
-      if (position.Y == 0)
-        return true;
-
-      if (IsPointOccupied(new ThreeDimensionalPacking(0, position.X, position.Y - 1, position.Z))
-        && IsPointOccupied(new ThreeDimensionalPacking(0, position.X + item.Width - 1, position.Y - 1, position.Z))
-        && IsPointOccupied(new ThreeDimensionalPacking(0, position.X, position.Y - 1, position.Z + item.Depth - 1))
-        && IsPointOccupied(new ThreeDimensionalPacking(0, position.X + item.Width - 1, position.Y - 1, position.Z + item.Depth - 1)))
-        return true;
-
-
-      //if (occupiedPoints[position.X, position.Y - 1, position.Z] != -1
-      //  && occupiedPoints[position.X + item.Width - 1, position.Y - 1, position.Z] != -1
-      //  && occupiedPoints[position.X, position.Y - 1, position.Z + item.Depth - 1] != -1
-      //  && occupiedPoints[position.X + item.Width - 1, position.Y - 1, position.Z + item.Depth - 1] != -1)
-      //  return true;
-
-      //int groundCount = 0;
-      //for (int x = ep.X; x < ep.X + item.Width - 1; x++) {
-      //  for (int z = ep.Z; z < ep.Z + item.Depth - 1; z++) {
-      //    if (occupiedPoints[x,ep.Y-1, z] != -1)                                                     
-      //      groundCount++;
-      //  }
-      //}
-      //double stableGround = (double)(groundCount) / (double)(item.Width * item.Depth);
-      //if (stableGround > 0.75)
-      //  return true;
-
-      return false;
-    }
-
-    [Storable]
-    private bool depthWasDoubled = false;
-    public void DoubleDepth() {
-      if (!depthWasDoubled) {
-        var oldDepth = BinMeasures.Depth;
-        BinMeasures.Depth = BinMeasures.Depth * 2;
-        //OccupiedPoints.ChangeBinMeasures(BinMeasures);
-        depthWasDoubled = true;
-      }
-    }
-
-    public bool IsSupportedByAtLeastOnePoint(CuboidPackingItem item, ThreeDimensionalPacking position) {
-      if (position.Y == 0)
-        return true;
-
-      int y = position.Y - 1;
-      for (int x = position.X; x < position.X + item.Width; x++)
-        for (int z = position.Z; z < position.Z + item.Depth; z++)
-          if (IsPointOccupied(new ThreeDimensionalPacking(0, x, y, z)))
-            return true;
-
-      return false;
-    }
-    public bool IsWeightSupported(CuboidPackingItem item, ThreeDimensionalPacking ep) {
-      if (ep.Y == 0)
-        return true;
-
-      if (ItemMeasures[PointOccupation(new ThreeDimensionalPacking(0, ep.X, ep.Y - 1, ep.Z))].SupportsStacking(item)
-        && ItemMeasures[PointOccupation(new ThreeDimensionalPacking(0, ep.X + item.Width - 1, ep.Y - 1, ep.Z))].SupportsStacking(item)
-        && ItemMeasures[PointOccupation(new ThreeDimensionalPacking(0, ep.X, ep.Y - 1, ep.Z + item.Depth - 1))].SupportsStacking(item)
-        && ItemMeasures[PointOccupation(new ThreeDimensionalPacking(0, ep.X + item.Width - 1, ep.Y - 1, ep.Z + item.Depth - 1))].SupportsStacking(item))
-        return true;
-
-      return false;
-    }
-
-
-    protected override void InitializeOccupationLayers() {
-      for (int i = 0; i * 10 <= BinMeasures.Depth; i += 1) {
-        OccupationLayers[i] = new List<int>();
-      }
-    }
-    protected override void AddNewItemToOccupationLayers(int itemID, CuboidPackingItem measures, ThreeDimensionalPacking position) {
-      int z1 = position.Z / 10;
-      int z2 = (position.Z + (position.Rotated ? measures.Width : measures.Depth)) / 10;
-
-      for (int i = z1; i <= z2; i++)
-        OccupationLayers[i].Add(itemID);
-    }
-    protected override List<int> GetLayerItemIDs(ThreeDimensionalPacking position) {
-      return OccupationLayers[position.Z / 10];
-    }
-    protected override List<int> GetLayerItemIDs(CuboidPackingItem measures, ThreeDimensionalPacking position) {
-      List<int> result = new List<int>();
-      int z1 = position.Z / 10;
-      int z2 = (position.Z + (position.Rotated ? measures.Width : measures.Depth)) / 10;
-
-      for (int i = z1; i <= z2; i++)
-        result.AddRange(OccupationLayers[i]);
-
-      return result;
-    }
-  }
-  public class EPComparer3D : IComparer<ThreeDimensionalPacking> {
-    public int Compare(ThreeDimensionalPacking a, ThreeDimensionalPacking b) {
-      int result = a.Z.CompareTo(b.Z);
-      if (result == 0)
-        result = a.X.CompareTo(b.X);
-      if (result == 0)
-        result = a.Y.CompareTo(b.Y);
-
-      return result;
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/BinUtilizationRegularIdenticalBinEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/BinUtilizationRegularIdenticalBinEvaluator.cs	(revision 13607)
+++ 	(revision )
@@ -1,103 +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.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.Shapes;
-using HeuristicLab.Data;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
-
-namespace HeuristicLab.Problems.BinPacking.Evaluators {
-  [Item("Bin-Utilization Regular Identical-Bin Evaluator", "<Description missing> Found in Lee:2010")]
-  [StorableClass]
-  public abstract class BinUtilizationRegularIdenticalBinEvaluator<D, B, I> : RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D, B, I>
-    where D : class, IPackingDimensions
-    where B : PackingShape<D>, IPackingBin, IRegularPackingShape
-    where I : PackingShape<D>, IPackingItem, IRegularPackingShape {
-
-    [StorableConstructor]
-    protected BinUtilizationRegularIdenticalBinEvaluator(bool deserializing) : base(deserializing) { }
-    protected BinUtilizationRegularIdenticalBinEvaluator(BinUtilizationRegularIdenticalBinEvaluator<D, B, I> original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public BinUtilizationRegularIdenticalBinEvaluator() : base() { }
-
-    protected override DoubleValue Evaluate() {
-      DoubleValue quality = new DoubleValue(0);
-
-      IPackingPlan plan = PackingPlanParameter.ActualValue;
-      B binMeasure = PackingBinMeasuresParameter.ActualValue;
-      ItemList<I> itemMeasures = PackingItemMeasuresParameter.ActualValue;
-
-
-      //Check if data is valid
-      //if (plan.PackingItemPositions.Count != itemMeasures.Count)
-      //  throw new Exception("ERROR: ItemMeasures.count does not match packingPosition.count");
-
-
-      ////Check if any items are overlapping or not contained in their bins
-      //bool itemPositionsAreValid = !HasOverlappingOrNotContainedItems(plan.PackingItemPositions, binMeasure, itemMeasures, nrOfBins);
-
-
-
-      //if (itemPositionsAreValid)
-      return CalculateBinUtilization(plan as PackingPlan<D, B, I>);
-
-      //return quality;
-    }
-
-    public static DoubleValue CalculateBinUtilization(PackingPlan<D, B, I> plan) {
-      int nrOfBins = plan.NrOfBins;
-      double result = 0;
-
-      //for (int i = 0; i < nrOfBins; i++) {
-      //  double usableSpace = plan.GetPackingBinMeasuresForBinNr(i).MultipliedMeasures;
-      //  var indexes = plan.PackingItemPositions.Select((Value, Index) => new { Value, Index }).Where(s => s.Value.Value.AssignedBin == i).Select(s => s.Index);
-      //  var packedItemsInThisBin = plan.PackingItemMeasures.Select((Value, Index) => new { Value, Index }).Where(s => indexes.Contains(s.Index));
-      //  double usedSpaceInThisBin = packedItemsInThisBin.Select(s => s.Value.MultipliedMeasures).Sum();
-      //  result += (usedSpaceInThisBin / usableSpace);
-      //}
-
-      //result = result / nrOfBins;
-      //return new DoubleValue (result);
-
-      double totalUsedSpace = 0;
-      double totalUsableSpace = 0;
-
-      for (int i = 0; i < nrOfBins; i++) {
-        double usableSpace = plan.BinPackings[i].BinMeasures.Volume;
-        //var indexes = plan.PackingItemPositions.Select((Value, Index) => new { Value, Index }).Where(s => s.Value.Value.AssignedBin == i).Select(s => s.Index);
-        //var packedItemsInThisBin = plan.PackingItemMeasures.Select((Value, Index) => new { Value, Index }).Where(s => indexes.Contains(s.Index));
-        //double usedSpaceInThisBin = packedItemsInThisBin.Select(s => s.Value.MultipliedMeasures).Sum();
-        //result += (usedSpaceInThisBin / usableSpace);
-        totalUsableSpace += usableSpace;
-        //totalUsedSpace += usedSpaceInThisBin;
-        totalUsedSpace += plan.BinPackings[i].PackingDensity * usableSpace;
-      }
-
-      result = totalUsedSpace / totalUsableSpace;
-      return new DoubleValue(result);
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingPlanEvaluationAlgorithm.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingPlanEvaluationAlgorithm.cs	(revision 13607)
+++ 	(revision )
@@ -1,85 +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.Problems.BinPacking.Interfaces;
-using HeuristicLab.Operators;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Problems.BinPacking.Shapes;
-
-namespace HeuristicLab.Problems.BinPacking.Evaluators {
-  [Item("Packingplan Evaluation Algorithm", "Represents a composition of a decoder and an evaluator for bin-packing problems.")]
-  [StorableClass]
-  public class PackingPlanEvaluationAlgorithm<E, D, B, I> : SingleSuccessorOperator, IPackingPlanEvaluationAlgorithm
-    where E : Item //E defines the used Encoding
-    where D : class, IPackingDimensions
-    where B : PackingShape<D>, IPackingBin
-    where I : PackingShape<D>, IPackingItem {
-
-    public IValueLookupParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
-      get { return (IValueLookupParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
-    }
-    ILookupParameter<IPackingSolutionDecoder> IPackingPlanEvaluationAlgorithm.PackingSolutionDecoderParameter {
-      get { return PackingSolutionDecoderParameter; }
-    }
-    public IValueLookupParameter<IPackingPlanEvaluator> PackingPlanEvaluatorParameter {
-      get { return (IValueLookupParameter<IPackingPlanEvaluator>)Parameters["PackingPlanEvaluator"]; }
-    }
-    ILookupParameter<IPackingPlanEvaluator> IPackingPlanEvaluationAlgorithm.PackingPlanEvaluatorParameter {
-      get { return PackingPlanEvaluatorParameter; }
-    }
-    public ILookupParameter<DoubleValue> QualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
-    }
-
-    [StorableConstructor]
-    protected PackingPlanEvaluationAlgorithm(bool deserializing) : base(deserializing) { }
-    protected PackingPlanEvaluationAlgorithm(PackingPlanEvaluationAlgorithm<E, D, B, I> original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public PackingPlanEvaluationAlgorithm ()
-      : 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<IPackingPlanEvaluator>("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 PackingPlanEvaluationAlgorithm<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/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingPlanEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingPlanEvaluator.cs	(revision 13607)
+++ 	(revision )
@@ -1,77 +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.Problems.BinPacking.Interfaces;
-using HeuristicLab.Operators;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Parameters;
-using HeuristicLab.Data;
-using HeuristicLab.Problems.BinPacking.Shapes;
-
-namespace HeuristicLab.Problems.BinPacking.Evaluators {
-  [Item("Packingplan Evaluator", "Represents a evaluator class for standard bin-packing problems.")]
-  [StorableClass]
-  public abstract class PackingPlanEvaluator<D,B,I> : SingleSuccessorOperator, IPackingPlanEvaluator
-    where D : class, IPackingDimensions
-    where B : PackingShape<D>, IPackingBin
-    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"]; }
-    }
-    #endregion
-
-    [StorableConstructor]
-    protected PackingPlanEvaluator(bool deserializing) : base(deserializing) { }
-    protected PackingPlanEvaluator(PackingPlanEvaluator<D,B,I> original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public PackingPlanEvaluator()
-      : base() {
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value aka fitness 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."));
-    }
-
-
-    protected abstract DoubleValue Evaluate();                                                                        
-    public override IOperation Apply() {
-      QualityParameter.ActualValue = Evaluate();
-      return base.Apply();
-    }
-
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingRatioRegularIdenticalBinEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingRatioRegularIdenticalBinEvaluator.cs	(revision 13607)
+++ 	(revision )
@@ -1,103 +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.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.Shapes;
-using HeuristicLab.Data;
-using HeuristicLab.Common;
-using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
-
-namespace HeuristicLab.Problems.BinPacking.Evaluators {
-  [Item("Packing-Ratio Regular Identical-Bin Evaluator", "Represents an evaluation-algorithm for regular-shaped bin-packing problems with identical bins which calculates the ratio between packed and unpacked space. Found in Falkenauer:1996")]
-  [StorableClass]
-  public abstract class PackingRatioRegularIdenticalBinEvaluator<D, B, I> : RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D, B, I>
-    where D : class, IPackingDimensions
-    where B : PackingShape<D>, IPackingBin, IRegularPackingShape
-    where I : PackingShape<D>, IPackingItem, IRegularPackingShape {
-
-    [StorableConstructor]
-    protected PackingRatioRegularIdenticalBinEvaluator(bool deserializing) : base(deserializing) { }
-    protected PackingRatioRegularIdenticalBinEvaluator(PackingRatioRegularIdenticalBinEvaluator<D, B, I> original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public PackingRatioRegularIdenticalBinEvaluator() : base() { }
-
-    protected override DoubleValue Evaluate() {
-      DoubleValue quality = new DoubleValue(0);
-
-      IPackingPlan plan = PackingPlanParameter.ActualValue;
-      B binMeasure = PackingBinMeasuresParameter.ActualValue;
-      ItemList<I> itemMeasures = PackingItemMeasuresParameter.ActualValue;
-
-
-      //Check if data is valid
-      //if (plan.PackingItemPositions.Count != itemMeasures.Count)
-      //  throw new Exception("ERROR: ItemMeasures.count does not match packingPosition.count");
-
-
-      ////Check if any items are overlapping or not contained in their bins
-      //bool itemPositionsAreValid = !HasOverlappingOrNotContainedItems(plan.PackingItemPositions, binMeasure, itemMeasures, nrOfBins);
-
-
-
-      //if (itemPositionsAreValid)
-      return CalculatePackingRatio(plan as PackingPlan<D, B, I>);
-
-      //return quality;
-    }
-
-    /* 
-        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 DoubleValue CalculatePackingRatio(PackingPlan<D, B, I> plan) {
-      int nrOfBins = plan.NrOfBins;
-      double result = 0;
-
-      //C
-      //double usableSpace = binMeasure.MultipliedMeasures;
-      //nrOfBins = N
-      for (int i = 0; i < nrOfBins; i++) {
-        //C
-        //double usableSpace = plan.GetPackingBinMeasuresForBinNr(0).MultipliedMeasures;//plan.GetPackingBinMeasuresForBinNr(i).MultipliedMeasures;
-        //var indexes = plan.PackingItemPositions.Select((Value, Index) => new { Value, Index }).Where(s => s.Value.Value.AssignedBin == i).Select(s => s.Index);
-        //var packedItemsInThisBin = plan.PackingItemMeasures.Select((Value, Index) => new { Value, Index }).Where(s => indexes.Contains(s.Index));
-        //Fi
-        //double usedSpaceInThisBin = packedItemsInThisBin.Select(s => s.Value.MultipliedMeasures).Sum();
-        //k = 2 --> (Fi/C)*(Fi/C)
-        //result += (((usedSpaceInThisBin) / (usableSpace)) * ((usedSpaceInThisBin) / (usableSpace))) / (i*i + 1);
-        var PD = plan.BinPackings[i].PackingDensity;
-        result += (PD * PD) / (i + 1);
-      }
-
-      result = result / nrOfBins;
-      return new DoubleValue (result);
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs	(revision 13607)
+++ 	(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.Problems.BinPacking.Interfaces;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Parameters;
-using HeuristicLab.Problems.BinPacking.Shapes;
-using HeuristicLab.Collections;
-
-namespace HeuristicLab.Problems.BinPacking.Evaluators {
-  [Item("Regular Simple-Rotation Identical-Bin Packingplan Evaluator", "Represents a evaluator class for bin-packing problems using regular shapes and only simple rotations.")]
-  [StorableClass]
-  public abstract class RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D, B, I> : PackingPlanEvaluator<D, B, I>
-    where D : class, IPackingDimensions
-    where B : PackingShape<D>, IPackingBin, IRegularPackingShape
-    where I : PackingShape<D>, IPackingItem, IRegularPackingShape {
-
-    #region Parameter Properties
-    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 RegularSimpleRotationIdenticalBinPackingPlanEvaluator(bool deserializing) : base(deserializing) { }
-    protected RegularSimpleRotationIdenticalBinPackingPlanEvaluator(RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D,B,I> original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public RegularSimpleRotationIdenticalBinPackingPlanEvaluator()
-      : base() {
-      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 bool HasOverlappingOrNotContainedItems(ObservableDictionary<int, D> positions, B binMeasure, ItemList<I> itemMeasures, int nrOfBins) {
-      //TODO: Optimize performance by removing unnecessary allocations..
-      for (int i = 0; i < itemMeasures.Count; i++ ) {
-        I packingItem = itemMeasures [i];
-        D currentPosition = positions[i];
-        if (!binMeasure.Encloses(currentPosition, packingItem))
-          return true;
-
-        for (int j = 0; j < itemMeasures.Count; j++) {
-            D checkedPosition = positions[j];
-          if (i != j && currentPosition.AssignedBin == checkedPosition.AssignedBin) {
-            I checkedItem = itemMeasures[j];
-            if (packingItem.Overlaps(currentPosition, checkedPosition, checkedItem))
-              return true;
-          }
-        }
-
-      }
-
-      return false;
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/BinUtilizationRegularIdenticalBinEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/BinUtilizationRegularIdenticalBinEvaluator.cs	(revision 13608)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/BinUtilizationRegularIdenticalBinEvaluator.cs	(revision 13608)
@@ -0,0 +1,103 @@
+﻿#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.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.Shapes;
+using HeuristicLab.Data;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+
+namespace HeuristicLab.Problems.BinPacking.Evaluators {
+  [Item("Bin-Utilization Regular Identical-Bin Evaluator", "<Description missing> Found in Lee:2010")]
+  [StorableClass]
+  public abstract class BinUtilizationRegularIdenticalBinEvaluator<D, B, I> : RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D, B, I>
+    where D : class, IPackingDimensions
+    where B : PackingShape<D>, IPackingBin, IRegularPackingShape
+    where I : PackingShape<D>, IPackingItem, IRegularPackingShape {
+
+    [StorableConstructor]
+    protected BinUtilizationRegularIdenticalBinEvaluator(bool deserializing) : base(deserializing) { }
+    protected BinUtilizationRegularIdenticalBinEvaluator(BinUtilizationRegularIdenticalBinEvaluator<D, B, I> original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public BinUtilizationRegularIdenticalBinEvaluator() : base() { }
+
+    protected override DoubleValue Evaluate() {
+      DoubleValue quality = new DoubleValue(0);
+
+      IPackingPlan plan = PackingPlanParameter.ActualValue;
+      B binMeasure = PackingBinMeasuresParameter.ActualValue;
+      ItemList<I> itemMeasures = PackingItemMeasuresParameter.ActualValue;
+
+
+      //Check if data is valid
+      //if (plan.PackingItemPositions.Count != itemMeasures.Count)
+      //  throw new Exception("ERROR: ItemMeasures.count does not match packingPosition.count");
+
+
+      ////Check if any items are overlapping or not contained in their bins
+      //bool itemPositionsAreValid = !HasOverlappingOrNotContainedItems(plan.PackingItemPositions, binMeasure, itemMeasures, nrOfBins);
+
+
+
+      //if (itemPositionsAreValid)
+      return CalculateBinUtilization(plan as PackingPlan<D, B, I>);
+
+      //return quality;
+    }
+
+    public static DoubleValue CalculateBinUtilization(PackingPlan<D, B, I> plan) {
+      int nrOfBins = plan.NrOfBins;
+      double result = 0;
+
+      //for (int i = 0; i < nrOfBins; i++) {
+      //  double usableSpace = plan.GetPackingBinMeasuresForBinNr(i).MultipliedMeasures;
+      //  var indexes = plan.PackingItemPositions.Select((Value, Index) => new { Value, Index }).Where(s => s.Value.Value.AssignedBin == i).Select(s => s.Index);
+      //  var packedItemsInThisBin = plan.PackingItemMeasures.Select((Value, Index) => new { Value, Index }).Where(s => indexes.Contains(s.Index));
+      //  double usedSpaceInThisBin = packedItemsInThisBin.Select(s => s.Value.MultipliedMeasures).Sum();
+      //  result += (usedSpaceInThisBin / usableSpace);
+      //}
+
+      //result = result / nrOfBins;
+      //return new DoubleValue (result);
+
+      double totalUsedSpace = 0;
+      double totalUsableSpace = 0;
+
+      for (int i = 0; i < nrOfBins; i++) {
+        double usableSpace = plan.BinPackings[i].BinMeasures.Volume;
+        //var indexes = plan.PackingItemPositions.Select((Value, Index) => new { Value, Index }).Where(s => s.Value.Value.AssignedBin == i).Select(s => s.Index);
+        //var packedItemsInThisBin = plan.PackingItemMeasures.Select((Value, Index) => new { Value, Index }).Where(s => indexes.Contains(s.Index));
+        //double usedSpaceInThisBin = packedItemsInThisBin.Select(s => s.Value.MultipliedMeasures).Sum();
+        //result += (usedSpaceInThisBin / usableSpace);
+        totalUsableSpace += usableSpace;
+        //totalUsedSpace += usedSpaceInThisBin;
+        totalUsedSpace += plan.BinPackings[i].PackingDensity * usableSpace;
+      }
+
+      result = totalUsedSpace / totalUsableSpace;
+      return new DoubleValue(result);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingPlanEvaluationAlgorithm.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingPlanEvaluationAlgorithm.cs	(revision 13608)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingPlanEvaluationAlgorithm.cs	(revision 13608)
@@ -0,0 +1,85 @@
+﻿#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.Problems.BinPacking.Interfaces;
+using HeuristicLab.Operators;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.BinPacking.Shapes;
+
+namespace HeuristicLab.Problems.BinPacking.Evaluators {
+  [Item("Packingplan Evaluation Algorithm", "Represents a composition of a decoder and an evaluator for bin-packing problems.")]
+  [StorableClass]
+  public class PackingPlanEvaluationAlgorithm<E, D, B, I> : SingleSuccessorOperator, IPackingPlanEvaluationAlgorithm
+    where E : Item //E defines the used Encoding
+    where D : class, IPackingDimensions
+    where B : PackingShape<D>, IPackingBin
+    where I : PackingShape<D>, IPackingItem {
+
+    public IValueLookupParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
+      get { return (IValueLookupParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
+    }
+    ILookupParameter<IPackingSolutionDecoder> IPackingPlanEvaluationAlgorithm.PackingSolutionDecoderParameter {
+      get { return PackingSolutionDecoderParameter; }
+    }
+    public IValueLookupParameter<IPackingPlanEvaluator> PackingPlanEvaluatorParameter {
+      get { return (IValueLookupParameter<IPackingPlanEvaluator>)Parameters["PackingPlanEvaluator"]; }
+    }
+    ILookupParameter<IPackingPlanEvaluator> IPackingPlanEvaluationAlgorithm.PackingPlanEvaluatorParameter {
+      get { return PackingPlanEvaluatorParameter; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    [StorableConstructor]
+    protected PackingPlanEvaluationAlgorithm(bool deserializing) : base(deserializing) { }
+    protected PackingPlanEvaluationAlgorithm(PackingPlanEvaluationAlgorithm<E, D, B, I> original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public PackingPlanEvaluationAlgorithm ()
+      : 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<IPackingPlanEvaluator>("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 PackingPlanEvaluationAlgorithm<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/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingPlanEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingPlanEvaluator.cs	(revision 13608)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingPlanEvaluator.cs	(revision 13608)
@@ -0,0 +1,77 @@
+﻿#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.Interfaces;
+using HeuristicLab.Operators;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Parameters;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.BinPacking.Shapes;
+
+namespace HeuristicLab.Problems.BinPacking.Evaluators {
+  [Item("Packingplan Evaluator", "Represents a evaluator class for standard bin-packing problems.")]
+  [StorableClass]
+  public abstract class PackingPlanEvaluator<D,B,I> : SingleSuccessorOperator, IPackingPlanEvaluator
+    where D : class, IPackingDimensions
+    where B : PackingShape<D>, IPackingBin
+    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"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected PackingPlanEvaluator(bool deserializing) : base(deserializing) { }
+    protected PackingPlanEvaluator(PackingPlanEvaluator<D,B,I> original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public PackingPlanEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value aka fitness 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."));
+    }
+
+
+    protected abstract DoubleValue Evaluate();                                                                        
+    public override IOperation Apply() {
+      QualityParameter.ActualValue = Evaluate();
+      return base.Apply();
+    }
+
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingRatioRegularIdenticalBinEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingRatioRegularIdenticalBinEvaluator.cs	(revision 13608)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingRatioRegularIdenticalBinEvaluator.cs	(revision 13608)
@@ -0,0 +1,103 @@
+﻿#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.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.Shapes;
+using HeuristicLab.Data;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+
+namespace HeuristicLab.Problems.BinPacking.Evaluators {
+  [Item("Packing-Ratio Regular Identical-Bin Evaluator", "Represents an evaluation-algorithm for regular-shaped bin-packing problems with identical bins which calculates the ratio between packed and unpacked space. Found in Falkenauer:1996")]
+  [StorableClass]
+  public abstract class PackingRatioRegularIdenticalBinEvaluator<D, B, I> : RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D, B, I>
+    where D : class, IPackingDimensions
+    where B : PackingShape<D>, IPackingBin, IRegularPackingShape
+    where I : PackingShape<D>, IPackingItem, IRegularPackingShape {
+
+    [StorableConstructor]
+    protected PackingRatioRegularIdenticalBinEvaluator(bool deserializing) : base(deserializing) { }
+    protected PackingRatioRegularIdenticalBinEvaluator(PackingRatioRegularIdenticalBinEvaluator<D, B, I> original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public PackingRatioRegularIdenticalBinEvaluator() : base() { }
+
+    protected override DoubleValue Evaluate() {
+      DoubleValue quality = new DoubleValue(0);
+
+      IPackingPlan plan = PackingPlanParameter.ActualValue;
+      B binMeasure = PackingBinMeasuresParameter.ActualValue;
+      ItemList<I> itemMeasures = PackingItemMeasuresParameter.ActualValue;
+
+
+      //Check if data is valid
+      //if (plan.PackingItemPositions.Count != itemMeasures.Count)
+      //  throw new Exception("ERROR: ItemMeasures.count does not match packingPosition.count");
+
+
+      ////Check if any items are overlapping or not contained in their bins
+      //bool itemPositionsAreValid = !HasOverlappingOrNotContainedItems(plan.PackingItemPositions, binMeasure, itemMeasures, nrOfBins);
+
+
+
+      //if (itemPositionsAreValid)
+      return CalculatePackingRatio(plan as PackingPlan<D, B, I>);
+
+      //return quality;
+    }
+
+    /* 
+        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 DoubleValue CalculatePackingRatio(PackingPlan<D, B, I> plan) {
+      int nrOfBins = plan.NrOfBins;
+      double result = 0;
+
+      //C
+      //double usableSpace = binMeasure.MultipliedMeasures;
+      //nrOfBins = N
+      for (int i = 0; i < nrOfBins; i++) {
+        //C
+        //double usableSpace = plan.GetPackingBinMeasuresForBinNr(0).MultipliedMeasures;//plan.GetPackingBinMeasuresForBinNr(i).MultipliedMeasures;
+        //var indexes = plan.PackingItemPositions.Select((Value, Index) => new { Value, Index }).Where(s => s.Value.Value.AssignedBin == i).Select(s => s.Index);
+        //var packedItemsInThisBin = plan.PackingItemMeasures.Select((Value, Index) => new { Value, Index }).Where(s => indexes.Contains(s.Index));
+        //Fi
+        //double usedSpaceInThisBin = packedItemsInThisBin.Select(s => s.Value.MultipliedMeasures).Sum();
+        //k = 2 --> (Fi/C)*(Fi/C)
+        //result += (((usedSpaceInThisBin) / (usableSpace)) * ((usedSpaceInThisBin) / (usableSpace))) / (i*i + 1);
+        var PD = plan.BinPackings[i].PackingDensity;
+        result += (PD * PD) / (i + 1);
+      }
+
+      result = result / nrOfBins;
+      return new DoubleValue (result);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs	(revision 13608)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs	(revision 13608)
@@ -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.Problems.BinPacking.Interfaces;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.BinPacking.Shapes;
+using HeuristicLab.Collections;
+
+namespace HeuristicLab.Problems.BinPacking.Evaluators {
+  [Item("Regular Simple-Rotation Identical-Bin Packingplan Evaluator", "Represents a evaluator class for bin-packing problems using regular shapes and only simple rotations.")]
+  [StorableClass]
+  public abstract class RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D, B, I> : PackingPlanEvaluator<D, B, I>
+    where D : class, IPackingDimensions
+    where B : PackingShape<D>, IPackingBin, IRegularPackingShape
+    where I : PackingShape<D>, IPackingItem, IRegularPackingShape {
+
+    #region Parameter Properties
+    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 RegularSimpleRotationIdenticalBinPackingPlanEvaluator(bool deserializing) : base(deserializing) { }
+    protected RegularSimpleRotationIdenticalBinPackingPlanEvaluator(RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D,B,I> original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public RegularSimpleRotationIdenticalBinPackingPlanEvaluator()
+      : base() {
+      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 bool HasOverlappingOrNotContainedItems(ObservableDictionary<int, D> positions, B binMeasure, ItemList<I> itemMeasures, int nrOfBins) {
+      //TODO: Optimize performance by removing unnecessary allocations..
+      for (int i = 0; i < itemMeasures.Count; i++ ) {
+        I packingItem = itemMeasures [i];
+        D currentPosition = positions[i];
+        if (!binMeasure.Encloses(currentPosition, packingItem))
+          return true;
+
+        for (int j = 0; j < itemMeasures.Count; j++) {
+            D checkedPosition = positions[j];
+          if (i != j && currentPosition.AssignedBin == checkedPosition.AssignedBin) {
+            I checkedItem = itemMeasures[j];
+            if (packingItem.Overlaps(currentPosition, checkedPosition, checkedItem))
+              return true;
+          }
+        }
+
+      }
+
+      return false;
+    }
+  }
+}
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 13607)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj	(revision 13608)
@@ -160,12 +160,5 @@
     <Compile Include="Analyzers\BestBinPackingSolutionAnalyzer.cs" />
     <Compile Include="Analyzers\BinPackingAnalyzer.cs" />
-    <Compile Include="Decoders\3D\EP\ExtremePointMultiComponentVectorDecoder3D.cs" />
-    <Compile Include="Decoders\3D\EP\ExtremePointGroupingVectorDecoder3D.cs" />
-    <Compile Include="Decoders\3D\EP\ExtremePointPackingSequenceDecoder3D.cs" />
-    <Compile Include="Decoders\3D\DBL\DeepestBottomLeftMultiComponentVectorDecoder.cs" />
-    <Compile Include="Decoders\3D\DBL\DeepestBottomLeftGroupingVectorDecoder.cs" />
-    <Compile Include="Decoders\3D\DBL\DeepestBottomLeftPackingSequenceDecoder.cs" />
-    <Compile Include="Decoders\3D\EP\ISOContainerMultiComponentVectorDecoder3D.cs" />
-    <Compile Include="Decoders\PackingSolutionDecoder.cs" />
+    <Compile Include="BinPackingProblem.cs" />
     <Compile Include="Encodings\GroupingVector\GroupingVectorSwap2Manipulator.cs" />
     <Compile Include="Encodings\GroupingVector\GroupingVectorSinglePointCrossover.cs" />
@@ -258,10 +251,4 @@
     <Compile Include="Encodings\PackingSolutionCrossover.cs" />
     <Compile Include="Encodings\PackingSolutionManipulator.cs" />
-    <Compile Include="Evaluators\3D\PackingRatioCuboidIdenticalBinEvaluator.cs" />
-    <Compile Include="Evaluators\Abstract\BinUtilizationRegularIdenticalBinEvaluator.cs" />
-    <Compile Include="Evaluators\Abstract\PackingRatioRegularIdenticalBinEvaluator.cs" />
-    <Compile Include="Evaluators\Abstract\RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs" />
-    <Compile Include="Evaluators\Abstract\PackingPlanEvaluationAlgorithm.cs" />
-    <Compile Include="Evaluators\Abstract\PackingPlanEvaluator.cs" />
     <Compile Include="Instances\BPPData.cs" />
     <Compile Include="Instances\BPPInstanceProvider.cs" />
@@ -269,9 +256,5 @@
     <Compile Include="Instances\BPPORLIBDataDescriptor.cs" />
     <Compile Include="Instances\RealBPPData.cs" />
-    <Compile Include="Interfaces\DecoderInterfaces\I3DMCVDecoder.cs" />
-    <Compile Include="Interfaces\DecoderInterfaces\I3DGVDecoder.cs" />
-    <Compile Include="Interfaces\DecoderInterfaces\I3DPSDecoder.cs" />
     <Compile Include="Interfaces\IPackingSequenceMoveOperator.cs" />
-    <Compile Include="Interfaces\I3DOperator.cs" />
     <Compile Include="Interfaces\IPackingMove.cs" />
     <Compile Include="Interfaces\IMultiComponentVectorMoveOperator.cs" />
@@ -291,29 +274,16 @@
     <Compile Include="Interfaces\IPackingShape.cs" />
     <Compile Include="Interfaces\IPackingDimensions.cs" />
-    <Compile Include="MoveEvaluators\PackingMoveEvaluator3DPS.cs" />
-    <Compile Include="MoveEvaluators\PackingMoveEvaluator.cs" />
-    <Compile Include="MoveEvaluators\PackingMoveEvaluator3DGV.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="MoveEvaluators\PackingMoveEvaluator3DMCV.cs">
-      <SubType>Code</SubType>
-    </Compile>
+    <Compile Include="PackingDimensions.cs" />
+    <Compile Include="PackingMoveEvaluator.cs" />
     <Compile Include="PackingPlan3D.cs" />
-    <Compile Include="Problem\BinPackingProblem.cs" />
-    <Compile Include="Problem\ISOContainerBinPackingProblem.cs" />
-    <Compile Include="Problem\CuboidIdenticalBinPackingProblem.cs" />
-    <Compile Include="Problem\RegularIdenticalBinPackingProblem.cs" />
-    <Compile Include="Dimensions\PackingDimensions.cs" />
-    <Compile Include="Dimensions\ThreeDimensionalPacking.cs" />
-    <Compile Include="Shapes\PackingShape.cs" />
-    <Compile Include="Shapes\CuboidPackingShape.cs" />
     <Compile Include="Interfaces\IRegularPackingShape.cs" />
-    <Compile Include="PackingBin\CuboidPackingBin.cs" />
-    <Compile Include="PackingItem\CuboidPackingItem.cs" />
     <Compile Include="Interfaces\IPackingBin.cs" />
     <Compile Include="Interfaces\IPackingItem.cs" />
     <Compile Include="Interfaces\IPackingPlan.cs" />
+    <Compile Include="PackingShape.cs" />
+    <Compile Include="PackingSolutionDecoder.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RegularIdenticalBinPackingProblem.cs" />
   </ItemGroup>
   <ItemGroup>
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/I3DOperator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/I3DOperator.cs	(revision 13607)
+++ 	(revision )
@@ -1,25 +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
-
-namespace HeuristicLab.Problems.BinPacking.Interfaces {
-  public interface I3DOperator {
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator.cs	(revision 13607)
+++ 	(revision )
@@ -1,108 +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.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.BinPacking.Decoders;
-using HeuristicLab.Problems.BinPacking.Evaluators;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.Shapes;
-
-namespace HeuristicLab.Problems.BinPacking {
-  [Item("PackingMoveEvaluator", "A base class for operators which evaluate Packing-Solution moves.")]
-  [StorableClass]
-  public abstract class PackingMoveEvaluator<D, B, I> : SingleSuccessorOperator, IPackingMoveEvaluator, IMoveOperator
-    where D : class, IPackingDimensions
-    where B : PackingShape<D>, IPackingBin, IRegularPackingShape
-    where I : PackingShape<D>, IPackingItem, IRegularPackingShape {     
-    public override bool CanChangeName {
-      get { return false; }
-    }
-
-    public ILookupParameter<DoubleValue> QualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
-    }
-    public ILookupParameter<DoubleValue> MoveQualityParameter {
-      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
-    }
-    public ILookupParameter<ItemList<I>> PackingItemMeasuresParameter {
-      get { return (LookupParameter<ItemList<I>>)Parameters["PackingItemMeasures"]; }
-    }
-    public ILookupParameter<B> PackingBinMeasuresParameter {
-      get { return (LookupParameter<B>)Parameters["PackingBinMeasures"]; }
-    }
-    public IValueLookupParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
-      get { return (IValueLookupParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
-    }
-    public IValueLookupParameter<IPackingPlanEvaluator> PackingPlanEvaluatorParameter {
-      get { return (IValueLookupParameter<IPackingPlanEvaluator>)Parameters["PackingPlanEvaluator"]; }
-    }
-    protected ScopeParameter CurrentScopeParameter {
-      get { return (ScopeParameter)Parameters["CurrentScope"]; }
-    }
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
-    }  
-    
-    [StorableConstructor]
-    protected PackingMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator(PackingMoveEvaluator<D, B, I> original, Cloner cloner) : base(original, cloner) { }
-    protected PackingMoveEvaluator()
-      : base() {
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of a packing solution."));
-      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The evaluated quality of a move on a packing solution."));
-      Parameters.Add(new LookupParameter<ItemList<I>>("PackingItemMeasures", "Packing-item data taken from the bin-packing problem-instance."));
-      Parameters.Add(new LookupParameter<B>("PackingBinMeasures", "Packing-bin data taken from the bin-packing problem-instance."));
-      Parameters.Add(new ValueLookupParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The decoding operator that is used to calculate a packing plan from the used representation."));
-      Parameters.Add(new ValueLookupParameter<IPackingPlanEvaluator>("PackingPlanEvaluator", "The actual packing plan evaluation operator."));
-      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the decoded solution should be added to."));
-      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
-    }
-
-
-
-    public override IOperation Apply() {
-      IPackingMove move = PackingMoveParameter.ActualValue;
-      IPackingSolutionEncoding newSolution = move.GetSolutionAfterMove();
-      CurrentScopeParameter.ActualValue.Variables.Add(new Variable("MovedSolution", newSolution));
-
-      PackingPlan<D, B, I> packingPlan = (PackingSolutionDecoderParameter.ActualValue as PackingSolutionDecoder<D, B, I>).
-        CreatePackingPlanFromEncoding(newSolution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
-
-
-      CurrentScopeParameter.ActualValue.Variables.Add(new Variable("PackingPlanAfterMove", packingPlan));
-
-      DoubleValue quality = PackingRatioRegularIdenticalBinEvaluator<D, B, I>.CalculatePackingRatio(packingPlan);
-
-      double moveQuality = quality.Value;
-
-      if (MoveQualityParameter.ActualValue == null) MoveQualityParameter.ActualValue = new DoubleValue(moveQuality);
-      else MoveQualityParameter.ActualValue.Value = moveQuality;
-      return base.Apply();
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator3DGV.cs	(revision 13607)
+++ 	(revision )
@@ -1,48 +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.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-
-namespace HeuristicLab.Problems.BinPacking {
-  [Item("GroupingVectorMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
-  [StorableClass]
-  public class PackingMoveEvaluator3DGV : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IGroupingVectorMoveOperator, I3DOperator {
-    [StorableConstructor]
-    protected PackingMoveEvaluator3DGV(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator3DGV(PackingMoveEvaluator3DGV original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingMoveEvaluator3DGV(this, cloner);
-    }
-    public PackingMoveEvaluator3DGV()
-      : base() {
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator3DMCV.cs	(revision 13607)
+++ 	(revision )
@@ -1,48 +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.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-
-namespace HeuristicLab.Problems.BinPacking {
-  [Item("MultiComponentVectorMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
-  [StorableClass]
-  public class PackingMoveEvaluator3DMCV : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator, I3DOperator {
-    [StorableConstructor]
-    protected PackingMoveEvaluator3DMCV(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator3DMCV(PackingMoveEvaluator3DMCV original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingMoveEvaluator3DMCV(this, cloner);
-    }
-    public PackingMoveEvaluator3DMCV()
-      : base() {
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator3DPS.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator3DPS.cs	(revision 13607)
+++ 	(revision )
@@ -1,48 +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.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-
-namespace HeuristicLab.Problems.BinPacking {
-  [Item("PackingSequenceMoveEvaluator3D", "Class for evaluating packing moves for 3dimensional problems.")]
-  [StorableClass]
-  public class PackingMoveEvaluator3DPS : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IPackingSequenceMoveOperator, I3DOperator {
-    [StorableConstructor]
-    protected PackingMoveEvaluator3DPS(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator3DPS(PackingMoveEvaluator3DPS original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new PackingMoveEvaluator3DPS(this, cloner);
-    }
-    public PackingMoveEvaluator3DPS()
-      : base() {
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingBin/CuboidPackingBin.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingBin/CuboidPackingBin.cs	(revision 13607)
+++ 	(revision )
@@ -1,47 +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.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.Shapes;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-
-
-namespace HeuristicLab.Problems.BinPacking.PackingBin {
-  [Item("CuboidPackingBin", "Represents a cuboidic container for a three dimensional bin-packing problem.")]
-  [StorableClass]
-  public class CuboidPackingBin : CuboidPackingShape, IPackingBin {
-    public CuboidPackingBin(int width, int height, int depth) : base(width, height, depth) { }
-
-    [StorableConstructor]
-    protected CuboidPackingBin(bool deserializing) : base(deserializing) { }
-    protected CuboidPackingBin(CuboidPackingBin original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new CuboidPackingBin(this, cloner);
-    }
-    public CuboidPackingBin()
-      : base() {
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingDimensions.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingDimensions.cs	(revision 13608)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingDimensions.cs	(revision 13608)
@@ -0,0 +1,79 @@
+﻿#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.Problems.BinPacking.Interfaces;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Core;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.BinPacking.Dimensions {
+  [Item("Packing Dimensions", "Represents an abstract packing-position associated with a packing-problem.")]
+  [StorableClass]
+  // PackingDimensions is immutable (and handled as value types concerning Equals and GetHashCode)
+  public abstract class PackingDimensions : Item, IPackingDimensions {
+    /// <summary>
+    /// The number of the bin to which the current item is assigned is stored in this variable. Counting starts at 0 !!!
+    /// </summary>    
+    [Storable]
+    private readonly int assignedBin;
+    public int AssignedBin {
+      get { return assignedBin; }
+    }
+
+    [Storable]
+    private readonly bool rotated;
+    /// <summary>
+    /// Determines if the positioned item is to be rotate by 90 degrees or not. (TODO: which axis?)
+    /// </summary>
+    public bool Rotated {
+      get { return rotated; }
+    }
+
+    [StorableConstructor]
+    protected PackingDimensions(bool deserializing) : base(deserializing) { }
+    protected PackingDimensions(PackingDimensions original, Cloner cloner)
+      : base(original, cloner) {
+      assignedBin = original.AssignedBin;
+      rotated = original.Rotated;
+    }
+
+    protected PackingDimensions(int assignedBin, bool rotated) {
+      this.assignedBin = assignedBin;
+      this.rotated = rotated;
+    }
+
+    public override string ToString() {
+      return string.Format("[{0}-{1}]", AssignedBin, Rotated);
+    }
+
+    public override bool Equals(object obj) {
+      var other = obj as PackingDimensions;
+      if (other != null)
+        return (other.AssignedBin == this.AssignedBin && other.Rotated == this.Rotated);
+      else return false;
+    }
+
+    public override int GetHashCode() {
+      return 31 * AssignedBin * (Rotated ? 3 : 7);
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingItem/CuboidPackingItem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingItem/CuboidPackingItem.cs	(revision 13607)
+++ 	(revision )
@@ -1,120 +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.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.Shapes;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-
-namespace HeuristicLab.Problems.BinPacking.PackingItem {
-  [Item("CuboidPackingItem", "Represents a cuboidic packing-item for bin-packing problems.")]
-  [StorableClass]
-  public class CuboidPackingItem : CuboidPackingShape, IPackingItem {
-    public IValueParameter<CuboidPackingBin> TargetBinParameter {
-      get { return (IValueParameter<CuboidPackingBin>)Parameters["TargetBin"]; }
-    }
-    public IFixedValueParameter<DoubleValue> WeightParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters["Weight"]; }
-    }
-    public IFixedValueParameter<IntValue> MaterialParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["Material"]; }
-    }
-
-    public CuboidPackingBin TargetBin {
-      get { return TargetBinParameter.Value; }
-      set { TargetBinParameter.Value = value; }
-    }
-
-    public double Weight {
-      get { return WeightParameter.Value.Value; }
-      set { WeightParameter.Value.Value = value; }
-    }
-
-    public int Material {
-      get { return MaterialParameter.Value.Value; }
-      set { MaterialParameter.Value.Value = value; }
-    }
-
-    public bool SupportsStacking(IPackingItem other) {
-      return ((other.Material < this.Material) || (other.Material.Equals(this.Material) && other.Weight <= this.Weight));
-    }
-
-    [StorableConstructor]
-    protected CuboidPackingItem(bool deserializing) : base(deserializing) { }
-    protected CuboidPackingItem(CuboidPackingItem original, Cloner cloner)
-      : base(original, cloner) {
-      RegisterEvents();
-    }
-    public CuboidPackingItem()
-      : base() {
-      Parameters.Add(new ValueParameter<CuboidPackingBin>("TargetBin"));
-      Parameters.Add(new FixedValueParameter<DoubleValue>("Weight"));
-      Parameters.Add(new FixedValueParameter<IntValue>("Material"));
-
-      RegisterEvents();
-    }
-
-    public CuboidPackingItem(int width, int height, int depth, CuboidPackingBin targetBin, double weight, int material)
-      : this() {
-      this.Width = width;
-      this.Height = height;
-      this.Depth = depth;
-      this.Weight = weight;
-      this.Material = material;
-      this.TargetBin = (CuboidPackingBin)targetBin.Clone();
-    }
-
-    public CuboidPackingItem(int width, int height, int depth, CuboidPackingBin targetBin)
-      : this() {
-      this.Width = width;
-      this.Height = height;
-      this.Depth = depth;
-      this.TargetBin = (CuboidPackingBin)targetBin.Clone();
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      RegisterEvents();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new CuboidPackingItem(this, cloner);
-    }
-
-    private void RegisterEvents() {
-      // only because of ToString override
-      WeightParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
-      MaterialParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
-
-      // target bin does not occur in ToString()
-    }
-
-
-    public override string ToString() {
-      return string.Format("CuboidPackingItem ({0}, {1}, {2}; weight={3}, mat={4})", this.Width, this.Height, this.Depth, this.Weight, this.Material);
-    }
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingMoveEvaluator.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingMoveEvaluator.cs	(revision 13608)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingMoveEvaluator.cs	(revision 13608)
@@ -0,0 +1,108 @@
+#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.PackingEncoding.PackingPlan;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking.Decoders;
+using HeuristicLab.Problems.BinPacking.Evaluators;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.Shapes;
+
+namespace HeuristicLab.Problems.BinPacking {
+  [Item("PackingMoveEvaluator", "A base class for operators which evaluate Packing-Solution moves.")]
+  [StorableClass]
+  public abstract class PackingMoveEvaluator<D, B, I> : SingleSuccessorOperator, IPackingMoveEvaluator, IMoveOperator
+    where D : class, IPackingDimensions
+    where B : PackingShape<D>, IPackingBin, IRegularPackingShape
+    where I : PackingShape<D>, IPackingItem, IRegularPackingShape {     
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+    public ILookupParameter<ItemList<I>> PackingItemMeasuresParameter {
+      get { return (LookupParameter<ItemList<I>>)Parameters["PackingItemMeasures"]; }
+    }
+    public ILookupParameter<B> PackingBinMeasuresParameter {
+      get { return (LookupParameter<B>)Parameters["PackingBinMeasures"]; }
+    }
+    public IValueLookupParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
+      get { return (IValueLookupParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
+    }
+    public IValueLookupParameter<IPackingPlanEvaluator> PackingPlanEvaluatorParameter {
+      get { return (IValueLookupParameter<IPackingPlanEvaluator>)Parameters["PackingPlanEvaluator"]; }
+    }
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+    public ILookupParameter<IPackingMove> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    }  
+    
+    [StorableConstructor]
+    protected PackingMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected PackingMoveEvaluator(PackingMoveEvaluator<D, B, I> original, Cloner cloner) : base(original, cloner) { }
+    protected PackingMoveEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of a packing solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The evaluated quality of a move on a packing solution."));
+      Parameters.Add(new LookupParameter<ItemList<I>>("PackingItemMeasures", "Packing-item data taken from the bin-packing problem-instance."));
+      Parameters.Add(new LookupParameter<B>("PackingBinMeasures", "Packing-bin data taken from the bin-packing problem-instance."));
+      Parameters.Add(new ValueLookupParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The decoding operator that is used to calculate a packing plan from the used representation."));
+      Parameters.Add(new ValueLookupParameter<IPackingPlanEvaluator>("PackingPlanEvaluator", "The actual packing plan evaluation operator."));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the decoded solution should be added to."));
+      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+    }
+
+
+
+    public override IOperation Apply() {
+      IPackingMove move = PackingMoveParameter.ActualValue;
+      IPackingSolutionEncoding newSolution = move.GetSolutionAfterMove();
+      CurrentScopeParameter.ActualValue.Variables.Add(new Variable("MovedSolution", newSolution));
+
+      PackingPlan<D, B, I> packingPlan = (PackingSolutionDecoderParameter.ActualValue as PackingSolutionDecoder<D, B, I>).
+        CreatePackingPlanFromEncoding(newSolution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+
+
+      CurrentScopeParameter.ActualValue.Variables.Add(new Variable("PackingPlanAfterMove", packingPlan));
+
+      DoubleValue quality = PackingRatioRegularIdenticalBinEvaluator<D, B, I>.CalculatePackingRatio(packingPlan);
+
+      double moveQuality = quality.Value;
+
+      if (MoveQualityParameter.ActualValue == null) MoveQualityParameter.ActualValue = new DoubleValue(moveQuality);
+      else MoveQualityParameter.ActualValue.Value = moveQuality;
+      return base.Apply();
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingShape.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingShape.cs	(revision 13608)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingShape.cs	(revision 13608)
@@ -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 System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.BinPacking.Shapes {
+  [Item("PackingShape", "Represents an abstract shape to describe the measures and the positioning of objects related to bin-packing problems.")]
+  [StorableClass]
+  public abstract class PackingShape<T> : Item, IPackingShape, IParameterizedItem
+    where T : class, IPackingDimensions {
+    public static Type PositionType {
+      get { return typeof(T); }
+    }
+
+    public abstract bool EnclosesPoint(T myPosition, T checkedPoint);
+    public abstract bool Encloses(T checkedPosition, PackingShape<T> checkedShape);
+    public abstract bool Overlaps(T myPosition, T checkedPosition, PackingShape<T> checkedShape);
+    public abstract int Volume { get; }
+    public abstract T Origin { get; }
+
+    protected PackingShape()
+      : base() {
+      Parameters = new ParameterCollection();
+    }
+
+
+    [StorableConstructor]
+    protected PackingShape(bool deserializing) { }
+    protected PackingShape(PackingShape<T> original, Cloner cloner) {
+      this.Parameters = new ParameterCollection(original.Parameters.Select(p => cloner.Clone(p)));
+    }
+
+    public virtual void CollectParameterValues(IDictionary<string, IItem> values) {
+      foreach (IValueParameter param in Parameters.OfType<IValueParameter>()) {
+        var children = GetCollectedValues(param);
+        foreach (var c in children) {
+          if (String.IsNullOrEmpty(c.Key))
+            values.Add(param.Name, c.Value);
+          else values.Add(param.Name + "." + c.Key, c.Value);
+        }
+      }
+    }
+
+    protected virtual IEnumerable<KeyValuePair<string, IItem>> GetCollectedValues(IValueParameter param) {
+      if (param.Value == null) yield break;
+      if (param.GetsCollected) yield return new KeyValuePair<string, IItem>(String.Empty, param.Value);
+      var parameterizedItem = param.Value as IParameterizedItem;
+      if (parameterizedItem != null) {
+        var children = new Dictionary<string, IItem>();
+        parameterizedItem.CollectParameterValues(children);
+        foreach (var child in children) yield return child;
+      }
+    }
+
+    public IKeyedItemCollection<string, IParameter> Parameters { get; private set; }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingSolutionDecoder.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingSolutionDecoder.cs	(revision 13608)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingSolutionDecoder.cs	(revision 13608)
@@ -0,0 +1,85 @@
+﻿#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.Problems.BinPacking.Interfaces;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.BinPacking.Shapes;
+using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.BinPacking.Decoders {
+
+  [Item("Packing-Solution Decoder", "An operator to create a concrete bin packing solution from a given encoding-instance.")]
+  [StorableClass]
+  public abstract class PackingSolutionDecoder<D, B, I> : SingleSuccessorOperator, IPackingSolutionDecoder
+    where D : class, IPackingDimensions
+    where B : PackingShape<D>, IPackingBin
+    where I : PackingShape<D>, IPackingItem {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    private ILookupParameter<ItemList<I>> PackingItemMeasuresParameter {
+      get { return (LookupParameter<ItemList<I>>)Parameters["PackingItemMeasures"]; }
+    }
+    private ILookupParameter<B> PackingBinMeasuresParameter {
+      get { return (LookupParameter<B>)Parameters["PackingBinMeasures"]; }
+    }
+    public ILookupParameter<IItem> EncodedSolutionParameter {
+      get { return (ILookupParameter<IItem>)Parameters["EncodedSolution"]; }
+    }
+    public ILookupParameter<PackingPlan<D,B,I>> PackingPlanParameter {
+      get { return (ILookupParameter<PackingPlan<D, B, I>>)Parameters["PackingPlan"]; }
+    }
+    public ValueParameter<BoolValue> StackingConstraintsParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["StackingConstraint"]; }
+    }
+
+
+    public PackingSolutionDecoder() : base() {
+      Parameters.Add(new LookupParameter<IItem>("EncodedSolution", "The new bin-packing solution represented as encoding."));
+      Parameters.Add(new LookupParameter<PackingPlan<D, B, I>>("PackingPlan", "The decoded bin-packing solution represented as generalized packing plan."));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new LookupParameter<ItemList<I>>("PackingItemMeasures", "Packing-item data taken from the bin-packing problem-instance."));
+      Parameters.Add(new LookupParameter<B>("PackingBinMeasures", "Packing-bin data taken from the bin-packing problem-instance."));
+      Parameters.Add(new ValueParameter<BoolValue>("StackingConstraint", "A flag determining whether stackingconstraints should be enforced or not.", new BoolValue(true)));
+    }
+
+    [StorableConstructor]
+    protected PackingSolutionDecoder(bool deserializing) : base(deserializing) { }
+    protected PackingSolutionDecoder(PackingSolutionDecoder<D,B,I> original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public abstract PackingPlan<D, B, I> CreatePackingPlanFromEncoding(IItem solution, B binMeasures, ItemList<I> itemMeasures);
+
+    public override IOperation Apply() {
+      PackingPlan<D, B, I> result = CreatePackingPlanFromEncoding(EncodedSolutionParameter.ActualValue, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);
+      PackingPlanParameter.ActualValue = result;
+      return base.Apply();
+    }
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/BinPackingProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/BinPackingProblem.cs	(revision 13607)
+++ 	(revision )
@@ -1,93 +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.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.Shapes;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Parameters;
-using HeuristicLab.Encodings.PackingEncoding.PackingPlan;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Problems.BinPacking.Problem {
-  [Item("BinPackingProblem", "Abstract class that represents a BinPacking Problem")]
-  [StorableClass]
-  public abstract class BinPackingProblem<D, B, I> : SingleObjectiveHeuristicOptimizationProblem<IPackingPlanEvaluationAlgorithm, IPackingSolutionCreator> 
-    where D : class, IPackingDimensions 
-    where B : PackingShape<D>, IPackingBin, 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<IPackingPlanEvaluator> PackingPlanEvaluatorParameter {
-      get { return (ValueParameter<IPackingPlanEvaluator>)Parameters["PackingPlanEvaluator"]; }
-    }
-    #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 IPackingPlanEvaluator PackingPlanEvaluator {
-      get { return PackingPlanEvaluatorParameter.Value; }
-      set { PackingPlanEvaluatorParameter.Value = value; }
-    }
-    #endregion
-
-
-    [StorableConstructor]
-    protected BinPackingProblem(bool deserializing) : base(deserializing) { }
-    protected BinPackingProblem(BinPackingProblem<D,B,I> original, Cloner cloner)
-      : base(original, cloner) {
-    }                 
-    protected BinPackingProblem(IPackingPlanEvaluationAlgorithm 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()));
-    }
-
-    protected abstract void InitializeDecoder(); 
-    protected abstract void InitializeProblemInstance();
-    protected abstract void InitializeOperators();
-    protected abstract void InitializeEventHandlers();
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/CuboidIdenticalBinPackingProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/CuboidIdenticalBinPackingProblem.cs	(revision 13607)
+++ 	(revision )
@@ -1,141 +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.Problems.BinPacking.Dimensions;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.PackingBin;
-using HeuristicLab.Problems.BinPacking.PackingItem;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-using HeuristicLab.Problems.BinPacking.Evaluators;
-using HeuristicLab.Encodings.PermutationEncoding;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
-using HeuristicLab.Problems.Instances;
-using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
-using HeuristicLab.PluginInfrastructure;
-
-namespace HeuristicLab.Problems.BinPacking.Problem {
-  [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 CuboidIdenticalBinPackingProblem : RegularIdenticalBinPackingProblem<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> {
-
-    #region Default Instance
-    private static readonly BPPData DefaultInstance = new BPPData() {  
-      Name = "3D BPP Default Instance", 
-      Description = "The default instance for 3D Bin Packing.",
-      BinMeasures = new int[] {25,25,35},
-      ItemMeasures = new int[][] {
-        new int[] {12,5,10},
-        new int[] {10,18,20},
-        new int[] {9,7,7},
-        new int[] {21,12,4},
-        new int[] {8,8,12},
-        new int[] {3,6,14},
-        new int[] {20,4,9},
-        new int[] {5,9,8},
-        new int[] {7,17,3},
-        new int[] {13,20,15},
-        new int[] {9,11,9},
-        new int[] {10,18,20},
-        new int[] {9,7,7},
-        new int[] {21,12,4},
-        new int[] {8,8,12},
-        new int[] {3,6,14},
-        new int[] {20,4,9},
-        new int[] {5,9,8},
-        new int[] {7,17,3},
-        new int[] {13,20,15},
-        new int[] {9,11,9},
-        new int[] {10,18,20},
-        new int[] {9,7,7},
-        new int[] {21,12,4},
-        new int[] {8,8,12},
-        new int[] {3,6,14},
-        new int[] {20,4,9},
-        new int[] {5,9,8},
-        new int[] {7,17,3},
-        new int[] {13,20,15},
-        new int[] {9,11,9},
-        new int[] {10,18,20},
-        new int[] {9,7,7},
-        new int[] {21,12,4},
-        new int[] {8,8,12},
-        new int[] {3,6,14},
-        new int[] {20,4,9},
-        new int[] {5,9,8},
-        new int[] {7,17,3},
-        new int[] {13,20,15},
-        new int[] {9,11,9}
-      },
-      Items = 30
-    };
-    #endregion
-    
-    [StorableConstructor]
-    protected CuboidIdenticalBinPackingProblem(bool deserializing) : base(deserializing) { }
-    protected CuboidIdenticalBinPackingProblem(CuboidIdenticalBinPackingProblem original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new CuboidIdenticalBinPackingProblem(this, cloner);
-    }
-    public CuboidIdenticalBinPackingProblem() : base(
-      new PackingPlanEvaluationAlgorithm<Permutation, ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>()) {
-    }
-
-
-
-    #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 IPackingPlanEvaluator CreateDefaultEvaluator() {
-      return new PackingRatioCuboidIdenticalBinEvaluator();
-    }
-
-    protected override void InitializeProblemData() {
-      Load(DefaultInstance);
-    }
-
-    protected override void RemoveTooBigItems() {
-      PackingItemMeasures.RemoveAll(pi => 
-        !PackingBinMeasures.Encloses (new ThreeDimensionalPacking(0, 0, 0, 0, false), pi) &&
-        !PackingBinMeasures.Encloses(new ThreeDimensionalPacking(0, 0, 0, 0, true), pi));
-    }
-    #endregion
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/ISOContainerBinPackingProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/ISOContainerBinPackingProblem.cs	(revision 13607)
+++ 	(revision )
@@ -1,188 +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.Problems.BinPacking.Interfaces;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Core;
-using HeuristicLab.Common;
-using HeuristicLab.Problems.BinPacking.Decoders;
-using HeuristicLab.Problems.Instances;
-using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
-
-namespace HeuristicLab.Problems.BinPacking.Problem {
-  [Item("Bin Packing Problem (3D, ISO containers) (BPP)", "Represents a three-dimensional bin-packing problem using two different bin sizes.")]
-  [StorableClass]
-  [Creatable(CreatableAttribute.Categories.CombinatorialProblems, Priority = 320)]
-  public class ISOContainerBinPackingProblem : CuboidIdenticalBinPackingProblem {
-
-
-    #region Default Instance
-    private static readonly RealBPPData DefaultInstance = new RealBPPData() {  
-      Name = "3D BPP with weigthed items Default Instance", 
-      Description = "The default instance for 3D Bin Packing Problem with weighted items.",
-      BinMeasures = new int[] {25,25,35},
-      ItemMeasures = new int[][] {
-        new int[] {12,5,10},
-        new int[] {10,18,20},
-        new int[] {9,7,7},
-        new int[] {21,12,4},
-        new int[] {8,8,12},
-        new int[] {3,6,14},
-        new int[] {20,4,9},
-        new int[] {5,9,8},
-        new int[] {7,17,3},
-        new int[] {13,20,15},
-        new int[] {9,11,9},
-        new int[] {10,18,20},
-        new int[] {9,7,7},
-        new int[] {21,12,4},
-        new int[] {8,8,12},
-        new int[] {3,6,14},
-        new int[] {20,4,9},
-        new int[] {5,9,8},
-        new int[] {7,17,3},
-        new int[] {13,20,15},
-        new int[] {9,11,9},
-        new int[] {10,18,20},
-        new int[] {9,7,7},
-        new int[] {21,12,4},
-        new int[] {8,8,12},
-        new int[] {3,6,14},
-        new int[] {20,4,9},
-        new int[] {5,9,8},
-        new int[] {7,17,3},
-        new int[] {13,20,15},
-        new int[] {9,11,9},
-        new int[] {10,18,20},
-        new int[] {9,7,7},
-        new int[] {21,12,4},
-        new int[] {8,8,12},
-        new int[] {3,6,14},
-        new int[] {20,4,9},
-        new int[] {5,9,8},
-        new int[] {7,17,3},
-        new int[] {13,20,15},
-        new int[] {9,11,9}
-      },
-      Items = 30,
-      ItemWeights = new double[] {
-        12*5*10,
-        10*18*20,
-        9*7*7,
-        21*12*4,
-        8*8*12,
-        3*6*14,
-        20*4*9,
-        5*9*8,
-        7*17*3,
-        13*20*15,
-        9*11*9,
-        10*18*20,
-        9*7*7,
-        21*12*4,
-        8*8*12,
-        3*6*14,
-        20*4*9,
-        5*9*8,
-        7*17*3,
-        13*20*15,
-        9*11*9,
-        10*18*20,
-        9*7*7,
-        21*12*4,
-        8*8*12,
-        3*6*14,
-        20*4*9,
-        5*9*8,
-        7*17*3,
-        13*20*15,
-        9*11*9
-      },
-      ItemMaterials = new int[] {
-        1,
-        0,
-        0,
-        1,
-        0,
-        0,
-        1,
-        1,
-        0,
-        1,
-        1,
-        0,
-        0,
-        1,
-        0,
-        0,
-        1,
-        1,
-        0,
-        1,
-        1,
-        0,
-        0,
-        1,
-        0,
-        0,
-        1,
-        1,
-        0,
-        1,
-        1,
-
-      } 
-    };
-    #endregion
-    
-    [StorableConstructor]
-    protected ISOContainerBinPackingProblem(bool deserializing) : base(deserializing) { }
-    protected ISOContainerBinPackingProblem(ISOContainerBinPackingProblem original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ISOContainerBinPackingProblem(this, cloner);
-    }
-    public ISOContainerBinPackingProblem()
-      : base() {
-    }
-
-
-
-    #region Helpers
-    protected override void InitializeDecoder() {
-      // Operators.RemoveAll(op => op is I2DOperator); TODO
-
-      PackingSolutionDecoderParameter.ValidValues.Clear();
-      if (SolutionCreator is MultiComponentVectorRandomCreator) {
-        PackingSolutionDecoderParameter.ValidValues.Add(new ISOContainerMultiComponentVectorDecoder3D());
-      } else {
-        string error = "The given problem does not support the selected solution-creator.";
-        PluginInfrastructure.ErrorHandling.ShowErrorDialog(error, null);
-      }
-    }
-
-    protected override void InitializeProblemData() {
-      Load(DefaultInstance);
-    }
-    #endregion
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RegularIdenticalBinPackingProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RegularIdenticalBinPackingProblem.cs	(revision 13607)
+++ 	(revision )
@@ -1,281 +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 System.Linq;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Problems.BinPacking.Shapes;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Parameters;
-using HeuristicLab.Problems.BinPacking.Decoders;
-using HeuristicLab.PluginInfrastructure;
-using HeuristicLab.Data;
-using HeuristicLab.Problems.BinPacking.Analyzers;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
-using HeuristicLab.Problems.Instances;
-using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
-
-namespace HeuristicLab.Problems.BinPacking.Problem {
-  [Item("RegularIdenticalBinPackingProblem", "Represents a bin-packing problem-instance using only bins with identical measures and bins/items with regular shapes (e.g. rectangle, cuboid).")]
-  [StorableClass]
-  public abstract class RegularIdenticalBinPackingProblem<D, B, I> : BinPackingProblem<D, B, I>, IProblemInstanceConsumer<BPPData>,  IProblemInstanceExporter<BPPData> 
-    where D : class, IPackingDimensions
-    where B : PackingShape<D>, IPackingBin, IRegularPackingShape, new()
-    where I : PackingShape<D>, IPackingItem, IRegularPackingShape, new() {        
-
-    #region Parameter Properties
-    public IValueParameter<B> PackingBinMeasuresParameter {
-      get { return (IValueParameter<B>)Parameters["PackingBinMeasures"]; }
-    }
-    public IConstrainedValueParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
-      get { return (IConstrainedValueParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
-    }
-    #endregion
-
-    #region Properties
-    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 RegularIdenticalBinPackingProblem(bool deserializing) : base(deserializing) { }
-    protected RegularIdenticalBinPackingProblem(RegularIdenticalBinPackingProblem<D,B,I> original, Cloner cloner)
-      : base(original, cloner) {
-      InitializeEventHandlers();
-    }
-
-    protected RegularIdenticalBinPackingProblem(IPackingPlanEvaluationAlgorithm e) : this(e, new MultiComponentVectorRandomCreator()) { }
-    protected RegularIdenticalBinPackingProblem(IPackingPlanEvaluationAlgorithm e, IPackingSolutionCreator c)
-      : base(e, c) {
-      Parameters.Add(new ValueParameter<B>("PackingBinMeasures", "Packing-bin data defining the measures of the used bins.", new B()));
-      Parameters.Add(new ValueParameter<IPackingPlanEvaluator>("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();
-      InitializeOperators();
-      InitializeEventHandlers();
-    }
-
-    
-
-
-    #region Helpers
-    protected override void InitializeProblemInstance() {
-      InitializeProblemData();
-      ApplyHorizontalOrientation();
-      SortItems();
-      RemoveTooBigItems();
-      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
-      LowerBoundParameter.Value.Value = CalculateLowerBound();
-    }
-    protected abstract void RemoveTooBigItems();
-    protected abstract void InitializeProblemData();
-    protected abstract IPackingPlanEvaluator CreateDefaultEvaluator();
-    private void ApplyHorizontalOrientation() {
-      PackingBinMeasures.ApplyHorizontalOrientation();
-      foreach (IRegularPackingShape shape in PackingItemMeasures) {
-        shape.ApplyHorizontalOrientation();
-      }
-    }
-    private void SortItems() {
-      PackingItemMeasures.Sort((x, y) => y.CompareTo(x));
-    }
-    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 items = PackingItemMeasures.Select(x => x.Volume).Sum();
-      int bin = PackingBinMeasures.Volume;
-      return (items + bin - 1)/(bin);
-    }
-
-    protected override void InitializeOperators() {
-      Operators.Clear();  
-      Operators.Add(new BestBinPackingSolutionAnalyzer<D, B, I>());
-
-      ApplyEncoding();
-      ParameterizeOperators();
-    }
-    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;
-        }
-      }
-
-    }
-
-    protected override 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;
-    }
-
-    #endregion
-
-    #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
-
-
-    #region Problem instance handling
-    public virtual void Load(BPPData data) {
-      // var realData = data as RealBPPData;
-      // var binData = new B();
-      // binData.InitializeFromMeasures (data.BinMeasures);
-      // 
-      // var itemData = new ItemList<I>(data.Items);
-      // for (int j = 0; j < data.Items; j++) {
-      //   var item = new I();
-      //   item.InitializeFromMeasures(data.ItemMeasures[j]);
-      //   item.AddTargetBinMeasures(data.BinMeasures);
-      //   if (realData != null) {
-      //     item.Weight = realData.ItemWeights[j];
-      //     item.Material = realData.ItemMaterials[j];
-      //   }
-      //   itemData.Add(item);
-      // }
-      // 
-      // BestKnownQuality = data.BestKnownQuality.HasValue ? new DoubleValue(data.BestKnownQuality.Value) : null;
-      // 
-      // PackingBinMeasures = binData;    
-      // PackingItemMeasures = itemData;
-      // 
-      // ApplyHorizontalOrientation();
-      // SortItems();
-      // PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
-      // LowerBoundParameter.Value.Value = CalculateLowerBound();
-
-      throw new NotImplementedException();
-    }
-
-    public BPPData Export() {
-      // var result = new BPPData{
-      //   Name = Name,
-      //   Description = Description,
-      //   Items = PackingItemsParameter.Value.Value,
-      //   BinMeasures = PackingBinMeasures.ToArray() // TODO: split functionality of class in 2d and 3d code
-      // };
-      // 
-      // var itemMeasures = new int[result.Items][];
-      // int i = 0;
-      // foreach (var item in PackingItemMeasures) {
-      //   itemMeasures[i] = item.ToArray();
-      //   i++;
-      // }
-      // result.ItemMeasures = itemMeasures;
-      // return result;
-
-      throw new NotImplementedException();
-    }
-    #endregion
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/RegularIdenticalBinPackingProblem.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/RegularIdenticalBinPackingProblem.cs	(revision 13608)
+++ branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/RegularIdenticalBinPackingProblem.cs	(revision 13608)
@@ -0,0 +1,281 @@
+﻿#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 System.Linq;
+using HeuristicLab.Problems.BinPacking.Interfaces;
+using HeuristicLab.Problems.BinPacking.Shapes;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+using HeuristicLab.Parameters;
+using HeuristicLab.Problems.BinPacking.Decoders;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.BinPacking.Analyzers;
+using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
+using HeuristicLab.Problems.Instances;
+using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
+
+namespace HeuristicLab.Problems.BinPacking.Problem {
+  [Item("RegularIdenticalBinPackingProblem", "Represents a bin-packing problem-instance using only bins with identical measures and bins/items with regular shapes (e.g. rectangle, cuboid).")]
+  [StorableClass]
+  public abstract class RegularIdenticalBinPackingProblem<D, B, I> : BinPackingProblem<D, B, I>, IProblemInstanceConsumer<BPPData>,  IProblemInstanceExporter<BPPData> 
+    where D : class, IPackingDimensions
+    where B : PackingShape<D>, IPackingBin, IRegularPackingShape, new()
+    where I : PackingShape<D>, IPackingItem, IRegularPackingShape, new() {        
+
+    #region Parameter Properties
+    public IValueParameter<B> PackingBinMeasuresParameter {
+      get { return (IValueParameter<B>)Parameters["PackingBinMeasures"]; }
+    }
+    public IConstrainedValueParameter<IPackingSolutionDecoder> PackingSolutionDecoderParameter {
+      get { return (IConstrainedValueParameter<IPackingSolutionDecoder>)Parameters["PackingSolutionDecoder"]; }
+    }
+    #endregion
+
+    #region Properties
+    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 RegularIdenticalBinPackingProblem(bool deserializing) : base(deserializing) { }
+    protected RegularIdenticalBinPackingProblem(RegularIdenticalBinPackingProblem<D,B,I> original, Cloner cloner)
+      : base(original, cloner) {
+      InitializeEventHandlers();
+    }
+
+    protected RegularIdenticalBinPackingProblem(IPackingPlanEvaluationAlgorithm e) : this(e, new MultiComponentVectorRandomCreator()) { }
+    protected RegularIdenticalBinPackingProblem(IPackingPlanEvaluationAlgorithm e, IPackingSolutionCreator c)
+      : base(e, c) {
+      Parameters.Add(new ValueParameter<B>("PackingBinMeasures", "Packing-bin data defining the measures of the used bins.", new B()));
+      Parameters.Add(new ValueParameter<IPackingPlanEvaluator>("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();
+      InitializeOperators();
+      InitializeEventHandlers();
+    }
+
+    
+
+
+    #region Helpers
+    protected override void InitializeProblemInstance() {
+      InitializeProblemData();
+      ApplyHorizontalOrientation();
+      SortItems();
+      RemoveTooBigItems();
+      PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
+      LowerBoundParameter.Value.Value = CalculateLowerBound();
+    }
+    protected abstract void RemoveTooBigItems();
+    protected abstract void InitializeProblemData();
+    protected abstract IPackingPlanEvaluator CreateDefaultEvaluator();
+    private void ApplyHorizontalOrientation() {
+      PackingBinMeasures.ApplyHorizontalOrientation();
+      foreach (IRegularPackingShape shape in PackingItemMeasures) {
+        shape.ApplyHorizontalOrientation();
+      }
+    }
+    private void SortItems() {
+      PackingItemMeasures.Sort((x, y) => y.CompareTo(x));
+    }
+    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 items = PackingItemMeasures.Select(x => x.Volume).Sum();
+      int bin = PackingBinMeasures.Volume;
+      return (items + bin - 1)/(bin);
+    }
+
+    protected override void InitializeOperators() {
+      Operators.Clear();  
+      Operators.Add(new BestBinPackingSolutionAnalyzer<D, B, I>());
+
+      ApplyEncoding();
+      ParameterizeOperators();
+    }
+    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;
+        }
+      }
+
+    }
+
+    protected override 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;
+    }
+
+    #endregion
+
+    #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
+
+
+    #region Problem instance handling
+    public virtual void Load(BPPData data) {
+      // var realData = data as RealBPPData;
+      // var binData = new B();
+      // binData.InitializeFromMeasures (data.BinMeasures);
+      // 
+      // var itemData = new ItemList<I>(data.Items);
+      // for (int j = 0; j < data.Items; j++) {
+      //   var item = new I();
+      //   item.InitializeFromMeasures(data.ItemMeasures[j]);
+      //   item.AddTargetBinMeasures(data.BinMeasures);
+      //   if (realData != null) {
+      //     item.Weight = realData.ItemWeights[j];
+      //     item.Material = realData.ItemMaterials[j];
+      //   }
+      //   itemData.Add(item);
+      // }
+      // 
+      // BestKnownQuality = data.BestKnownQuality.HasValue ? new DoubleValue(data.BestKnownQuality.Value) : null;
+      // 
+      // PackingBinMeasures = binData;    
+      // PackingItemMeasures = itemData;
+      // 
+      // ApplyHorizontalOrientation();
+      // SortItems();
+      // PackingItemsParameter.Value.Value = PackingItemMeasures.Count;
+      // LowerBoundParameter.Value.Value = CalculateLowerBound();
+
+      throw new NotImplementedException();
+    }
+
+    public BPPData Export() {
+      // var result = new BPPData{
+      //   Name = Name,
+      //   Description = Description,
+      //   Items = PackingItemsParameter.Value.Value,
+      //   BinMeasures = PackingBinMeasures.ToArray() // TODO: split functionality of class in 2d and 3d code
+      // };
+      // 
+      // var itemMeasures = new int[result.Items][];
+      // int i = 0;
+      // foreach (var item in PackingItemMeasures) {
+      //   itemMeasures[i] = item.ToArray();
+      //   i++;
+      // }
+      // result.ItemMeasures = itemMeasures;
+      // return result;
+
+      throw new NotImplementedException();
+    }
+    #endregion
+  }
+}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Shapes/CuboidPackingShape.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Shapes/CuboidPackingShape.cs	(revision 13607)
+++ 	(revision )
@@ -1,191 +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.Problems.BinPacking.Interfaces;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Problems.BinPacking.Dimensions;
-
-namespace HeuristicLab.Problems.BinPacking.Shapes {
-  [Item("CuboidPackingShape", "Represents the cuboid measures (width, height, depth) of a three-dimensional cuboidic bin-packing object.")]
-  [StorableClass]
-  public abstract class CuboidPackingShape : PackingShape<ThreeDimensionalPacking>, IRegularPackingShape, IComparable<CuboidPackingShape> {
-    public IFixedValueParameter<IntValue> HeightParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["Height"]; }
-    }
-    public IFixedValueParameter<IntValue> WidthParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["Width"]; }
-    }
-    public IFixedValueParameter<IntValue> DepthParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters["Depth"]; }
-    }
-
-    public int Height {
-      get { return HeightParameter.Value.Value; }
-      set { HeightParameter.Value.Value = value; }
-    }
-
-    public int Width {
-      get { return WidthParameter.Value.Value; }
-      set { WidthParameter.Value.Value = value; }
-    }
-
-    public int Depth {
-      get { return DepthParameter.Value.Value; }
-      set { DepthParameter.Value.Value = value; }
-    }
-
-    [StorableConstructor]
-    protected CuboidPackingShape(bool deserializing) : base(deserializing) { }
-    protected CuboidPackingShape(CuboidPackingShape original, Cloner cloner)
-      : base(original, cloner) {
-      RegisterEvents();
-    }
-    protected CuboidPackingShape()
-      : base() {
-      Parameters.Add(new FixedValueParameter<IntValue>("Width"));
-      Parameters.Add(new FixedValueParameter<IntValue>("Height"));
-      Parameters.Add(new FixedValueParameter<IntValue>("Depth"));
-
-      RegisterEvents();
-    }
-
-    protected CuboidPackingShape(int width, int height, int depth)
-      : this() {
-      this.Width = width;
-      this.Height = height;
-      this.Depth = depth;
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      RegisterEvents();
-    }
-
-    private void RegisterEvents() {
-      // only because of ToString override
-      HeightParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
-      WidthParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
-      DepthParameter.Value.ValueChanged += (sender, args) => OnToStringChanged();
-    }
-
-    public override string ToString() {
-      return String.Format("CuboidPackingShape ({0}, {1}, {2})", this.Width, this.Height, this.Depth);
-    }
-
-    #region IComparable Members
-
-    public int CompareTo(CuboidPackingShape other) {
-      //Using "Clustered-Area-Height"-comparison as descr
-
-      int result = (this.Width * this.Depth).CompareTo(other.Width * other.Depth);
-
-      if (result == 0)
-        result = this.Volume.CompareTo(other.Volume);
-      if (result == 0)
-        result = this.Height.CompareTo(other.Height);
-      return result;
-    }
-
-    public int CompareTo(object obj) {
-      var other = (CuboidPackingShape)obj;
-      if (other != null) return CompareTo(other);
-      else throw new ArgumentException(string.Format("Cannot compare with object {0}", obj), "obj");
-    }
-
-    #endregion
-
-    private struct CuboidDiagonal {
-      public int x1;
-      public int y1;
-      public int z1;
-      public int x2;
-      public int y2;
-      public int z2;
-      public CuboidDiagonal(CuboidPackingShape myShape) : this(new ThreeDimensionalPacking(0, 0, 0, 0), myShape) { }
-      public CuboidDiagonal(ThreeDimensionalPacking myPosition, CuboidPackingShape myShape) {
-        x1 = myPosition.X;
-        y1 = myPosition.Y;
-        z1 = myPosition.Z;
-        x2 = myPosition.X + (myPosition.Rotated ? myShape.Depth : myShape.Width) - 1;
-        y2 = myPosition.Y + myShape.Height - 1;
-        z2 = myPosition.Z + (myPosition.Rotated ? myShape.Width : myShape.Depth) - 1;
-      }
-    }
-
-
-    #region Helpers
-    public override ThreeDimensionalPacking Origin { get { return new ThreeDimensionalPacking(0, 0, 0, 0); } }
-    public override int Volume { get { return Width * Height * Depth; } }
-
-    public override bool EnclosesPoint(ThreeDimensionalPacking myPosition, ThreeDimensionalPacking checkedPoint) {
-      return (myPosition.X <= checkedPoint.X &&
-                (myPosition.X + (myPosition.Rotated ? Depth : Width) - 1) >= checkedPoint.X &&
-                myPosition.Y <= checkedPoint.Y &&
-                (myPosition.Y + Height - 1) >= checkedPoint.Y &&
-                myPosition.Z <= checkedPoint.Z &&
-                (myPosition.Z + (myPosition.Rotated ? Width : Depth) - 1) >= checkedPoint.Z);
-    }
-    public override bool Encloses(ThreeDimensionalPacking checkedPosition, PackingShape<ThreeDimensionalPacking> checkedShape) {
-      return Encloses(checkedPosition, (CuboidPackingShape)checkedShape);
-    }
-    private bool Encloses(ThreeDimensionalPacking checkedPosition, CuboidPackingShape checkedShape) {
-      return Encloses(new CuboidDiagonal(this), new CuboidDiagonal(checkedPosition, checkedShape));
-    }
-    private bool Encloses(CuboidDiagonal c1, CuboidDiagonal c2) {
-      return (c1.x1 <= c2.x1 &&
-                c1.x2 >= c2.x2 &&
-                c1.y1 <= c2.y1 &&
-                c1.y2 >= c2.y2 &&
-                c1.z1 <= c2.z1 &&
-                c1.z2 >= c2.z2);
-    }
-
-    public override bool Overlaps(ThreeDimensionalPacking myPosition, ThreeDimensionalPacking checkedPosition, PackingShape<ThreeDimensionalPacking> checkedShape) {
-      return Overlaps(myPosition, checkedPosition, (CuboidPackingShape)checkedShape);
-    }
-    private bool Overlaps(ThreeDimensionalPacking myPosition, ThreeDimensionalPacking checkedPosition, CuboidPackingShape checkedShape) {
-      return Overlaps(new CuboidDiagonal(myPosition, this), new CuboidDiagonal(checkedPosition, checkedShape));
-    }
-    private bool Overlaps(CuboidDiagonal c1, CuboidDiagonal c2) {
-      return !(c1.x1 > c2.x2 ||
-               c1.y1 > c2.y2 ||
-               c1.z1 > c2.z2 ||
-               c1.x2 < c2.x1 ||
-               c1.y2 < c2.y1 ||
-               c1.z2 < c2.z1);
-    }
-
-    public void ApplyHorizontalOrientation() {
-      if (Width > Depth) {
-        var aux = Width;
-        Width = Depth;
-        Depth = aux;
-      }
-    }
-    #endregion
-
-  }
-}
Index: branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Shapes/PackingShape.cs
===================================================================
--- branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Shapes/PackingShape.cs	(revision 13607)
+++ 	(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 System;
-using System.Collections.Generic;
-using System.Drawing;
-using System.Linq;
-using HeuristicLab.Problems.BinPacking.Interfaces;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Common;
-
-namespace HeuristicLab.Problems.BinPacking.Shapes {
-  [Item("PackingShape", "Represents an abstract shape to describe the measures and the positioning of objects related to bin-packing problems.")]
-  [StorableClass]
-  public abstract class PackingShape<T> : Item, IPackingShape, IParameterizedItem
-    where T : class, IPackingDimensions {
-    public static Type PositionType {
-      get { return typeof(T); }
-    }
-
-    public abstract bool EnclosesPoint(T myPosition, T checkedPoint);
-    public abstract bool Encloses(T checkedPosition, PackingShape<T> checkedShape);
-    public abstract bool Overlaps(T myPosition, T checkedPosition, PackingShape<T> checkedShape);
-    public abstract int Volume { get; }
-    public abstract T Origin { get; }
-
-    protected PackingShape()
-      : base() {
-      Parameters = new ParameterCollection();
-    }
-
-
-    [StorableConstructor]
-    protected PackingShape(bool deserializing) { }
-    protected PackingShape(PackingShape<T> original, Cloner cloner) {
-      this.Parameters = new ParameterCollection(original.Parameters.Select(p => cloner.Clone(p)));
-    }
-
-    public virtual void CollectParameterValues(IDictionary<string, IItem> values) {
-      foreach (IValueParameter param in Parameters.OfType<IValueParameter>()) {
-        var children = GetCollectedValues(param);
-        foreach (var c in children) {
-          if (String.IsNullOrEmpty(c.Key))
-            values.Add(param.Name, c.Value);
-          else values.Add(param.Name + "." + c.Key, c.Value);
-        }
-      }
-    }
-
-    protected virtual IEnumerable<KeyValuePair<string, IItem>> GetCollectedValues(IValueParameter param) {
-      if (param.Value == null) yield break;
-      if (param.GetsCollected) yield return new KeyValuePair<string, IItem>(String.Empty, param.Value);
-      var parameterizedItem = param.Value as IParameterizedItem;
-      if (parameterizedItem != null) {
-        var children = new Dictionary<string, IItem>();
-        parameterizedItem.CollectParameterValues(children);
-        foreach (var child in children) yield return child;
-      }
-    }
-
-    public IKeyedItemCollection<string, IParameter> Parameters { get; private set; }
-  }
-}
