Changeset 14128 for branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking

Timestamp:

07/20/16 14:02:36 (8 years ago)

Author:

gkronber

Message:

#1966: refactoring of bin packing implementation

Location:

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3

Files:

• Analyzers/BestBinPackingSolutionAnalyzer.cs (modified) (1 diff)
• Encodings/PackingPlans/BinPacking.cs (modified) (1 diff)
• Encodings/PackingPlans/PackingPlan.cs (modified) (4 diffs)
• Encodings/PackingSequence/Encoding.cs (modified) (3 diffs)
• Encodings/PackingSequence/IPackingSequenceCreator.cs (modified) (2 diffs)
• Encodings/PackingSequence/Moves/GroupingMoveHardTabuCriterion.cs (modified) (6 diffs)
• Encodings/PackingSequence/Moves/GroupingMoveMaker.cs (modified) (4 diffs)
• Encodings/PackingSequence/Moves/GroupingMoveSoftTabuCriterion.cs (modified) (6 diffs)
• Encodings/PackingSequence/Moves/Insertion/ExhaustiveInsertionMoveGenerator.cs (modified) (4 diffs)
• Encodings/PackingSequence/Moves/Insertion/InsertionMove.cs (modified) (7 diffs)
• Encodings/PackingSequence/Moves/Insertion/InsertionMoveGenerator.cs (modified) (4 diffs)
• Encodings/PackingSequence/Moves/Insertion/StochasticInsertionMoveGenerator.cs (modified) (4 diffs)
• Encodings/PackingSequence/Moves/SequenceMove.cs (modified) (2 diffs)
• Encodings/PackingSequence/Moves/SequenceTabuMaker.cs (modified) (4 diffs)
• Encodings/PackingSequence/Moves/Swap2/ExhaustiveSwap2MoveGenerator.cs (modified) (4 diffs)
• Encodings/PackingSequence/Moves/Swap2/StochasticSwap2MoveGenerator.cs (modified) (4 diffs)
• Encodings/PackingSequence/Moves/Swap2/Swap2Move.cs (modified) (4 diffs)
• Encodings/PackingSequence/Moves/Swap2/Swap2MoveGenerator.cs (modified) (4 diffs)
• Encodings/PackingSequence/PackingSequenceCrossover.cs (modified) (4 diffs)
• Encodings/PackingSequence/PackingSequenceInversionManipulator.cs (modified) (1 diff)
• Encodings/PackingSequence/PackingSequenceManipulator.cs (modified) (3 diffs)
• Encodings/PackingSequence/PackingSequenceOrderCrossover.cs (modified) (2 diffs)
• Encodings/PackingSequence/PackingSequencePartiallyMatchedCrossover.cs (modified) (2 diffs)
• Encodings/PackingSequence/PackingSequenceRandomCreator.cs (modified) (2 diffs)
• Encodings/PackingSequence/PackingSequenceScrambleManipulator.cs (modified) (1 diff)
• Encodings/PackingSolutionCrossover.cs (modified) (2 diffs)
• Encodings/PackingSolutionManipulator.cs (modified) (2 diffs)
• Evaluators/BinUtilizationEvaluator.cs (modified) (3 diffs)
• Evaluators/EvaluatorBase.cs (modified) (1 diff)
• Evaluators/PackingRatioEvaluator.cs (modified) (3 diffs)
• HeuristicLab.Problems.BinPacking-3.3.csproj (modified) (2 diffs)
• Interfaces/IPackingMove.cs (modified) (1 diff)
• Interfaces/IPackingSolutionCreator.cs (modified) (1 diff)
• Interfaces/IPackingSolutionCrossover.cs (modified) (1 diff)
• Interfaces/IPackingSolutionManipulator.cs (modified) (1 diff)
• PackingMoveEvaluator.cs (modified) (6 diffs)
• PackingSequenceProblem.cs (modified) (5 diffs)
• Problem.cs (modified) (7 diffs)

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Analyzers/BestBinPackingSolutionAnalyzer.cs

@@ -93 +93 @@
       }
       string binUtilKey = "Overall Bin Utilization";
-      DoubleValue binUtil = BinUtilizationEvaluator<D, B, I>.CalculateBinUtilization(bestSolution);
+      var binUtil = new DoubleValue(BinUtilizationEvaluator<D, B, I>.CalculateBinUtilization(bestSolution));
       if (!results.ContainsKey(binUtilKey))
         results.Add(new Result(binUtilKey, binUtil));

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/BinPacking.cs

@@ -40 +40 @@
 
     [Storable]
-    public ObservableDictionary<int, I> ItemMeasures { get; private set; } // TODO: renamed to item
+    public ObservableDictionary<int, I> ItemMeasures { get; private set; } // TODO: rename to items
 
     [Storable]
-    public B BinMeasures { get; private set; }
+    public B BinMeasures { get; private set; } 
 
     [Storable]

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs

@@ -28 +28 @@
 using HeuristicLab.Data;
 using HeuristicLab.Collections;
-using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
-using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Problems.BinPacking;
+using HeuristicLab.Encodings.PermutationEncoding;
 
 namespace HeuristicLab.Encodings.PackingEncoding {
@@ -98 +96 @@
     }
 
+    /*
     public void Pack(MultiComponentVectorEncoding solution, ItemList<I> itemMeasures) {
       var sequenceMatrix = solution.GenerateSequenceMatrix();
@@ -197 +196 @@
       solution.GroupingVector = new IntegerVector(newSolution);
     }
-    public void Pack(PackingSequenceEncoding solution, ItemList<I> itemMeasures) {
-      List<int> remainingIDs = new List<int>(solution.PackingSequence);
+     * 
+     
+    public void Pack(Permutation solution, ItemList<I> itemMeasures) {
+      List<int> remainingIDs = new List<int>(solution);
       while (remainingIDs.Count > 0) {
         var bp = NewBinPacking();
@@ -210 +211 @@
     }
 
-
+    */
     #region Events
     public event EventHandler QualityChanged;

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Encoding.cs

@@ -6 +6 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -13 +14 @@
 namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
   [StorableClass]
