Context Navigation

← Previous Changeset
Next Changeset →

Changeset 15473

Timestamp:

11/15/17 12:30:13 (7 years ago)

Author:

rhanghof

Message:

#2817:
-Added unit tests
-Refactoring of bp 3D

Location:

branches/2817-BinPackingSpeedup

Files:

: 338 added
: 8 deleted
: 17 edited

Legend:

: Unmodified
: Added
: Removed

branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/2D/BinPacking2D.cs

-                      r15241
+                      r15473
     public BinPacking2D(PackingShape binShape)
       : base(binShape) {
+      OccupationLayers = new Dictionary<int, List<int>>();
       ExtremePoints.Add(binShape.Origin);
       InitializeOccupationLayers();
 …
     [StorableConstructor]
     protected BinPacking2D(bool deserializing) : base(deserializing) { }
+    protected BinPacking2D(BinPacking2D original, Cloner cloner) : base(original, cloner) { }
+    protected BinPacking2D(BinPacking2D original, Cloner cloner) : base(original, cloner) {
+      this.OccupationLayers = new Dictionary<int, List<int>>();
+      foreach (var kvp in original.OccupationLayers) {
+        OccupationLayers.Add(kvp.Key, new List<int>(kvp.Value));
+      }
+    }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new BinPacking2D(this, cloner);
+    }
+    [Storable]
+    protected Dictionary<int, List<int>> OccupationLayers { get; set; }
     protected override void GenerateNewExtremePointsForNewItem(PackingItem newItem, PackingPosition position) {
 …
+    }
     public override PackingPosition FindExtremePointForItem(PackingItem item, bool rotated, bool stackingConstraints) {
+    public PackingPosition FindExtremePointForItem(PackingItem item, bool rotated, bool stackingConstraints) {
       PackingItem rotatedItem = new PackingItem(
         rotated ? item.Height : item.Width,
 …
       return null;
+    }
+    public override PackingPosition FindPositionBySliding(PackingItem item, bool rotated, bool stackingConstraints) {
+    public override void PackItem(int itemID, PackingItem item, PackingPosition position) {
+      Items[itemID] = item;
+      Positions[itemID] = position;
+      ExtremePoints.Remove(position);
+      GenerateNewExtremePointsForNewItem(item, position);
+      AddNewItemToOccupationLayers(itemID, item, position);
+    }
+    public bool PackItemIfFeasible(int itemID, PackingItem item, PackingPosition position, bool stackingConstraints) {
+      if (IsPositionFeasible(item, position, stackingConstraints)) {
+        PackItem(itemID, item, position);
+        return true;
+      }
+      return false;
+    }
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="item"></param>
+    /// <param name="position"></param>
+    /// <param name="stackingConstraints"></param>
+    /// <returns></returns>
+    public override bool IsPositionFeasible(PackingItem item, PackingPosition position, bool stackingConstraints) {
+      //In this case feasability is defined as following:
+      //1. the item fits into the bin-borders;
+      //2. the point is supported by something;
+      //3. the item does not collide with another already packed item
+      if (!BinShape.Encloses(position, item))
+        return false;
+      foreach (var id in GetLayerItemIDs(item, position)) {
+        if (Items[id].Overlaps(Positions[id], position, item))
+          return false;
+      }
+      return true;
+    }
+    public PackingPosition FindPositionBySliding(PackingItem item, bool rotated, bool stackingConstraints) {
       PackingPosition currentPosition = new PackingPosition(0,
         BinShape.Width - (rotated ? item.Height : item.Width),
 …
+    }
     public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints) {
+    public void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
 …
+      }
+    }
     public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> items, Dictionary<int, bool> rotationArray, bool stackingConstraints) {
+    public void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> items, Dictionary<int, bool> rotationArray, bool stackingConstraints) {
       var temp = new List<int>(sequence);
       for (int i = 0; i < temp.Count; i++) {
 …
+      }
+    }
     public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints) {
+    public void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
 …
+    }
     public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
