Changeset 14050 for branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators

Timestamp:

07/12/16 20:35:19 (9 years ago)

Author:

gkronber

Message:

#1966: renamed evaluators

Location:

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

Files:

• BinUtilizationRegularIdenticalBinEvaluator.cs (modified) (3 diffs)
• PackingPlanEvaluationAlgorithm.cs (modified) (2 diffs)
• PackingPlanEvaluator.cs (modified) (3 diffs)
• PackingRatioEvaluator.cs (moved) (moved from branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/PackingRatioRegularIdenticalBinEvaluator.cs) (2 diffs)
• RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs (modified) (2 diffs)

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

@@ -28 +28 @@
 
 namespace HeuristicLab.Problems.BinPacking {
-  [Item("Bin-Utilization Regular Identical-Bin Evaluator", "<Description missing> Found in Lee:2010")]
+  [Item("Bin-Utilization Evaluator", "<Description missing> Found in Lee:2010")] // TODO
   [StorableClass]
-  public abstract class BinUtilizationRegularIdenticalBinEvaluator<D, B, I> : RegularSimpleRotationIdenticalBinPackingPlanEvaluator<D, B, I>
+  public abstract class BinUtilizationEvaluator<D, B, I> : EvaluatorBase<D, B, I>
     where D : class, IPackingPosition
     where B : PackingShape<D>
@@ -36 +36 @@
 
     [StorableConstructor]
-    protected BinUtilizationRegularIdenticalBinEvaluator(bool deserializing) : base(deserializing) { }
-    protected BinUtilizationRegularIdenticalBinEvaluator(BinUtilizationRegularIdenticalBinEvaluator<D, B, I> original, Cloner cloner)
+    protected BinUtilizationEvaluator(bool deserializing) : base(deserializing) { }
+    protected BinUtilizationEvaluator(BinUtilizationEvaluator<D, B, I> original, Cloner cloner)
       : base(original, cloner) {
     }
-    public BinUtilizationRegularIdenticalBinEvaluator() : base() { }
+    public BinUtilizationEvaluator() : base() { }
 
     protected override DoubleValue Evaluate() {
@@ -49 +49 @@
       ItemList<I> itemMeasures = PackingItemMeasuresParameter.ActualValue;
 
+      // TODO: check and remove code
 
       //Check if data is valid

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

@@ -44 +44 @@
       get { return PackingSolutionDecoderParameter; }
     }
-    public IValueLookupParameter<IPackingPlanEvaluator> PackingPlanEvaluatorParameter {
-      get { return (IValueLookupParameter<IPackingPlanEvaluator>)Parameters["PackingPlanEvaluator"]; }
+    public IValueLookupParameter<IEvaluator> PackingPlanEvaluatorParameter {
+      get { return (IValueLookupParameter<IEvaluator>)Parameters["PackingPlanEvaluator"]; }
     }
-    ILookupParameter<IPackingPlanEvaluator> IPackingPlanEvaluationAlgorithm.PackingPlanEvaluatorParameter {
+    ILookupParameter<IEvaluator> IPackingPlanEvaluationAlgorithm.PackingPlanEvaluatorParameter {
       get { return PackingPlanEvaluatorParameter; }
     }
@@ -62 +62 @@
       : 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 ValueLookupParameter<IEvaluator>("PackingPlanEvaluator", "The actual packing plan evaluation operator."));
         Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value aka fitness value of the solution."));
         QualityParameter.Hidden = true;

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

@@ -27 +27 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Data;
-
+using HeuristicLab.Collections;
 
 namespace HeuristicLab.Problems.BinPacking {
   [Item("Packingplan Evaluator", "Represents a evaluator class for standard bin-packing problems.")]
   [StorableClass]
-  public abstract class PackingPlanEvaluator<D,B,I> : SingleSuccessorOperator, IPackingPlanEvaluator
+  public abstract class EvaluatorBase<D,B,I> : SingleSuccessorOperator, IEvaluator
     where D : class, IPackingPosition
     where B : PackingShape<D>
@@ -52 +52 @@
       get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlan"]; }
     }
+    public ILookupParameter<ItemList<I>> PackingItemMeasuresParameter {
+      get { return (ILookupParameter<ItemList<I>>)Parameters["PackingItemMeasures"]; }
+    }
+    public ILookupParameter<B> PackingBinMeasuresParameter {
+      get { return (ILookupParameter<B>)Parameters["PackingBinMeasures"]; }
+    }
     #endregion
 
     [StorableConstructor]
-    protected PackingPlanEvaluator(bool deserializing) : base(deserializing) { }
-    protected PackingPlanEvaluator(PackingPlanEvaluator<D,B,I> original, Cloner cloner)
+    protected EvaluatorBase(bool deserializing) : base(deserializing) { }
+    protected EvaluatorBase(EvaluatorBase<D,B,I> original, Cloner cloner)
       : base(original, cloner) {
     }
-    public PackingPlanEvaluator()
+    public EvaluatorBase()
       : base() {
-      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value aka fitness value of the solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value of the solution."));
       Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlan", "The decoded bin-packing solution represented as generalized packing-plan."));
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator."));
+      Parameters.Add(new LookupParameter<ItemList<I>>("PackingItemMeasures", "Packing-item data taken from the bin-packing problem-instance."));
+      Parameters.Add(new LookupParameter<B>("PackingBinMeasures", "Packing-bin data taken from the bin-packing problem-instance."));
+
     }
-
 
     protected abstract DoubleValue Evaluate();                                                                        
@@ -73 +81 @@
     }
 
+    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;
+    }
   }
 }

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

@@ -28 +28 @@
 
 namespace HeuristicLab.Problems.BinPacking {
-  [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>
+  public abstract class PackingRatioEvaluator<D, B, I> : EvaluatorBase<D, B, I>
     where D : class, IPackingPosition
     where B : PackingShape<D>
@@ -36 +35 @@
 
     [StorableConstructor]
-    protected PackingRatioRegularIdenticalBinEvaluator(bool deserializing) : base(deserializing) { }
-    protected PackingRatioRegularIdenticalBinEvaluator(PackingRatioRegularIdenticalBinEvaluator<D, B, I> original, Cloner cloner)
+    protected PackingRatioEvaluator(bool deserializing) : base(deserializing) { }
+    protected PackingRatioEvaluator(PackingRatioEvaluator<D, B, I> original, Cloner cloner)
       : base(original, cloner) {
     }
-    public PackingRatioRegularIdenticalBinEvaluator() : base() { }
+    public PackingRatioEvaluator() : base() { }
 
     protected override DoubleValue Evaluate() {

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

@@ -54 +54 @@
     }
 
-
-
-
     protected bool HasOverlappingOrNotContainedItems(ObservableDictionary<int, D> positions, B binMeasure, ItemList<I> itemMeasures, int nrOfBins) {
       //TODO: Optimize performance by removing unnecessary allocations..
@@ -73 +70 @@
           }
         }
-
       }
-
       return false;
     }