-  internal class Encoding : HeuristicLab.Optimization.Encoding<PackingSolutionCreator> {
+  public class Encoding : HeuristicLab.Optimization.Encoding<IPackingSolutionCreator> {
     [StorableConstructor]
     private Encoding(bool deserializing) : base(deserializing) { }
-    public Encoding() : base("PackingSequence") {
+    public Encoding()
+      : base("PackingSequence") {
       SolutionCreator = new PackingSequenceRandomCreator();
       RegisterParameterEvents();
@@ -64 +66 @@
 
   public static class IndividualExtensionMethods {
-    public static PackingSequence PackingSequence(this Individual individual) {
+    public static Permutation PackingSequence(this Individual individual) {
       var encoding = individual.GetEncoding<Encoding>();
       return individual.PackingSequence(encoding.Name);
     }
 
-    public static PackingSequence PackingSequence(this Individual individual, string name) {
-      return (PackingSequence)individual[name];
+    public static Permutation PackingSequence(this Individual individual, string name) {
+      return (Permutation)individual[name];
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/IPackingSequenceCreator.cs

@@ -23 +23 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Problems.BinPacking;
@@ -28 +29 @@
 namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
   interface IPackingSequenceCreator : ISolutionCreator, IPackingSequenceOperator {
-    IValueLookupParameter<IntValue> PackingItemsParameter { get; }
-    ILookupParameter<PackingSequence> SolutionParameter { get; }
-
+    ILookupParameter<IntValue> NumberOfPackingItemsParameter { get; }
+    ILookupParameter<Permutation> SolutionParameter { get; }
   }
 }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveHardTabuCriterion.cs

@@ -24 +24 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -37 +38 @@
       get { return false; }
     }
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
     }
-    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
-      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
     }
     public ILookupParameter<ItemList<IItem>> TabuListParameter {
@@ -64 +65 @@
     public SequenceMoveHardTabuCriterion()
       : base() {
-      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
-      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The solution to evaluate."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The solution candidate to evaluate."));
       Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
       Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
@@ -80 +81 @@
       ItemList<IItem> tabuList = TabuListParameter.ActualValue;
       SequenceMove move = PackingMoveParameter.ActualValue as SequenceMove;
-      PackingSequenceEncoding PackingSequence = PackingSequenceParameter.ActualValue;
-      int length = PackingSequence.PackingSequence.Length;
       double moveQuality = MoveQualityParameter.ActualValue.Value;
       bool maximization = MaximizationParameter.ActualValue.Value;
       bool useAspiration = UseAspirationCriterionParameter.Value.Value;
-      bool isTabu = IsMoveTabu(tabuList, move, PackingSequence, moveQuality, maximization, useAspiration);
+      bool isTabu = IsMoveTabu(tabuList, move, moveQuality, maximization, useAspiration);
 
       MoveTabuParameter.ActualValue = new BoolValue(isTabu);
@@ -91 +90 @@
     }
 
-    private bool IsMoveTabu(ItemList<IItem> tabuList, SequenceMove move, PackingSequenceEncoding PackingSequence, double moveQuality, bool maximization, bool useAspiration) {
+    private bool IsMoveTabu(ItemList<IItem> tabuList, SequenceMove move, double moveQuality, bool maximization, bool useAspiration) {
       bool isTabu = false;
-      var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType()));
+      var attributes = tabuList.FindAll(ta => ta.GetType() == move.GetMoveAttributeType());
 
       foreach (IItem attr in attributes) {
@@ -102 +101 @@
               || !maximization && moveQuality >= gvAttr.MoveQuality)) {
 
-          isTabu = move.BelongsToAttribute(gvAttr, true);
+          isTabu = move.BelongsToAttribute(gvAttr, true); // only difference to soft tabu criterion
         }
         if (isTabu) break;

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveMaker.cs

@@ -24 +24 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -43 +44 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
     }
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
     }
-    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
-      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
     }
     public ILookupParameter<IPackingPlan> PackingPlanParameter {
@@ -62 +63 @@
       : base() {
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution."));
-      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The move to evaluate."));
       Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The relative quality of the move."));
-      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The solution as Sequence vector."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The solution as Sequence vector."));
       Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlan", "The currently best performing, decoded bin-packing solution represented as generalized packing-plan."));
       Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlanAfterMove", "The moved and decoded bin-packing solution represented as generalized packing-plan."));
@@ -74 +75 @@
 
     public override IOperation Apply() {
-      IPackingMove move = PackingMoveParameter.ActualValue;
-      PackingSequenceEncoding PackingSequence = PackingSequenceParameter.ActualValue;
       DoubleValue moveQuality = MoveQualityParameter.ActualValue;
       DoubleValue quality = QualityParameter.ActualValue;
 
-      PackingSequence.PackingSequence = (move.GetSolutionAfterMove() as PackingSequenceEncoding).PackingSequence;
       PackingPlanParameter.ActualValue = PackingPlanAfterMoveParameter.ActualValue;
 

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/GroupingMoveSoftTabuCriterion.cs

@@ -24 +24 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -38 +39 @@
       get { return false; }
     }
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
     }
-    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
-      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
     }
     public ILookupParameter<ItemList<IItem>> TabuListParameter {
@@ -65 +66 @@
     public SequenceMoveSoftTabuCriterion()
       : base() {
-      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
-      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The solution to evaluate."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The solution to evaluate."));
       Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu."));
       Parameters.Add(new LookupParameter<ItemList<IItem>>("TabuList", "The tabu list."));
@@ -81 +82 @@
       ItemList<IItem> tabuList = TabuListParameter.ActualValue;
       SequenceMove move = PackingMoveParameter.ActualValue as SequenceMove;
-      PackingSequenceEncoding PackingSequence = PackingSequenceParameter.ActualValue;
-      int length = PackingSequence.PackingSequence.Length;
       double moveQuality = MoveQualityParameter.ActualValue.Value;
-      bool maximization = MaximizationParameter.ActualValue.Value;   
+      bool maximization = MaximizationParameter.ActualValue.Value;
       bool useAspiration = UseAspirationCriterionParameter.Value.Value;
-      bool isTabu = IsMoveTabu(tabuList, move, PackingSequence, moveQuality, maximization, useAspiration);
+      bool isTabu = IsMoveTabu(tabuList, move, moveQuality, maximization, useAspiration);
 
       MoveTabuParameter.ActualValue = new BoolValue(isTabu);
@@ -92 +91 @@
     }
 
-    private bool IsMoveTabu(ItemList<IItem> tabuList, SequenceMove move, PackingSequenceEncoding PackingSequence, double moveQuality, bool maximization, bool useAspiration) {
+    private bool IsMoveTabu(ItemList<IItem> tabuList, SequenceMove move, double moveQuality, bool maximization, bool useAspiration) {
       bool isTabu = false;
-      var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType()));
+      var attributes = tabuList.FindAll(ta => ta.GetType() == move.GetMoveAttributeType());
 
       foreach (IItem attr in attributes) {
@@ -103 +102 @@
               || !maximization && moveQuality >= gvAttr.MoveQuality)) {
 
-          isTabu = move.BelongsToAttribute(gvAttr, false);
+          isTabu = move.BelongsToAttribute(gvAttr, false); // only difference to hard tabu criterion 
         }
         if (isTabu) break;

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/ExhaustiveInsertionMoveGenerator.cs

@@ -24 +24 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -39 +40 @@
       return new ExhaustiveInsertionMoveGenerator(this, cloner);
     }