+    public void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
       var temp = new List<int>(sequence);
       foreach (int itemID in temp) {
 …
+    }
     public override int ShortestPossibleSideFromPoint(PackingPosition position) {
+    public int ShortestPossibleSideFromPoint(PackingPosition position) {
       int shortestSide = int.MaxValue;
       int width = BinShape.Width;
 …
       throw new NotSupportedException();
+    }
     protected override void InitializeOccupationLayers() {
+    protected void InitializeOccupationLayers() {
       for (int i = 0; i * 10 <= BinShape.Width; i += 1) {
         OccupationLayers[i] = new List<int>();
 …
+    }
     protected override void AddNewItemToOccupationLayers(int itemID, PackingItem item, PackingPosition position) {
+    protected void AddNewItemToOccupationLayers(int itemID, PackingItem item, PackingPosition position) {
       int x1 = position.X / 10;
       int x2 = (position.X + (position.Rotated ? item.Height : item.Width)) / 10;
 …
         OccupationLayers[i].Add(itemID);
+    }
     protected override List<int> GetLayerItemIDs(PackingPosition position) {
+    protected List<int> GetLayerItemIDs(PackingPosition position) {
       return OccupationLayers[position.X / 10];
+    }
     protected override List<int> GetLayerItemIDs(PackingItem item, PackingPosition position) {
+    protected List<int> GetLayerItemIDs(PackingItem item, PackingPosition position) {
       List<int> result = new List<int>();
       int x1 = position.X / 10;
 …
       return result;
+    }
+    public int PointOccupation(PackingPosition position) {
+      foreach (var id in GetLayerItemIDs(position)) {
+        if (Items[id].EnclosesPoint(Positions[id], position))
+          return id;
+      }
+      return -1;
+    }
+    public bool IsPointOccupied(PackingPosition position) {
+      foreach (var id in GetLayerItemIDs(position)) {
+        if (Items[id].EnclosesPoint(Positions[id], position))
+          return true;
+      }
+      return false;
+    }
+  }
+}

branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/BinPacking3D.cs

-                      r15471
+                      r15473
       ResidualSpace = new Dictionary<PackingPosition, Tuple<int, int, int>>();
       AddExtremePoint(binShape.Origin);
-      InitializeOccupationLayers();
+    }
     [StorableConstructor]
 …
       #endregion
+    }
-    #region New methods for bin packer class
     /// <summary>
 …
       AddExtremePoint(ep3);
+    }
     private Tuple<int, int, int> CalculateResidualSpace(Vector3D pos) {
       var itemPos = Items.Select(x => new { Item = x.Value, Position = Positions[x.Key] });
 …
+        }
+      }
       if (limit.X - pos.X <= 0 || limit.Y - pos.Y <= 0  || limit.Z - pos.Z <= 0) {
+      if (limit.X - pos.X <= 0 || limit.Y - pos.Y <= 0 || limit.Z - pos.Z <= 0) {
         return Tuple.Create(0, 0, 0);
+      }
+      }
       return Tuple.Create(limit.X - pos.X, limit.Y - pos.Y, limit.Z - pos.Z);
+    }
 …
         itemsP4.Where(x => x.Item2.SupportsStacking(item)).Any();
+    }
+    #endregion
     /// <summary>
 …
       return false;
+    }
     #region Projections
 …
     #endregion
-    #region Sliding based packing  and obsolet methods
-    public override PackingPosition FindExtremePointForItem(PackingItem item, bool rotated, bool stackingConstraints) {
-      throw new NotSupportedException();
-      PackingItem newItem = new PackingItem(
-        rotated ? item.Depth : item.Width,
-        item.Height,
-        rotated ? item.Width : item.Depth,
-        item.TargetBin, item.Weight, item.Material);
-      var ep = ExtremePoints.Where(x => IsPositionFeasible(newItem, x, stackingConstraints))
-                            .FirstOrDefault();
-      if (ep != null) {
-        var result = new PackingPosition(ep.AssignedBin, ep.X, ep.Y, ep.Z, rotated);
-        return result;
+      }
-      return null;
+    }
-    public override PackingPosition FindPositionBySliding(PackingItem item, bool rotated, bool stackingConstraints) {
-      throw new NotSupportedException();
+    }
-    public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints) {
-      throw new NotSupportedException();
+    }
-    public override void SlidingBasedPacking(ref IList<int> sequence, IList<PackingItem> items, Dictionary<int, bool> rotationArray, bool stackingConstraints) {
-      throw new NotSupportedException();
+    }
-    public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints) {
-      throw new NotSupportedException();
+    }
-    public override void ExtremePointBasedPacking(ref IList<int> sequence, IList<PackingItem> items, bool stackingConstraints, Dictionary<int, bool> rotationArray) {
-      throw new NotSupportedException();
+    }
-    public override int ShortestPossibleSideFromPoint(PackingPosition position) {
-      throw new NotSupportedException();
+    }
-    protected override void InitializeOccupationLayers() {
+    }
-    protected override void AddNewItemToOccupationLayers(int itemID, PackingItem item, PackingPosition position) {
+    }
-    protected override List<int> GetLayerItemIDs(PackingPosition position) {
-      return null;
+    }
-    protected override List<int> GetLayerItemIDs(PackingItem item, PackingPosition position) {
-      return null;
+    }
-    #endregion

branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Evaluators/BinUtilizationEvaluator.cs