-    public static IEnumerable<InsertionMove> Generate(PackingSequenceEncoding PackingSequence, int nrOfBins) {
-      for (int i = 0; i < PackingSequence.PackingSequence.Length - 1; i++)
-        for (int j = i + 1; j < PackingSequence.PackingSequence.Length; j++) {
+    public static IEnumerable<InsertionMove> Generate(Permutation packingSequence, int nrOfBins) {
+      for (int i = 0; i < packingSequence.Length - 1; i++)
+        for (int j = i + 1; j < packingSequence.Length; j++) {
           if (j != i)
-            yield return new InsertionMove(i, j, PackingSequence);
+            yield return new InsertionMove(i, j, packingSequence);
         }
     }
 
-    public static InsertionMove[] Apply(PackingSequenceEncoding PackingSequence) {
+    public static InsertionMove[] Apply(Permutation packingSequence) {
       int nrOfBins = 0;
-      foreach (int binNr in PackingSequence.PackingSequence) {
+      foreach (int binNr in packingSequence) {
         if (binNr > nrOfBins)
           nrOfBins = binNr;
@@ -55 +56 @@
       nrOfBins++;
 
-      int totalMoves = (PackingSequence.PackingSequence.Length * (PackingSequence.PackingSequence.Length - 1)) / 2;
+      int totalMoves = (packingSequence.Length * (packingSequence.Length - 1)) / 2;
       InsertionMove[] moves = new InsertionMove[totalMoves];
       int count = 0;
-      foreach (InsertionMove move in Generate(PackingSequence, nrOfBins)) {
+      foreach (InsertionMove move in Generate(packingSequence, nrOfBins)) {
         moves[count++] = move;
       }
@@ -64 +65 @@
     }
 
-    protected override InsertionMove[] GenerateMoves(PackingSequenceEncoding PackingSequence) {
-      return Apply(PackingSequence);
+    protected override InsertionMove[] GenerateMoves(Permutation packingSequence) {
+      return Apply(packingSequence);
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMove.cs

@@ -32 +32 @@
   [Item("Insertion Move", "A move on a Sequence vector that is specified by two group-assignment-indexes.")]
   [StorableClass]
-  public class InsertionMove : SequenceMove, IPackingMove {
+  public class InsertionMove : SequenceMove {
     [Storable]
     public int Index1 { get; protected set; }
@@ -45 +45 @@
       this.Index2 = original.Index2;
     }
-    public InsertionMove(int index1, int index2, PackingSequenceEncoding PackingSequence)
-      : base(PackingSequence) {
+    public InsertionMove(int index1, int index2, Permutation packingSequence)
+      : base(packingSequence) {
       Index1 = index1;
       Index2 = index2;
@@ -55 +55 @@
     }
 
-    public override IPackingSolutionEncoding GetSolutionAfterMove() {
-      PackingSequenceEncoding newSolution = new PackingSequenceEncoding();
-
-      Permutation original = PackingSequence.PackingSequence;
-      Permutation resultingPermutation = (Permutation)PackingSequence.PackingSequence.Clone();
+    public override Permutation GetSolutionAfterMove() {
+      Permutation original = PackingSequence;
+      Permutation resultingPermutation = (Permutation)PackingSequence.Clone();
       int cutIndex, insertIndex, number;
 
@@ -68 +66 @@
       int i = 0;  // index in new permutation
       int j = 0;  // index in old permutation
-      while (i < PackingSequence.PackingSequence.Length) {
+      while (i < PackingSequence.Length) {
         if (j == cutIndex) {
           j++;
@@ -83 +81 @@
       }
 
-      newSolution.PackingSequence = resultingPermutation;
-      return newSolution;
+      return resultingPermutation;
     }
 
@@ -92 +89 @@
 
     public override SequenceMoveAttribute GetAttribute(double quality) {
-      return new InsertionMoveAttribute(Index1, Index2, PackingSequence.PackingSequence[Index1], PackingSequence.PackingSequence[Index2], quality);
+      return new InsertionMoveAttribute(Index1, Index2, PackingSequence[Index1], PackingSequence[Index2], quality);
     }
 
@@ -103 +100 @@
         } else
           if (Index1 == attr.Index1 && Index2 == attr.Index2)
-          return true;
+            return true;
       }
       return false;

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/InsertionMoveGenerator.cs

@@ -23 +23 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -37 +38 @@
       get { return false; }
     }
-    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
-      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
     }
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (LookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (LookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
     }
     protected ScopeParameter CurrentScopeParameter {
@@ -52 +53 @@
     public InsertionMoveGenerator()
       : base() {
-      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The Sequence vector for which moves should be generated."));
-      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The moves that should be generated in subscopes."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The Sequence vector for which moves should be generated."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The moves that should be generated in subscopes."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
     }
 
     public override IOperation Apply() {
-      PackingSequenceEncoding ps = PackingSequenceParameter.ActualValue;
+      Permutation ps = PackingSequenceParameter.ActualValue;
       InsertionMove[] moves = GenerateMoves(ps);
       Scope[] moveScopes = new Scope[moves.Length];
@@ -69 +70 @@
     }
 
-    protected abstract InsertionMove[] GenerateMoves(PackingSequenceEncoding PackingSequence);
+    protected abstract InsertionMove[] GenerateMoves(Permutation packingSequence);
   }
 }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Insertion/StochasticInsertionMoveGenerator.cs

@@ -25 +25 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -58 +59 @@
     }
 
-    public static InsertionMove[] Apply(PackingSequenceEncoding PackingSequence, IRandom random, int sampleSize) {
+    public static InsertionMove[] Apply(Permutation packingSequence, IRandom random, int sampleSize) {
 
       int nrOfBins = 0;
-      foreach (int binNr in PackingSequence.PackingSequence) {
+      foreach (int binNr in packingSequence) {
         if (binNr > nrOfBins)
           nrOfBins = binNr;
@@ -67 +68 @@
       nrOfBins++;
       var generatedMoves = new List<InsertionMove>();
-      var moves = new List<InsertionMove>(ExhaustiveInsertionMoveGenerator.Generate(PackingSequence, nrOfBins));
+      var moves = new List<InsertionMove>(ExhaustiveInsertionMoveGenerator.Generate(packingSequence, nrOfBins));
       int moveCount = moves.Count;
       for (int i = 0; i < sampleSize; i++) {
@@ -76 +77 @@
     }
 
-    protected override InsertionMove[] GenerateMoves(PackingSequenceEncoding SwapSequence) {
+    protected override InsertionMove[] GenerateMoves(Permutation packingSequence) {
       IRandom random = RandomParameter.ActualValue;
-      return Apply(SwapSequence, random, SampleSizeParameter.ActualValue.Value);
+      return Apply(packingSequence, random, SampleSizeParameter.ActualValue.Value);
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceMove.cs

@@ -24 +24 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.BinPacking;
 
 namespace HeuristicLab.Encodings.PackingEncoding.PackingSequence {
-  [Item("SequenceMove", "An abstract move for a packingSequence encoded solution.")]
+  [Item("SequenceMove", "An abstract move for a packing sequence encoded solution.")]
   [StorableClass]
-  public abstract class SequenceMove : Item, IPackingMove {
+  public abstract class SequenceMove : Item, IPackingMove<Permutation> {
     [Storable]
-    public PackingSequenceEncoding PackingSequence { get; protected set; }
+    public Permutation PackingSequence { get; protected set; }
 
     [StorableConstructor]
@@ -41 +42 @@
           this.PackingSequence = cloner.Clone(original.PackingSequence);
     }
-    public SequenceMove(PackingSequenceEncoding packingSequence)
+    public SequenceMove(Permutation packingSequence)
       : base() {
         PackingSequence = packingSequence;
     }
 
-    public abstract IPackingSolutionEncoding GetSolutionAfterMove();
+    public abstract Permutation GetSolutionAfterMove();
     public abstract Type GetMoveAttributeType();
     public abstract SequenceMoveAttribute GetAttribute(double quality);

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/SequenceTabuMaker.cs

@@ -23 +23 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization.Operators;
 using HeuristicLab.Parameters;
@@ -32 +33 @@
   [StorableClass]
   public class SequenceTabuMaker : TabuMaker, IPackingSequenceMoveOperator {
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
     }
-    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
-      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
     }
 
@@ -44 +45 @@
     public SequenceTabuMaker()
       : base() {
-      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate."));
-      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The solution to evaluate."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The move to evaluate."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The solution to evaluate."));
     }
 
@@ -53 +54 @@
 
     protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) {
-      IPackingMove move = PackingMoveParameter.ActualValue;
-      PackingSequenceEncoding PackingSequence = PackingSequenceParameter.ActualValue;
+      var move = PackingMoveParameter.ActualValue;
       double baseQuality = moveQuality;
       if (maximization && quality > moveQuality || !maximization && quality < moveQuality)

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/ExhaustiveSwap2MoveGenerator.cs

@@ -24 +24 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -39 +40 @@
       return new ExhaustiveSwap2MoveGenerator(this, cloner);
     }
-    public static IEnumerable<Swap2Move> Generate(PackingSequenceEncoding PackingSequence, int nrOfBins) {
-      for (int i = 0; i < PackingSequence.PackingSequence.Length - 1; i++)
-        for (int j = i + 1; j < PackingSequence.PackingSequence.Length; j++) {
+    public static IEnumerable<Swap2Move> Generate(Permutation packingSequence, int nrOfBins) {
+      for (int i = 0; i < packingSequence.Length - 1; i++)
+        for (int j = i + 1; j < packingSequence.Length; j++) {
           if (j != i)
-            yield return new Swap2Move(i, j, PackingSequence);
+            yield return new Swap2Move(i, j, packingSequence);
         }
     }
 
-    public static Swap2Move[] Apply(PackingSequenceEncoding PackingSequence) {
+    public static Swap2Move[] Apply(Permutation packingSequence) {
       int nrOfBins = 0;
-      foreach (int binNr in PackingSequence.PackingSequence) {
+      foreach (int binNr in packingSequence) {
         if (binNr > nrOfBins)
           nrOfBins = binNr;
@@ -55 +56 @@
       nrOfBins++;
 
-      int totalMoves = (PackingSequence.PackingSequence.Length * (PackingSequence.PackingSequence.Length - 1)) / 2;
+      int totalMoves = (packingSequence.Length * (packingSequence.Length - 1)) / 2;
       Swap2Move[] moves = new Swap2Move[totalMoves];
       int count = 0;
-      foreach (Swap2Move move in Generate(PackingSequence, nrOfBins)) {
+      foreach (Swap2Move move in Generate(packingSequence, nrOfBins)) {
         moves[count++] = move;
       }
@@ -64 +65 @@
     }
 
-    protected override Swap2Move[] GenerateMoves(PackingSequenceEncoding PackingSequence) {
-      return Apply(PackingSequence);
+    protected override Swap2Move[] GenerateMoves(Permutation packingSequence) {
+      return Apply(packingSequence);
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/StochasticSwap2MoveGenerator.cs

@@ -25 +25 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -58 +59 @@
     }
 
-    public static Swap2Move[] Apply(PackingSequenceEncoding PackingSequence, IRandom random, int sampleSize) {
+    public static Swap2Move[] Apply(Permutation packingSequence, IRandom random, int sampleSize) {
 
       int nrOfBins = 0;
-      foreach (int binNr in PackingSequence.PackingSequence) {
+      foreach (int binNr in packingSequence) {
         if (binNr > nrOfBins)
           nrOfBins = binNr;
@@ -67 +68 @@
       nrOfBins++;
       var generatedMoves = new List<Swap2Move>();
-      var moves = new List<Swap2Move>(ExhaustiveSwap2MoveGenerator.Generate(PackingSequence, nrOfBins));
+      var moves = new List<Swap2Move>(ExhaustiveSwap2MoveGenerator.Generate(packingSequence, nrOfBins));
       int moveCount = moves.Count;
       for (int i = 0; i < sampleSize; i++) {
@@ -76 +77 @@
     }
 
-    protected override Swap2Move[] GenerateMoves(PackingSequenceEncoding SwapSequence) {
+    protected override Swap2Move[] GenerateMoves(Permutation packingSequence) {
       IRandom random = RandomParameter.ActualValue;
-      return Apply(SwapSequence, random, SampleSizeParameter.ActualValue.Value);
+      return Apply(packingSequence, random, SampleSizeParameter.ActualValue.Value);
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2Move.cs

@@ -32 +32 @@
   [Item("Swap2 Move", "A move on a Sequence vector that is specified by two group-assignment-indexes.")]
   [StorableClass]
-  public class Swap2Move : SequenceMove, IPackingMove {
+  public class Swap2Move : SequenceMove, IPackingMove<Permutation> {
     [Storable]
     public int Index1 { get; protected set; }
@@ -45 +45 @@
       this.Index2 = original.Index2;
     }
-    public Swap2Move(int index1, int index2, PackingSequenceEncoding PackingSequence)
-      : base(PackingSequence) {
+    public Swap2Move(int index1, int index2, Permutation packingSequence)
+      : base(packingSequence) {
       Index1 = index1;
       Index2 = index2;
@@ -55 +55 @@
     }
 
-    public override IPackingSolutionEncoding GetSolutionAfterMove() {
-      PackingSequenceEncoding newSolution = new PackingSequenceEncoding();
-      newSolution.PackingSequence = (Permutation)PackingSequence.PackingSequence.Clone(new Cloner());
-      newSolution.PackingSequence[Index1] = PackingSequence.PackingSequence[Index2];
-      newSolution.PackingSequence[Index2] = PackingSequence.PackingSequence[Index1];
+    public override Permutation GetSolutionAfterMove() {
+      Permutation newSolution = (Permutation)PackingSequence.Clone(new Cloner());
+      newSolution[Index1] = PackingSequence[Index2];
+      newSolution[Index2] = PackingSequence[Index1];
       return newSolution;
     }
@@ -68 +67 @@
 
     public override SequenceMoveAttribute GetAttribute(double quality) {
-      return new Swap2MoveAttribute(Index1, Index2, PackingSequence.PackingSequence[Index1], PackingSequence.PackingSequence[Index2], quality);
+      return new Swap2MoveAttribute(Index1, Index2, PackingSequence[Index1], PackingSequence[Index2], quality);
     }
 

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/Moves/Swap2/Swap2MoveGenerator.cs

@@ -23 +23 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -36 +37 @@
       get { return false; }
     }
-    public ILookupParameter<PackingSequenceEncoding> PackingSequenceParameter {
-      get { return (ILookupParameter<PackingSequenceEncoding>)Parameters["PackingSequence"]; }
+    public ILookupParameter<Permutation> PackingSequenceParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
     }
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (LookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    public ILookupParameter<IPackingMove<Permutation>> PackingMoveParameter {
+      get { return (LookupParameter<IPackingMove<Permutation>>)Parameters["PackingMove"]; }
     }
     protected ScopeParameter CurrentScopeParameter {
@@ -51 +52 @@
     public Swap2MoveGenerator()
       : base() {
-      Parameters.Add(new LookupParameter<PackingSequenceEncoding>("PackingSequence", "The Sequence vector for which moves should be generated."));
-      Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The moves that should be generated in subscopes."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The Sequence vector for which moves should be generated."));
+      Parameters.Add(new LookupParameter<IPackingMove<Permutation>>("PackingMove", "The moves that should be generated in subscopes."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes."));
     }
 
     public override IOperation Apply() {
-      PackingSequenceEncoding ps = PackingSequenceParameter.ActualValue;
+      Permutation ps = PackingSequenceParameter.ActualValue;
       Swap2Move[] moves = GenerateMoves(ps);
       Scope[] moveScopes = new Scope[moves.Length];
@@ -68 +69 @@
     }
 
-    protected abstract Swap2Move[] GenerateMoves(PackingSequenceEncoding PackingSequence);
+    protected abstract Swap2Move[] GenerateMoves(Permutation packingSequence);
   }
 }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceCrossover.cs

@@ -23 +23 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.BinPacking;
@@ -29 +30 @@
   [Item("PackingSequenceCrossover", "An operator which crosses two PackingSequence representations.")]
   [StorableClass]
-  public abstract class PackingSequenceCrossover : PackingSolutionCrossover, IPackingSequenceOperator {
+  public abstract class PackingSequenceCrossover : PackingSolutionCrossover<Permutation>, IPackingSequenceOperator {
 
     [StorableConstructor]
@@ -36 +37 @@
     public PackingSequenceCrossover()
       : base() {
-        ParentsParameter.ActualName = "PackingSequence";
-        ChildParameter.ActualName = "PackingSequence";
+      ParentsParameter.ActualName = "PackingSequence";
+      ChildParameter.ActualName = "PackingSequence";
     }
 
-    public abstract PackingSequenceEncoding Cross(IRandom random, PackingSequenceEncoding parent1, PackingSequenceEncoding parent2);
+    public abstract Permutation Cross(IRandom random, Permutation parent1, Permutation parent2);
 
     public override IOperation Apply() {
@@ -46 +47 @@
 
       ChildParameter.ActualValue =
-        Cross(RandomParameter.ActualValue, parents[0] as PackingSequenceEncoding, parents[1] as PackingSequenceEncoding);
+        Cross(RandomParameter.ActualValue, parents[0], parents[1]);
 
       return base.Apply();

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceInversionManipulator.cs

@@ -43 +43 @@
     }
 
-    protected override void Manipulate(IRandom random, PackingSequenceEncoding individual) {
-      InversionManipulator.Apply(random, individual.PackingSequence);
+    protected override void Manipulate(IRandom random, Permutation individual) {
+      InversionManipulator.Apply(random, individual);
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceManipulator.cs

@@ -24 +24 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.BinPacking;
@@ -30 +31 @@
   [Item("PackingSequenceManipulator", "An operator which manipulates a PackingSequence representation.")]
   [StorableClass]
-  public abstract class PackingSequenceManipulator : PackingSolutionManipulator, IPackingSequenceOperator {
+  public abstract class PackingSequenceManipulator : PackingSolutionManipulator<Permutation>, IPackingSequenceOperator {
     [StorableConstructor]
     protected PackingSequenceManipulator(bool deserializing) : base(deserializing) { }
@@ -39 +40 @@
     }
 
-    protected abstract void Manipulate(IRandom random, PackingSequenceEncoding individual);
+    protected abstract void Manipulate(IRandom random, Permutation individual);
 
     public override IOperation Apply() {
-      var solution = EncodedSolutionParameter.ActualValue as PackingSequenceEncoding;
+      var solution = EncodedSolutionParameter.ActualValue;
       if (solution == null) throw new InvalidOperationException("PackingSolutionEncoding was not found or is not of type PackingSequenceEncoding.");
       Manipulate(RandomParameter.ActualValue, solution);

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceOrderCrossover.cs

@@ -30 +30 @@
   [Item("PackingSequence OX", "An operator which crosses two PackingSequence representations using the OX-strategy.")]
   [StorableClass]
-  public class PackingSequenceOrderCrossover : PackingSequenceCrossover, IPackingSequenceOperator {
+  public class PackingSequenceOrderCrossover : PackingSequenceCrossover {
 
     [StorableConstructor]
@@ -42 +42 @@
     }
 
-    public override PackingSequenceEncoding Cross(IRandom random, PackingSequenceEncoding parent1, PackingSequenceEncoding parent2) {
-      PackingSequenceEncoding result = new PackingSequenceEncoding();
-      result.PackingSequence = OrderCrossover.Apply(random, parent1.PackingSequence, parent2.PackingSequence);
-      return result;
+    public override Permutation Cross(IRandom random, Permutation parent1, Permutation parent2) {
+      return OrderCrossover.Apply(random, parent1, parent2);
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequencePartiallyMatchedCrossover.cs

@@ -31 +31 @@
   [Item("PackingSequence PMX", "An operator which crosses two PackingSequence representations using the OX-strategy.")]
   [StorableClass]
-  public class PackingSequencePartiallyMatchedCrossover : PackingSequenceCrossover, IPackingSequenceOperator {
+  public class PackingSequencePartiallyMatchedCrossover : PackingSequenceCrossover {
 
     [StorableConstructor]
@@ -43 +43 @@
     }
 
-    public override PackingSequenceEncoding Cross(IRandom random, PackingSequenceEncoding parent1, PackingSequenceEncoding parent2) {
-      PackingSequenceEncoding result = new PackingSequenceEncoding();
-      result.PackingSequence = PartiallyMatchedCrossover.Apply(random, parent1.PackingSequence, parent2.PackingSequence);
-      return result;
+    public override Permutation Cross(IRandom random, Permutation parent1, Permutation parent2) {
+      return PartiallyMatchedCrossover.Apply(random, parent1, parent2);
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceRandomCreator.cs

@@ -33 +33 @@
   [Item("PackingSequenceCreator", "Creator class used to create PackingSequence solutions for bin packing problems.")]
   [StorableClass]
-  public class PackingSequenceRandomCreator : PackingSolutionCreator, IStochasticOperator {
+  public class PackingSequenceRandomCreator : PackingSolutionCreator, IPackingSequenceCreator, IStochasticOperator {
 
     public ILookupParameter<IRandom> RandomParameter {
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public IValueLookupParameter<IntValue> PackingItemsParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["PackingItems"]; }
+    public ILookupParameter<IntValue> NumberOfPackingItemsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["NumberOfItems"]; }
     }
 
-    public ILookupParameter<PackingSequence> SolutionParameter {
-      get { return (ILookupParameter<PackingSequence>)Parameters["PackingItems"]; }
+    public ILookupParameter<Permutation> SolutionParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["PackingSequence"]; }
     }
 
@@ -58 +58 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("PackingItems", "The number of packing-items handled in this problem instance."));
-      Parameters.Add(new LookupParameter<PackingSequence>("PackingSequence"));
-
-      SolutionParameter.ActualName = "PackingSequence";
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfPackingItems", "The number of packing-items handled in this problem instance."));
+      Parameters.Add(new LookupParameter<Permutation>("PackingSequence", "The randomly created solution candidate."));
     }
 
     public override IOperation Apply() {
-      Apply(PackingItemsParameter.ActualValue.Value, RandomParameter.ActualValue);
+      Apply(NumberOfPackingItemsParameter.ActualValue.Value, RandomParameter.ActualValue);
       return base.Apply();
     }
 
-    public static PackingSequenceEncoding Apply(int items, IRandom random) {
-      var solution = new PackingSequenceEncoding();
-      solution.PackingSequence = new Permutation(PermutationTypes.Absolute, items, random);
-      return solution;
+    public static Permutation Apply(int items, IRandom random) {
+      return new Permutation(PermutationTypes.Absolute, items, random);
     }
     protected override IItem CreateSolution() {
-      return Apply(PackingItemsParameter.ActualValue.Value, RandomParameter.ActualValue);
+      return Apply(NumberOfPackingItemsParameter.ActualValue.Value, RandomParameter.ActualValue);
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSequence/PackingSequenceScrambleManipulator.cs

@@ -41 +41 @@
     }
 
-    protected override void Manipulate(IRandom random, PackingSequenceEncoding individual) {
-      ScrambleManipulator.Apply(random, individual.PackingSequence);
+    protected override void Manipulate(IRandom random, Permutation individual) {
+      ScrambleManipulator.Apply(random, individual);
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSolutionCrossover.cs

@@ -32 +32 @@
   [Item("PackingSolutionCrossover", "A bin packing crossover operation.")]
   [StorableClass]
-  public abstract class PackingSolutionCrossover : SingleSuccessorOperator, IPackingSolutionCrossover, IStochasticOperator {
+  public abstract class PackingSolutionCrossover<T> : SingleSuccessorOperator, IPackingSolutionCrossover<T>, IStochasticOperator
+  where T : class, IItem {
 
-    public ILookupParameter<IPackingSolutionEncoding> ChildParameter {
-      get { return (ILookupParameter<IPackingSolutionEncoding>)Parameters["Child"]; }
+    public ILookupParameter<T> ChildParameter {
+      get { return (ILookupParameter<T>)Parameters["Child"]; }
     }
-    public IScopeTreeLookupParameter<IPackingSolutionEncoding> ParentsParameter {
-      get { return (IScopeTreeLookupParameter<IPackingSolutionEncoding>)Parameters["Parents"]; }
+    public IScopeTreeLookupParameter<T> ParentsParameter {
+      get { return (IScopeTreeLookupParameter<T>)Parameters["Parents"]; }
     }
     public ILookupParameter<IRandom> RandomParameter {
@@ -46 +47 @@
     [StorableConstructor]
     protected PackingSolutionCrossover(bool deserializing) : base(deserializing) { }
-    protected PackingSolutionCrossover(PackingSolutionCrossover original, Cloner cloner) : base(original, cloner) { }
+    protected PackingSolutionCrossover(PackingSolutionCrossover<T> original, Cloner cloner) : base(original, cloner) { }
     public PackingSolutionCrossover()
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new LookupParameter<IPackingSolutionEncoding>("Child", "The child solution resulting from the crossover."));
+      Parameters.Add(new LookupParameter<T>("Child", "The child solution resulting from the crossover."));
       ChildParameter.ActualName = "EncodedSolution";
-      Parameters.Add(new ScopeTreeLookupParameter<IPackingSolutionEncoding>("Parents", "The parent solution which should be crossed."));
+      Parameters.Add(new ScopeTreeLookupParameter<T>("Parents", "The parent solution which should be crossed."));
       ParentsParameter.ActualName = "EncodedSolution";
     }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingSolutionManipulator.cs

@@ -32 +32 @@
   [Item("PackingSolutionManipulator", "A bin packing manipulation operation.")]
   [StorableClass]
-  public abstract class PackingSolutionManipulator : SingleSuccessorOperator, IPackingSolutionManipulator, IStochasticOperator {
+  public abstract class PackingSolutionManipulator<T> : SingleSuccessorOperator, IPackingSolutionManipulator<T>, IStochasticOperator
+  where T : class, IItem {
 
-    public ILookupParameter<IPackingSolutionEncoding> EncodedSolutionParameter {
-      get { return (ILookupParameter<IPackingSolutionEncoding>)Parameters["EncodedSolution"]; }
+    public ILookupParameter<T> EncodedSolutionParameter {
+      get { return (ILookupParameter<T>)Parameters["EncodedSolution"]; }
     }
 
@@ -44 +45 @@
     [StorableConstructor]
     protected PackingSolutionManipulator(bool deserializing) : base(deserializing) { }
-    protected PackingSolutionManipulator(PackingSolutionManipulator original, Cloner cloner) : base(original, cloner) { }
+    protected PackingSolutionManipulator(PackingSolutionManipulator<T> original, Cloner cloner) : base(original, cloner) { }
     public PackingSolutionManipulator()
       : base() {
-      Parameters.Add(new LookupParameter<IPackingSolutionEncoding>("EncodedSolution", "The bin packing solution to be manipulated."));
+      Parameters.Add(new LookupParameter<T>("EncodedSolution", "The bin packing solution to be manipulated."));
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
     }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/BinUtilizationEvaluator.cs

@@ -42 +42 @@
     public BinUtilizationEvaluator() : base() { }
 
-    protected override DoubleValue Evaluate() {
+    protected override double Evaluate() {
       DoubleValue quality = new DoubleValue(0);
 
@@ -67 +67 @@
     }
 
-    public static DoubleValue CalculateBinUtilization(PackingPlan<D, B, I> plan) {
+    public static double CalculateBinUtilization(PackingPlan<D, B, I> plan) {
       int nrOfBins = plan.NrOfBins;
       double result = 0;
@@ -97 +97 @@
 
       result = totalUsedSpace / totalUsableSpace;
-      return new DoubleValue(result);
+      return result;
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/EvaluatorBase.cs

@@ -75 +75 @@
     }
 
-    protected abstract DoubleValue Evaluate();                                                                        
+    protected abstract double Evaluate();                                                                        
     public override IOperation Apply() {
-      QualityParameter.ActualValue = Evaluate();
+      QualityParameter.ActualValue = new DoubleValue(Evaluate());
       return base.Apply();
     }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingRatioEvaluator.cs

@@ -41 +41 @@
     public PackingRatioEvaluator() : base() { }
 
-    protected override DoubleValue Evaluate() {
+    protected override double Evaluate() {
       DoubleValue quality = new DoubleValue(0);
 
@@ -74 +74 @@
         k.......a constant, k>1.
      */
-    public static DoubleValue CalculatePackingRatio(PackingPlan<D, B, I> plan) {
+    public static double CalculatePackingRatio(PackingPlan<D, B, I> plan) {
       int nrOfBins = plan.NrOfBins;
       double result = 0;
@@ -90 +90 @@
         //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);
+        var pd = plan.BinPackings[i].PackingDensity;
+        result += (pd * pd) / (i + 1);
       }
 
       result = result / nrOfBins;
-      return new DoubleValue(result);
+      return result;
     }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj

@@ -160 +160 @@
     <Compile Include="Analyzers\BestBinPackingSolutionAnalyzer.cs" />
     <Compile Include="Analyzers\BinPackingAnalyzer.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorSwap2Manipulator.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorSinglePointCrossover.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorDiscreteCrossover.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\GroupingMove.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\GroupingMoveAttribute.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\ExhaustiveSwapGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\SwapGroupingMove.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\SwapGroupingMoveAttribute.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\SwapGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\GroupingMoveMaker.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\GroupingTabuMaker.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\SwapGrouping\StochasticSwapGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\GroupingMoveSoftTabuCriterion.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\ExhaustiveChangeGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\ChangeGroupingMove.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\ChangeGroupingMoveAttribute.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\ChangeGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\GroupingMoveHardTabuCriterion.cs" />
-    <Compile Include="Encodings\GroupingVector\Moves\ChangeGrouping\StochasticChangeGroupingMoveGenerator.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorOnePositionManipulator.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorCrossover.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorEncoding.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorManipulator.cs" />
-    <Compile Include="Encodings\GroupingVector\GroupingVectorRandomCreator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\SequenceBasedMultiComponentVectorCrossover.cs" />
-    <Compile Include="Encodings\MultiComponentVector\BinBasedMultiComponentVectorCrossover.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Attributes\ChangePositionMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Triple\Attributes\MCVTripleMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Attributes\SwapPositionMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Attributes\SingleGroupingMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Attributes\SingleItemRotationMoveAttribute.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Triple\StochasticMCVTripleMoveGenerator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Triple\ExhaustiveMCVTripleMoveGenerator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Moves\ChangePositionMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Triple\Moves\MCVTripleMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveHardTabuCriterion.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Moves\SwapPositionMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Moves\SingleItemRotationMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\ExhaustiveMultiComponentVectorMoveGenerator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\Moves\SingleGroupingMove.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveGenerator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveSoftTabuCriterion.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorMoveMaker.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\MultiComponentVectorTabuMaker.cs" />
-    <Compile Include="Encodings\MultiComponentVector\Moves\Multi\StochasticMultiComponentVectorMoveGenerator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorEncoding.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorCrossover.cs" />
-    <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorManipulator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorRandomCreator.cs" />
-    <Compile Include="Encodings\MultiComponentVector\ThreeWayMultiComponentVectorManipulator.cs" />
     <Compile Include="Encodings\PackingPlans\BinPacking.cs" />
     <Compile Include="Encodings\PackingPlans\PackingPlan.cs" />
-    <Compile Include="Encodings\PackingSequence\Encoding.cs" />
-    <Compile Include="Encodings\PackingSequence\IPackingSequenceCreator.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Insertion\ExhaustiveInsertionMoveGenerator.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Insertion\StochasticInsertionMoveGenerator.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Insertion\InsertionMove.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Insertion\InsertionMoveAttribute.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Insertion\InsertionMoveGenerator.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequence.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequenceInversionManipulator.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequencePartiallyMatchedCrossover.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequenceOrderCrossover.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\SequenceMove.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\SequenceMoveAttribute.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\GroupingMoveHardTabuCriterion.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\GroupingMoveMaker.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\GroupingMoveSoftTabuCriterion.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\SequenceTabuMaker.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Swap2\ExhaustiveSwap2MoveGenerator.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Swap2\StochasticSwap2MoveGenerator.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Swap2\Swap2Move.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Swap2\Swap2MoveAttribute.cs" />
-    <Compile Include="Encodings\PackingSequence\Moves\Swap2\Swap2MoveGenerator.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequenceCrossover.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Encodings\PackingSequence\PackingSequenceEncoding.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Encodings\PackingSequence\PackingSequenceManipulator.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Encodings\PackingSequence\PackingSequenceRandomCreator.cs" />
-    <Compile Include="Encodings\PackingSequence\PackingSequenceScrambleManipulator.cs" />
     <Compile Include="Encodings\PackingSolutionCreator.cs" />
     <Compile Include="Encodings\PackingSolutionCrossover.cs" />
@@ -282 +195 @@
     <Compile Include="Plugin.cs" />
     <Compile Include="PackingSequenceProblem.cs" />
-    <Compile Include="Problem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingMove.cs

@@ -23 +23 @@
 
 namespace HeuristicLab.Problems.BinPacking  {
-  public interface IPackingMove : IItem {
-    IPackingSolutionEncoding GetSolutionAfterMove();
+  public interface IPackingMove<out T> : IItem {
+    T GetSolutionAfterMove();
   }
 }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionCreator.cs

@@ -24 +24 @@
 
 namespace HeuristicLab.Problems.BinPacking {
-  public interface IPackingSolutionCreator : ISolutionCreator{
+  public interface IPackingSolutionCreator : ISolutionCreator {
     ILookupParameter<IItem> EncodedSolutionParameter { get; }
   }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionCrossover.cs

@@ -25 +25 @@
 
 namespace HeuristicLab.Problems.BinPacking {
-  public interface IPackingSolutionCrossover : ICrossover, IPackingOperator {
-    ILookupParameter<IPackingSolutionEncoding> ChildParameter { get; }
-    IScopeTreeLookupParameter<IPackingSolutionEncoding> ParentsParameter { get; }
+  public interface IPackingSolutionCrossover<T> : ICrossover, IPackingOperator
+  where T : class, IItem {
+    ILookupParameter<T> ChildParameter { get; }
+    IScopeTreeLookupParameter<T> ParentsParameter { get; }
   }
 }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Interfaces/IPackingSolutionManipulator.cs

@@ -24 +24 @@
 
 namespace HeuristicLab.Problems.BinPacking {
-  public interface IPackingSolutionManipulator : IManipulator, IPackingOperator {
-    ILookupParameter<IPackingSolutionEncoding> EncodedSolutionParameter { get; }
+  public interface IPackingSolutionManipulator<T> : IManipulator, IPackingOperator
+  where T : class, IItem {
+    ILookupParameter<T> EncodedSolutionParameter { get; }
   }
 }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingMoveEvaluator.cs

@@ -24 +24 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.PackingEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -32 +33 @@
   [Item("PackingMoveEvaluator", "A base class for operators which evaluate Packing-Solution moves.")]
   [StorableClass]
-  public abstract class PackingMoveEvaluator<D, B, I> : SingleSuccessorOperator, IPackingMoveEvaluator, IMoveOperator
+  public abstract class PackingMoveEvaluator<D, B, I, M> : SingleSuccessorOperator, IPackingMoveEvaluator
     where D : class, IPackingPosition
     where B : PackingShape<D>
-    where I : PackingShape<D>, IPackingItem {     
+    where I : PackingShape<D>, IPackingItem 
+    where M : IItem {     
     public override bool CanChangeName {
       get { return false; }
@@ -61 +63 @@
       get { return (ScopeParameter)Parameters["CurrentScope"]; }
     }
-    public ILookupParameter<IPackingMove> PackingMoveParameter {
-      get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; }
+    public ILookupParameter<IPackingMove<M>> PackingMoveParameter {
+      get { return (ILookupParameter<IPackingMove<M>>)Parameters["PackingMove"]; }
     }  
     
     [StorableConstructor]
     protected PackingMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected PackingMoveEvaluator(PackingMoveEvaluator<D, B, I> original, Cloner cloner) : base(original, cloner) { }
+    protected PackingMoveEvaluator(PackingMoveEvaluator<D, B, I, M> original, Cloner cloner) : base(original, cloner) { }
     protected PackingMoveEvaluator()
       : base() {
@@ -77 +79 @@
       Parameters.Add(new ValueLookupParameter<IEvaluator>("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."));
+      Parameters.Add(new LookupParameter<IPackingMove<M>>("PackingMove", "The move to evaluate."));
     }
 
@@ -83 +85 @@
 
     public override IOperation Apply() {
-      IPackingMove move = PackingMoveParameter.ActualValue;
-      IPackingSolutionEncoding newSolution = move.GetSolutionAfterMove();
+      IPackingMove<M> move = PackingMoveParameter.ActualValue;
+      var newSolution = move.GetSolutionAfterMove();
       CurrentScopeParameter.ActualValue.Variables.Add(new Variable("MovedSolution", newSolution));
 
@@ -93 +95 @@
       CurrentScopeParameter.ActualValue.Variables.Add(new Variable("PackingPlanAfterMove", packingPlan));
 
-      DoubleValue quality = PackingRatioEvaluator<D, B, I>.CalculatePackingRatio(packingPlan);
+      var quality = PackingRatioEvaluator<D, B, I>.CalculatePackingRatio(packingPlan);
 
-      double moveQuality = quality.Value;
+      double moveQuality = quality;
 
       if (MoveQualityParameter.ActualValue == null) MoveQualityParameter.ActualValue = new DoubleValue(moveQuality);

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/PackingSequenceProblem.cs

@@ -23 +23 @@
 
 using System;
+using System.CodeDom;
 using System.Linq;
+using System.Text;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
+using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.BinPacking;
 
-namespace HeuristicLab.Problems.BinPacking2d {
+namespace HeuristicLab.Problems.BinPacking {
   [StorableClass]
-  abstract class PackingSequenceProblem : SingleObjectiveBasicProblem<Encoding> {
+  public abstract class PackingSequenceProblem<TSolution, TEncoding> : SingleObjectiveBasicProblem<TEncoding>
+    where TSolution : class, IItem
+    where TEncoding : class, IEncoding {
 
     // persistence
@@ -43 +48 @@
 
     // cloning
-    protected PackingSequenceProblem(PackingSequenceProblem original, Cloner cloner)
+    protected PackingSequenceProblem(PackingSequenceProblem<TSolution, TEncoding> original, Cloner cloner)
       : base(original, cloner) {
     }
@@ -53 +58 @@
     }
 
-    public sealed override double Evaluate(Individual individual, IRandom random) {
-      return Evaluate(individual.PackingSequence(), random);
-    }
-    public abstract double Evaluate(PackingSequence sequence, IRandom random);
-
-    public virtual void Analyze(PackingSequence[] trees, double[] qualities, ResultCollection results,
+    public virtual void Analyze(TSolution[] solutions, double[] qualities, ResultCollection results,
       IRandom random) {
       if (!results.ContainsKey("Best Solution Quality")) {
@@ -64 +64 @@
       }
       if (!results.ContainsKey("Best Solution")) {
-        results.Add(new Result("Best Solution", typeof(PackingSequence)));
+        results.Add(new Result("Best Solution", typeof(TSolution)));
       }
 
@@ -72 +72 @@
           IsBetter(bestQuality, ((DoubleValue)results["Best Solution Quality"].Value).Value)) {
         var bestIdx = Array.IndexOf(qualities, bestQuality);
-        var bestClone = (IItem)trees[bestIdx].Clone();
+        var bestClone = (IItem)solutions[bestIdx].Clone();
         results["Best Solution"].Value = bestClone;
         results["Best Solution Quality"].Value = new DoubleValue(bestQuality);
       }
     }
-
-    public sealed override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
-      Analyze(individuals.Select(ind => ind.PackingSequence()).ToArray(), qualities, results, random);
-    }
   }
 }

branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem.cs

@@ -26 +26 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector;
 using HeuristicLab.PluginInfrastructure;
 using System.Linq;
 using System;
-using HeuristicLab.Encodings.PackingEncoding.PackingSequence;
-using HeuristicLab.Encodings.PackingEncoding.GroupingVector;
 using HeuristicLab.Encodings.PackingEncoding;
 
@@ -97 +94 @@
     }
 
-    protected Problem(IDecodingEvaluator e) : this(e, new MultiComponentVectorRandomCreator()) { }
-
-    protected Problem(IDecodingEvaluator e, IPackingSolutionCreator c) : base(e, c) {
+    protected Problem(IDecodingEvaluator e) : this(e, new PackingSequenceRandomCreator()) { }
+
+    protected Problem(IDecodingEvaluator e, IPackingSolutionCreator c)
+      : base(e, c) {
       Parameters.Add(new OptionalValueParameter<PackingPlan<D, B, I>>("BestKnownSolution", "The best known solution of this bin-packing instance."));
       Parameters.Add(new ValueParameter<ItemList<I>>("PackingItemMeasures", "Packing-item data defining the measures of the different items that need to be packed.", new ItemList<I>()));
@@ -109 +107 @@
       Parameters.Add(new ConstrainedValueParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The operator that decodes the representation and creates a packing plan."));
       this.Maximization.Value = true;
-      InitializeProblemInstance();
+      InitializeProblemInstance(); // TODO
       InitializeOperators();
       InitializeEventHandlers();
@@ -163 +161 @@
         Operators.AddRange(ApplicationManager.Manager.GetInstances<IPackingSequenceOperator>());
         InitializeDecoder();
-      } else if (SolutionCreator.GetType() == typeof(GroupingVectorRandomCreator)) {
+      } /* else if (SolutionCreator.GetType() == typeof(GroupingVectorRandomCreator)) {
         Operators.AddRange(ApplicationManager.Manager.GetInstances<IGroupingVectorOperator>());
         InitializeDecoder();
@@ -169 +167 @@
         Operators.AddRange(ApplicationManager.Manager.GetInstances<IMultiComponentVectorOperator>());
         InitializeDecoder();
-      }
+      } */
     }
     private void ParameterizeOperators() {
@@ -193 +191 @@
         PackingPlanEvaluator.PackingPlanParameter.Hidden = false;
       }
+      /*
 
       foreach (var op in Operators.OfType<IPackingSolutionManipulator>()) {
@@ -205 +204 @@
         op.ParentsParameter.Hidden = true;
       }
-
+      */
       foreach (var op in Operators.OfType<BestBinPackingSolutionAnalyzer<D, B, I>>()) {
         op.QualityParameter.ActualName = PackingPlanEvaluator.QualityParameter.ActualName;