-                      r14167
+                      r15473
 using HeuristicLab.Common;
 namespace HeuristicLab.Problems.BinPacking3D {
+namespace HeuristicLab.Problems.BinPacking3D.Evaluators {
   // NOTE: same implementation as for 2d problem
   [Item("Bin-Utilization Evaluator (3d)", "Calculates the overall utilization of bin space.")]
 …
     #region IEvaluator Members
+    /// <summary>
+    /// Calculates the bin utilization in percent.
+    /// </summary>
+    /// <param name="solution"></param>
+    /// <returns>Returns the calculated bin utilization of all bins in percent.</returns>
     public double Evaluate(Solution solution) {
       return CalculateBinUtilization(solution);

branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Evaluators/PackingRatioEvaluator.cs

-                      r15462
+                      r15473
 using HeuristicLab.Common;
 namespace HeuristicLab.Problems.BinPacking3D {
+namespace HeuristicLab.Problems.BinPacking3D.Evaluators {
   // NOTE: same implementation as for 2d problem
   [Item("Packing-Ratio Evaluator (3d)", "Calculates the ratio between packed and unpacked space.")]
 …
     #region IEvaluator Members
+    /// <summary>
+    /// Calculates the packing ratio for the solution.
+    /// The packing ration is calculated as followed:
+    /// 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.
+    /// </summary>
+    /// <param name="solution"></param>
+    /// <returns>Returns the calculated packing ratio of the bins in the given solution.</returns>
     public double Evaluate(Solution solution) {
       return CalculatePackingRatio(solution);

branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Instances/BPPData.cs

-                      r14162
+                      r15473
 namespace HeuristicLab.Problems.BinPacking3D {
+namespace HeuristicLab.Problems.BinPacking3D.Instances {
+  /// <summary>
+  /// Represents an instance which contains bin packing problem data.
+  /// </summary>
   public class BPPData {
     /// <summary>
 …
     /// </summary>
     public string Name { get; set; }
     /// <summary>
     /// Optional! The description of the instance
 …
     /// </summary>
     public int NumItems { get { return Items == null ? 0 : Items.Length; } }
+    /// <summary>
+    /// Assigned packing shape
+    /// </summary>
     public PackingShape BinShape { get; set; }
+    /// <summary>
+    /// Array with assigned packing items
+    /// </summary>
     public PackingItem[] Items { get; set; }
     /// <summary>
     /// Optional! The quality of the best-known solution.

branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Instances/RandomInstanceProvider.cs

-                      r15454
+                      r15473
+    }
+    /// <summary>
+    /// Loads the data from the given data descriptor.
+    /// It retuns a bin packing problem data instance with the data of the random instance provider.
+    /// </summary>
+    /// <param name="dd"></param>
+    /// <returns></returns>
     public override BPPData LoadData(IDataDescriptor dd) {
       var randDd = dd as RandomDataDescriptor;

branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Instances/RealWorldContainerPackingInstanceProvider.cs

r15471	r15473
28	28	using System.Text.RegularExpressions;
29	29	using HeuristicLab.Problems.Instances;
	30	using HeuristicLab.Problems.BinPacking3D.Instances;
30	31
31	32	namespace HeuristicLab.Problems.BinPacking3D {

branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Packer/BinPacker.cs

r15471	r15473
54	54	/// <param name="packingItem"></param>
55	55	/// <param name="position"></param>
56		protected v~~oid PackItem(ref~~ BinPacking3D packingBin, int itemId, PackingItem packingItem, PackingPosition position, bool useStackingConstraints) {
	56	protected virtual void PackItem(BinPacking3D packingBin, int itemId, PackingItem packingItem, PackingPosition position, bool useStackingConstraints) {
57	57
58	58	packingBin.PackItem(itemId, packingItem, position);

branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Packer/BinPackerFirstFit.cs

r15471	r15473
67	67	// if a valid packing position could be found, the current item can be added to the given bin
68	68	if (position != null) {
69		PackItem(~~ref~~ packingBin, itemId, items[itemId], position, useStackingConstraints);
	69	PackItem(packingBin, itemId, items[itemId], position, useStackingConstraints);
70	70	remainingIds.Remove(itemId);
71	71	}

branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Packer/BinPackerFreeVolumeBestFit.cs

r15471	r15473
64	64	var bin = packingBin;
65	65	if (positionFound) {
66		PackItem(~~ref~~ bin, remainingId, item, position, useStackingConstraints);
	66	PackItem(bin, remainingId, item, position, useStackingConstraints);
67	67	break;
68	68	}
…	…
77	77	}
78	78
79		PackItem(~~ref~~ packingBin, remainingId, item, position, useStackingConstraints);
	79	PackItem(packingBin, remainingId, item, position, useStackingConstraints);
80	80	packingList.Add(packingBin);
81	81	}

branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/Packer/BinPackerResidualSpaceBestFit.cs

-                      r15471
+                      r15473
           if (point.Item1.IsPositionFeasible(item, point.Item2, useStackingConstraints)) {
             var binPacking = point.Item1;
             PackItem(ref binPacking, remainingId, item, point.Item2, useStackingConstraints);
+            PackItem(binPacking, remainingId, item, point.Item2, useStackingConstraints);
             packed = true;
             break;
 …
           var position = FindPackingPositionForItem(binPacking, item, useStackingConstraints, rotated);
           if (position != null) {
             PackItem(ref binPacking, remainingId, item, position, useStackingConstraints);
+            PackItem(binPacking, remainingId, item, position, useStackingConstraints);
           } else {
             throw new InvalidOperationException("Item " + remainingId + " cannot be packed in an empty bin.");

branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/3D/ProblemBase.cs

-                      r15471
+                      r15473
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.Instances;
+using HeuristicLab.Problems.BinPacking3D.Encoding;
+using HeuristicLab.Problems.BinPacking3D.Evaluators;
+using HeuristicLab.Problems.BinPacking3D.Instances;
 namespace HeuristicLab.Problems.BinPacking3D {

branches/2817-BinPackingSpeedup/HeuristicLab.Problems.BinPacking/3.3/BinPacking.cs

-                      r15454
+                      r15473
     public SortedSet<TPos> ExtremePoints { get; protected set; }
+    [Storable]
+    protected Dictionary<int, List<int>> OccupationLayers { get; set; }
+    #endregion Properties
+    public double PackingDensity {
+      get {
+        double result = 0;
+        foreach (var entry in Items)
+          result += entry.Value.Volume;
+        result /= BinShape.Volume;
+        return result;
+      }
+    }
     public int FreeVolume {
       get { return BinShape.Volume - Items.Sum(x => x.Value.Volume); }
+    }
+    #endregion Properties
     protected BinPacking(TBin binShape)
       : base() {
 …
       BinShape = (TBin)binShape.Clone();
       ExtremePoints = new SortedSet<TPos>();
-      OccupationLayers = new Dictionary<int, List<int>>();
+    }
     [StorableConstructor]
     protected BinPacking(bool deserializing) : base(deserializing) { }
     protected BinPacking(BinPacking<TPos, TBin, TItem> original, Cloner cloner)
       : base(original, cloner) {
 …
       this.BinShape = (TBin)original.BinShape.Clone(cloner);
       this.ExtremePoints = new SortedSet<TPos>(original.ExtremePoints.Select(p => cloner.Clone(p)));
-      this.OccupationLayers = new Dictionary<int, List<int>>();
-      foreach (var kvp in original.OccupationLayers) {
-        OccupationLayers.Add(kvp.Key, new List<int>(kvp.Value));
+      }
+    }
+    /// <summary>
+    /// Generate new extreme points for a given item
+    /// </summary>
+    /// <param name="item"></param>
+    /// <param name="position"></param>
     protected abstract void GenerateNewExtremePointsForNewItem(TItem item, TPos position);
+    public abstract TPos FindExtremePointForItem(TItem item, bool rotated, bool stackingConstraints);
+    public abstract TPos FindPositionBySliding(TItem item, bool rotated, bool stackingConstraints);
+    public abstract void SlidingBasedPacking(ref IList<int> sequence, IList<TItem> items, bool stackingConstraints);
+    public abstract void SlidingBasedPacking(ref IList<int> sequence, IList<TItem> items, Dictionary<int, bool> rotationArray, bool stackingConstraints);
+    public abstract void ExtremePointBasedPacking(ref IList<int> sequence, IList<TItem> items, bool stackingConstraints);
+    public abstract void ExtremePointBasedPacking(ref IList<int> sequence, IList<TItem> items, bool stackingConstraints, Dictionary<int, bool> rotationArray);
+    public virtual void PackItem(int itemID, TItem item, TPos position) {
+      Items[itemID] = item;
+      Positions[itemID] = position;
+      ExtremePoints.Remove(position);
+      GenerateNewExtremePointsForNewItem(item, position);
+      AddNewItemToOccupationLayers(itemID, item, position);
+    }
+    public virtual bool PackItemIfFeasible(int itemID, TItem item, TPos position, bool stackingConstraints) {
+      if (IsPositionFeasible(item, position, stackingConstraints)) {
+        PackItem(itemID, item, position);
+        return true;
+      }
+      return false;
+    }
+    public double PackingDensity {
+      get {
+        double result = 0;
+        foreach (var entry in Items)
+          result += entry.Value.Volume;
+        result /= BinShape.Volume;
+        return result;
+      }
+    }
+    public int PointOccupation(TPos position) {
+      foreach (var id in GetLayerItemIDs(position)) {
+        if (Items[id].EnclosesPoint(Positions[id], position))
+          return id;
+      }
+      return -1;
+    }
+    public bool IsPointOccupied(TPos position) {
+      foreach (var id in GetLayerItemIDs(position)) {
+        if (Items[id].EnclosesPoint(Positions[id], position))
+          return true;
+      }
+      return false;
+    }
     /// <summary>
+    ///
+    /// Packs an item into the bin packing
+    /// </summary>
+    /// <param name="itemID"></param>
+    /// <param name="item"></param>
+    /// <param name="position"></param>
+    public abstract void PackItem(int itemID, TItem item, TPos position);
+    /// <summary>
+    /// Checks if the given position is feasible for the given item
     /// </summary>
     /// <param name="item"></param>
     /// <param name="position"></param>
     /// <param name="stackingConstraints"></param>
+    /// <returns></returns>
+    public virtual bool IsPositionFeasible(TItem item, TPos position, bool stackingConstraints) {
+      //In this case feasability is defined as following:
+      //1. the item fits into the bin-borders;
+      //2. the point is supported by something;
+      //3. the item does not collide with another already packed item
+      if (!BinShape.Encloses(position, item))
+        return false;
+    /// <returns>Returns true if the given position is feasible for the given item</returns>
+    public abstract bool IsPositionFeasible(TItem item, TPos position, bool stackingConstraints);
       foreach (var id in GetLayerItemIDs(item, position)) {
         if (Items[id].Overlaps(Positions[id], position, item))
           return false;
+      }
       return true;
+    }
+    /// <summary>
+    /// Checks if the given item is static stable on the given position
+    /// </summary>
+    /// <param name="measures">Item</param>
+    /// <param name="position">Position of the item</param>
+    /// <returns>Returns true if the given item is static stable on the given position</returns>
+    public abstract bool IsStaticStable(TItem measures, TPos position);
+    public abstract int ShortestPossibleSideFromPoint(TPos position);
+    public abstract bool IsStaticStable(TItem measures, TPos position);
+    protected abstract void InitializeOccupationLayers();
+    protected abstract void AddNewItemToOccupationLayers(int itemID, TItem item, TPos position);
+    protected abstract List<int> GetLayerItemIDs(TPos position);
+    protected abstract List<int> GetLayerItemIDs(TItem item, TPos position);
+  }
+}

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

-                      r15462
+                      r15473
     <Compile Include="3D\Packer\BinPackerFirstFit.cs" />
     <Compile Include="3D\BinPacking3D.cs" />
     <Compile Include="3D\Decoder\ExtremePointPermutationDecoder.cs" />
+    <Compile Include="3D\Encoding\ExtremePointPermutationDecoder.cs" />
     <Compile Include="3D\Evaluators\BinUtilizationEvaluator.cs" />
     <Compile Include="3D\Evaluators\PackingRatioEvaluator.cs" />
 …
     <Compile Include="3D\Instances\RandomDataDescriptor.cs" />
     <Compile Include="3D\Instances\RealWorldContainerPackingInstanceProvider.cs" />
+    <Compile Include="3D\IntegerVectorEncoding\ThreeDInstanceParser.cs" />
+    <Compile Include="3D\IntegerVectorEncoding\BottomLeftIntegerVectorDecoder.cs" />
+    <Compile Include="3D\IntegerVectorEncoding\ExtremePointIntegerVectorDecoder.cs" />
+    <Compile Include="3D\IntegerVectorEncoding\IntegerVectorDecoderBase.cs" />
+    <Compile Include="3D\IntegerVectorEncoding\IntegerVectorProblem.cs" />
+    <Compile Include="3D\Interfaces\IDecoder.cs" />
+    <Compile Include="3D\Interfaces\IEvaluator.cs" />
+    <Compile Include="3D\Interfaces\IOperator.cs" />
+    <Compile Include="3D\MoveEvaluatorBase.cs" />
+    <Compile Include="3D\Instances\ThreeDInstanceParser.cs" />
+    <Compile Include="3D\Encoding\IDecoder.cs" />
+    <Compile Include="3D\Evaluators\IEvaluator.cs" />
+    <Compile Include="3D\IOperator.cs" />
+    <Compile Include="3D\Evaluators\MoveEvaluatorBase.cs" />
     <Compile Include="3D\PackingItem.cs" />
     <Compile Include="3D\PackingPosition.cs" />
     <Compile Include="3D\PackingShape.cs" />
     <Compile Include="3D\PermutationEncoding\PermutationProblem.cs" />
     <Compile Include="3D\PermutationEncoding\Swap2MoveEvaluator.cs" />
     <Compile Include="3D\PermutationEncoding\TranslocationMoveEvaluator.cs" />
+    <Compile Include="3D\Encoding\PermutationProblem.cs" />
+    <Compile Include="3D\Evaluators\Swap2MoveEvaluator.cs" />
+    <Compile Include="3D\Evaluators\TranslocationMoveEvaluator.cs" />
     <Compile Include="3D\ProblemBase.cs" />
     <Compile Include="3D\Solution.cs" />
     <Compile Include="3D\Sorting\PackingItemSorter.cs" />
     <Compile Include="Algorithms\3D\ExtremePointAlgorithm.cs" />
+    <Compile Include="3D\Sorting\PermutationPackingItemSorter.cs" />
+    <Compile Include="3D\Algorithms\ExtremePointAlgorithm.cs" />
     <Compile Include="BinPacking.cs" />
     <Compile Include="Interfaces\IPackingItem.cs">
 …
     <None Include="Plugin.cs.frame" />
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="3D\Algorithms\" />
+  </ItemGroup>
+  <ItemGroup />
   <ItemGroup>
     <ProjectReference Include="..\..\HeuristicLab.Analysis\3.3\HeuristicLab.Analysis-3.3.csproj">

branches/2817-BinPackingSpeedup/HeuristicLab.Tests/HeuristicLab.Problems.Bin-Packing-3.3/3D/PermutationSortingTest.cs

r15463	r15473
145	145	public void TestSortByMaterialClusteredAreaHeightExtension() {
146	146	Permutation actual = _items.SortByMaterialClusteredAreaHeight(_packingShape, 1.0);
147		Permutation expected = new Permutation(PermutationTypes.Absolute, new int[] { ~~0, 2, 5, 7, 8, 10, 13, 9, 11, 12, 14, 1, 3, 4, 6~~ });
	147	Permutation expected = new Permutation(PermutationTypes.Absolute, new int[] { 8, 13, 3, 2, 7, 12, 11, 1, 6, 0, 5, 10, 9, 14, 4 });
148	148	for (int i = 0; i < expected.Length; i++) {
149	149	Assert.AreEqual(expected[i], actual[i]);

branches/2817-BinPackingSpeedup/HeuristicLab.Tests/HeuristicLab.Problems.Bin-Packing-3.3/3D/RandomInstanceProviderTest.cs

r15471	r15473
44	44	private IDictionary<string, List<Dimension>> ReadReferenceItemLists() {
45	45	var itemList = new Dictionary<string, List<Dimension>>();
46		string path = @".\..\HeuristicLab.Tests\HeuristicLab.Problems.Bin-Packing-3.3\ReferenceInstances";
	46	string path = @".\..\HeuristicLab.Tests\HeuristicLab.Problems.Bin-Packing-3.3\TestInstances\ReferenceInstances";
47	47
48	48	string[] files = Directory.GetFiles(path);

branches/2817-BinPackingSpeedup/HeuristicLab.Tests/HeuristicLab.Tests.csproj

r15471	r15473
586	586	<Compile Include="HeuristicLab.Problems.Bin-Packing-3.3\3D\PermutationSortingTest.cs" />
587	587	<Compile Include="HeuristicLab.Problems.Bin-Packing-3.3\3D\ExtremePointAlgorithmTest.cs" />
	588	<Compile Include="HeuristicLab.Problems.Bin-Packing-3.3\3D\ThreeDInstanceParserTest.cs" />
588	589	<Compile Include="HeuristicLab.Problems.Bin-Packing-3.3\Utils\TestUtils.cs" />
589	590	<Compile Include="HeuristicLab.Problems.DataAnalysis-3.4\ThresholdCalculatorsTest.cs" />

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 15473

Legend:

Download in other formats: