Changeset 9495
- Timestamp:
- 05/15/13 22:23:36 (11 years ago)
- Location:
- branches/HeuristicLab.BinPacking
- Files:
-
- 13 added
- 2 deleted
- 58 edited
Legend:
- Unmodified
- Added
- Removed
-
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlans/PackingPlan2DView.cs
r9440 r9495 18 18 public PackingPlan2DView() { 19 19 InitializeComponent(); 20 } 21 22 protected override void DeregisterContentEvents() { 23 Content.QualityChanged -= new EventHandler(Content_QualityChanged); 24 base.DeregisterContentEvents(); 25 } 26 protected override void RegisterContentEvents() { 27 base.RegisterContentEvents(); 28 Content.QualityChanged += new EventHandler(Content_QualityChanged); 20 29 } 21 30 … … 46 55 private void Redraw(PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> plan) { 47 56 int currentBin = (binSelection != null && binSelection.SelectedItem != null) ? (int)(binSelection.SelectedItem) : 0; 48 var bin = plan. PackingBinMeasures;57 var bin = plan.GetPackingBinMeasuresForBinNr(currentBin); 49 58 packingPlan2D.InitializeContainer(bin.Width, bin.Height); 50 59 int i = 0; … … 65 74 } 66 75 76 77 78 private void Content_QualityChanged(object sender, EventArgs e) { 79 if (InvokeRequired) 80 Invoke(new EventHandler(Content_QualityChanged), sender, e); 81 else { 82 binSelection.Items.Clear(); 83 if (Content == null) { 84 Redraw(); 85 } else { 86 for (int i = 0; i < Content.NrOfBins; i++) 87 binSelection.Items.Add(i); 88 Redraw(Content); 89 } 90 packingPlan2D.Invalidate(); 91 packingPlan2D.Update(); 92 } 93 } 67 94 } 68 95 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/PackingPlans/PackingPlan3DView.cs
r9440 r9495 18 18 public PackingPlan3DView() { 19 19 InitializeComponent(); 20 this.nameTextBox.Text = " XX";20 this.nameTextBox.Text = "Packing Plan"; 21 21 } 22 22 23 24 protected override void DeregisterContentEvents() { 25 Content.QualityChanged -= new EventHandler(Content_QualityChanged); 26 base.DeregisterContentEvents(); 27 } 28 protected override void RegisterContentEvents() { 29 base.RegisterContentEvents(); 30 Content.QualityChanged += new EventHandler(Content_QualityChanged); 31 } 23 32 24 33 public new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> Content { … … 34 43 packingPlan3D.InitializeContainer(0, 0, 0); 35 44 } else { 36 Content.Name = " XX";45 Content.Name = "Packing Plan"; 37 46 for (int i = 0; i < Content.NrOfBins; i++) 38 47 binSelection.Items.Add(i); … … 45 54 private void UpdateModel() { 46 55 int currentBin = (binSelection != null && binSelection.SelectedItem != null) ? (int)(binSelection.SelectedItem) : 0; 47 var bin = Content. PackingBinMeasures;56 var bin = Content.GetPackingBinMeasuresForBinNr(currentBin); 48 57 packingPlan3D.InitializeContainer(bin.Width, bin.Height, bin.Depth); 49 58 int i = 0; … … 58 67 i++; 59 68 } 60 61 int selectedItem = -1;62 if ((itemSelection != null && itemSelection.SelectedItem != null)) {63 if (!Int32.TryParse(itemSelection.SelectedItem.ToString(), out selectedItem)) {64 //if (itemSelection.SelectedItem.ToString().Equals("enum"))65 // packingPlan3D.StartItemEnumeration();66 selectedItem = -1;67 } else68 packingPlan3D.SelectItem(selectedItem);69 }70 69 } 71 70 … … 80 79 itemSelection.Items.Add(i); 81 80 } 82 //itemSelection.Items.Add("enum");83 81 84 82 packingPlan3D.Invalidate(); … … 88 86 private void itemSelection_SelectedIndexChanged(object sender, EventArgs e) { 89 87 UpdateModel(); 88 89 int selectedItem = -1; 90 if ((itemSelection != null && itemSelection.SelectedItem != null) && Int32.TryParse(itemSelection.SelectedItem.ToString(), out selectedItem)) { 91 packingPlan3D.SelectItem(selectedItem); 92 } else 93 packingPlan3D.UnselectItem(); 94 90 95 packingPlan3D.Invalidate(); 91 96 packingPlan3D.Update(); 92 97 } 93 98 99 private void Content_QualityChanged(object sender, EventArgs e) { 100 if (InvokeRequired) 101 Invoke(new EventHandler(Content_QualityChanged), sender, e); 102 else { 103 binSelection.Items.Clear(); 104 if (Content == null) { 105 packingPlan3D.InitializeContainer(0, 0, 0); 106 } else { 107 Content.Name = "Packing Plan"; 108 for (int i = 0; i < Content.NrOfBins; i++) 109 binSelection.Items.Add(i); 110 binSelection.SelectedIndex = 0; 111 UpdateModel(); 112 packingPlan3D.StartRendering(); 113 } 114 } 115 } 94 116 } 95 117 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Plugin.cs
r9473 r9495 26 26 /// Plugin class for HeuristicLab.Problems.BinPacking.Views plugin. 27 27 /// </summary> 28 [Plugin("HeuristicLab.Problems.BinPacking.Views", "3.3.7.94 40")]28 [Plugin("HeuristicLab.Problems.BinPacking.Views", "3.3.7.9473")] 29 29 [PluginFile("HeuristicLab.Problems.BinPacking.Views-3.3.dll", PluginFileType.Assembly)] 30 30 [PluginDependency("HeuristicLab.Common", "3.3")] -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking.Views/3.3/Properties/AssemblyInfo.cs
r9473 r9495 54 54 // by using the '*' as shown below: 55 55 [assembly: AssemblyVersion("3.3.0.0")] 56 [assembly: AssemblyFileVersion("3.3.7.94 40")]56 [assembly: AssemblyFileVersion("3.3.7.9473")] -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftFunctions.cs
r9440 r9495 5 5 using HeuristicLab.Collections; 6 6 using HeuristicLab.Core; 7 using HeuristicLab.Encodings.PackingEncoding.GroupingVector; 8 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector; 7 9 using HeuristicLab.Encodings.PackingEncoding.PackingSequence; 8 10 using HeuristicLab.Problems.BinPacking.Dimensions; … … 14 16 namespace HeuristicLab.Problems.BinPacking.Decoders { 15 17 public static class BottomLeftFunctions { 16 17 18 19 public static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) { 18 19 20 public static ObservableDictionary<int, TwoDimensionalPacking> BottomLeftPacking( 21 MultiComponentVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) { 22 int nrOfBins = solution.NrOfBins; 23 24 //Get all indexes of items for every bin according to grouping-vector 25 Dictionary<int, List<PackingInformation>> unpackedItemIndexesPerBin = new Dictionary<int, List<PackingInformation>>(); 26 27 for (int i = 0; i < nrOfBins; i++) { 28 unpackedItemIndexesPerBin[i] = new List<PackingInformation>(solution.PackingInformations[i]); 29 } 30 31 ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>(); 32 var remainingItems = new List<PackingInformation>(); 33 34 //Iterate over all bin-lists 35 for (int binNr = 0; binNr < nrOfBins; binNr++) { 36 //Iterate over the current bin-item-list and find feasible positions in the current bin for each item 37 var unpackedItems = unpackedItemIndexesPerBin[binNr]; 38 for (int i = 0; i < unpackedItems.Count; i++) { 39 var itemIndex = unpackedItems[i].ItemID; 40 var item = itemMeasures[itemIndex]; 41 TwoDimensionalPacking position = null; 42 43 position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures, unpackedItems[i].Rotated); 44 45 if (position == null) { 46 position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures, !unpackedItems[i].Rotated); 47 } 48 if (position == null) { 49 remainingItems.Add(unpackedItems[i]); 50 } else { 51 packingPositions[itemIndex] = position; 52 solution.PackingInformations[binNr].Remove(unpackedItems[i]); 53 solution.PackingInformations[binNr].Find(pi => pi.ItemID == itemIndex).Rotated = position.Rotated; 54 } 55 } 56 } 57 58 //Packing of remaining items 59 //Iterate over all bin-lists 60 for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) { 61 var unpackedItems = new List<PackingInformation>(remainingItems); 62 for (int i = 0; i < unpackedItems.Count; i++) { 63 var itemIndex = unpackedItems[i].ItemID; 64 var item = itemMeasures[itemIndex]; 65 TwoDimensionalPacking position = null; 66 67 //Look for space in current bin 68 position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures, unpackedItems[i].Rotated); 69 70 if (position == null) { 71 position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures, !unpackedItems[i].Rotated); 72 } 73 if (position != null) { 74 packingPositions[itemIndex] = position; 75 remainingItems.Remove(unpackedItems[i]); 76 solution.PackingInformations[binNr].Add(unpackedItems[i]); 77 solution.PackingInformations[binNr].Find(pi => pi.ItemID == itemIndex).Rotated = position.Rotated; 78 } 79 } 80 if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) { 81 solution.PackingInformations[nrOfBins] = new ItemList<PackingInformation>(); 82 nrOfBins++; 83 } 84 } 85 86 return packingPositions; 87 } 88 89 public static ObservableDictionary<int, TwoDimensionalPacking> BottomLeftPacking( 90 GroupingVectorEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) { 91 92 int nrOfBins = solution.GroupingVector.Max() + 1; 93 94 //Get all indexes of items for every bin according to grouping-vector 95 //It is assumed, that at this point the item-indexes are sorted according to their item-size! 96 Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>(); 97 98 for (int i = 0; i < nrOfBins; i++) { 99 unpackedItemIndexesPerBin[i] = solution.GroupingVector 100 .Select((Value, Index) => new { Value, Index }) 101 .Where(temp => temp.Value == i) 102 .Select(temp => temp.Index).ToList(); 103 } 104 105 ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>(); 106 var remainingItems = new List<int>(); 107 108 //Iterate over all bin-lists 109 for (int binNr = 0; binNr < nrOfBins; binNr++) { 110 //Iterate over the current bin-item-list and find feasible positions in the current bin for each item 111 var unpackedItems = unpackedItemIndexesPerBin[binNr]; 112 for (int i = 0; i < unpackedItems.Count; i++) { 113 var itemIndex = unpackedItems[i]; 114 var item = itemMeasures[itemIndex]; 115 TwoDimensionalPacking position = null; 116 117 //Look for space in current bin 118 position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures); 119 120 //Did not find enough space in current bin 121 if (position == null) { 122 remainingItems.Add(itemIndex); 123 } else 124 packingPositions[itemIndex] = position; 125 } 126 } 127 128 //Packing of remaining items 129 //Iterate over all bin-lists 130 for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) { 131 var unpackedItems = new List<int>(remainingItems); 132 for (int i = 0; i < unpackedItems.Count; i++) { 133 var itemIndex = unpackedItems[i]; 134 var item = itemMeasures[itemIndex]; 135 TwoDimensionalPacking position = null; 136 137 //Look for space in current bin 138 position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures); 139 140 if (position != null) { 141 packingPositions[itemIndex] = position; 142 remainingItems.Remove(itemIndex); 143 solution.GroupingVector[itemIndex] = binNr; 144 } 145 } 146 if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) { 147 nrOfBins++; 148 } 149 } 150 151 return packingPositions; 152 } 153 154 public static ObservableDictionary<int, TwoDimensionalPacking> BottomLeftPacking( 155 PackingSequenceEncoding solution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) { 156 157 ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>(); 158 int nrOfBins = 1; 159 for (int i = 0; i < solution.PackingSequence.Length; i++) { 160 var item = itemMeasures[solution.PackingSequence[i]]; 161 TwoDimensionalPacking position = null; 162 //Look for space in existing bins 163 for (int binNr = 0; binNr < nrOfBins; binNr++) { 164 position = BottomLeftFunctions.BottomLeftPosition(binMeasures, binNr, item, packingPositions, itemMeasures); 165 if (position != null) 166 break; 167 } 168 //Did not find enough space in any of the existing bins => create new bin 169 if (position == null) { 170 nrOfBins++; 171 position = BottomLeftFunctions.BottomLeftPosition(binMeasures, nrOfBins - 1, item, packingPositions, itemMeasures); 172 } 173 174 if (position == null) 175 position = new TwoDimensionalPacking(-1, 0, 0); 176 177 packingPositions[solution.PackingSequence[i]] = position; 178 } 179 180 return packingPositions; 181 } 182 183 private static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures) { 20 184 return BottomLeftPosition(binMeasures, binNr, currentItem, itemPositions, itemMeasures, false); 21 185 } 22 p ublicstatic TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures, bool rotated) {186 private static TwoDimensionalPacking BottomLeftPosition(RectangularPackingBin binMeasures, int binNr, RectangularPackingItem currentItem, ObservableDictionary<int, TwoDimensionalPacking> itemPositions, ItemList<RectangularPackingItem> itemMeasures, bool rotated) { 23 187 TwoDimensionalPacking currentPosition = new TwoDimensionalPacking(binNr, 24 188 binMeasures.Width - (rotated ? currentItem.Height : currentItem.Width), -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftGroupingVectorDecoder.cs
r9440 r9495 41 41 [Item("Identical bin two dimensional grouping vector decoder", "<Description missing...>")] 42 42 [StorableClass] 43 public class BottomLeftGroupingVectorDecoder : IdenticalBinPackingSolutionDecoder<43 public class BottomLeftGroupingVectorDecoder : PackingSolutionDecoder< 44 44 TwoDimensionalPacking, 45 45 RectangularPackingBin, 46 RectangularPackingItem, 47 PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> { 46 RectangularPackingItem> { 48 47 49 48 public BottomLeftGroupingVectorDecoder() … … 61 60 62 61 63 p rotected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {62 public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) { 64 63 65 64 var solution = encodedSolution as GroupingVectorEncoding; … … 69 68 new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue); 70 69 71 int nrOfBins = solution.GroupingVector.Max() + 1; 72 73 //Get all indexes of items for every bin according to grouping-vector 74 //It is assumed, that at this point the item-indexes are sorted according to their item-size! 75 Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>(); 76 77 for (int i = 0; i < nrOfBins; i++) { 78 unpackedItemIndexesPerBin[i] = solution.GroupingVector 79 .Select((Value, Index) => new { Value, Index }) 80 .Where(temp => temp.Value == i) 81 .Select(temp => temp.Index).ToList(); 82 } 83 84 ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>(); 85 var remainingItems = new List<int>(); 86 87 //Iterate over all bin-lists 88 for (int binNr = 0; binNr < nrOfBins; binNr++ ) { 89 //Iterate over the current bin-item-list and find feasible positions in the current bin for each item 90 var unpackedItems = unpackedItemIndexesPerBin [binNr]; 91 for (int i = 0; i < unpackedItems.Count; i++ ) { 92 var itemIndex = unpackedItems[i]; 93 var item = PackingItemMeasuresParameter.ActualValue[itemIndex]; 94 TwoDimensionalPacking position = null; 95 96 //Look for space in current bin 97 position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue); 98 99 //Did not find enough space in current bin 100 if (position == null) { 101 remainingItems.Add(itemIndex); 102 //if (binNr + 1 >= nrOfBins) { 103 // nrOfBins++; 104 // unpackedItemIndexesPerBin[binNr + 1] = new List<int>(); 105 // unpackedItemIndexesPerBin[binNr + 1].Add(itemIndex); 106 // unpackedItemIndexesPerBin[binNr].Remove(itemIndex); 107 //} else { 108 // unpackedItemIndexesPerBin[binNr + 1].Add(itemIndex); 109 // unpackedItemIndexesPerBin[binNr + 1].Sort(); 110 //} 111 //solution.GroupingVector[itemIndex] = binNr + 1; 112 } else 113 packingPositions[itemIndex] = position; 114 } 115 } 116 117 //Packing of remaining items 118 //Iterate over all bin-lists 119 for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) { 120 var unpackedItems = new List<int>(remainingItems); 121 for (int i = 0; i < unpackedItems.Count; i++) { 122 var itemIndex = unpackedItems[i]; 123 var item = PackingItemMeasuresParameter.ActualValue[itemIndex]; 124 TwoDimensionalPacking position = null; 125 126 //Look for space in current bin 127 position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue); 128 129 if (position != null) { 130 packingPositions[itemIndex] = position; 131 remainingItems.Remove(itemIndex); 132 solution.GroupingVector[itemIndex] = binNr; 133 } 134 } 135 if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) { 136 nrOfBins++; 137 } 138 } 139 140 result.PackingItemPositions = packingPositions; 141 142 70 result.PackingItemPositions = BottomLeftFunctions.BottomLeftPacking(solution, binMeasures, itemMeasures); 143 71 return result; 144 72 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftMultiComponentVectorDecoder.cs
r9440 r9495 41 41 [Item("Identical bin two dimensional multi component vector decoder", "<Description missing...>")] 42 42 [StorableClass] 43 public class BottomLeftMultiComponentVectorDecoder : IdenticalBinPackingSolutionDecoder<43 public class BottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder< 44 44 TwoDimensionalPacking, 45 45 RectangularPackingBin, 46 RectangularPackingItem, 47 PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> { 46 RectangularPackingItem> { 48 47 49 48 public BottomLeftMultiComponentVectorDecoder() … … 61 60 62 61 63 p rotected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {62 public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) { 64 63 65 64 var solution = encodedSolution as MultiComponentVectorEncoding; … … 68 67 PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> result = 69 68 new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue); 70 int nrOfBins = solution.PackingInformations.Max(pi => pi.AssignedBin) + 1; 71 72 //Get all indexes of items for every bin according to grouping-vector 73 Dictionary<int, List<PackingInformation>> unpackedItemIndexesPerBin = new Dictionary<int, List<PackingInformation>>(); 74 75 for (int i = 0; i < nrOfBins; i++) { 76 unpackedItemIndexesPerBin[i] = solution.PackingInformations 77 .Where(pi => pi.AssignedBin == i) 78 .ToList(); 79 } 80 81 ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>(); 82 var remainingItems = new List<PackingInformation>(); 83 84 //Iterate over all bin-lists 85 for (int binNr = 0; binNr < nrOfBins; binNr++) { 86 //Iterate over the current bin-item-list and find feasible positions in the current bin for each item 87 var unpackedItems = unpackedItemIndexesPerBin[binNr]; 88 for (int i = 0; i < unpackedItems.Count; i++) { 89 var itemIndex = unpackedItems[i].ItemIndex; 90 var item = PackingItemMeasuresParameter.ActualValue[itemIndex]; 91 TwoDimensionalPacking position = null; 92 93 position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, unpackedItems[i].Rotated); 94 95 if (position == null) { 96 position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, !unpackedItems[i].Rotated); 97 } 98 if (position == null) { 99 remainingItems.Add(unpackedItems[i]); 100 } else { 101 packingPositions[itemIndex] = position; 102 solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).Rotated = position.Rotated; 103 } 104 } 105 } 106 107 //Packing of remaining items 108 //Iterate over all bin-lists 109 for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) { 110 var unpackedItems = new List<PackingInformation>(remainingItems); 111 for (int i = 0; i < unpackedItems.Count; i++) { 112 var itemIndex = unpackedItems[i].ItemIndex; 113 var item = PackingItemMeasuresParameter.ActualValue[itemIndex]; 114 TwoDimensionalPacking position = null; 115 116 //Look for space in current bin 117 position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, unpackedItems[i].Rotated); 118 119 if (position == null) { 120 position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, !unpackedItems[i].Rotated); 121 } 122 if (position != null) { 123 packingPositions[itemIndex] = position; 124 remainingItems.Remove(unpackedItems[i]); 125 solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).AssignedBin = binNr; 126 solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).Rotated = position.Rotated; 127 } 128 } 129 if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) { 130 nrOfBins++; 131 } 132 } 133 134 result.PackingItemPositions = packingPositions; 69 70 result.PackingItemPositions = BottomLeftFunctions.BottomLeftPacking(solution, binMeasures, itemMeasures); 135 71 136 72 return result; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/BL/BottomLeftPackingSequenceDecoder.cs
r9440 r9495 40 40 [Item("Identical bin, two dimensional, direct permutation decoder", "<Description missing...>")] 41 41 [StorableClass] 42 public class BottomLeftPackingSequenceDecoder : IdenticalBinPackingSolutionDecoder<42 public class BottomLeftPackingSequenceDecoder : PackingSolutionDecoder< 43 43 TwoDimensionalPacking, 44 44 RectangularPackingBin, 45 RectangularPackingItem, 46 PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> { 45 RectangularPackingItem> { 47 46 48 47 public BottomLeftPackingSequenceDecoder() … … 60 59 61 60 62 p rotected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {61 public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) { 63 62 64 63 var solution = encodedSolution as PackingSequenceEncoding; … … 68 67 new PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue); 69 68 70 ObservableDictionary<int, TwoDimensionalPacking> packingPositions = new ObservableDictionary<int, TwoDimensionalPacking>(); 71 int nrOfBins = 1; 72 for (int i = 0; i < solution.PackingSequence.Length; i++) { 73 var item = PackingItemMeasuresParameter.ActualValue[solution.PackingSequence[i]]; 74 TwoDimensionalPacking position = null; 75 //Look for space in existing bins 76 for (int binNr = 0; binNr < nrOfBins; binNr++) { 77 position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue); 78 if (position != null) 79 break; 80 } 81 //Did not find enough space in any of the existing bins => create new bin 82 if (position == null) { 83 nrOfBins++; 84 position = BottomLeftFunctions.BottomLeftPosition(PackingBinMeasuresParameter.ActualValue, nrOfBins - 1, item, packingPositions, PackingItemMeasuresParameter.ActualValue); 85 } 86 87 if (position == null) 88 position = new TwoDimensionalPacking(-1, 0, 0); 89 90 packingPositions[solution.PackingSequence[i]] = position; 91 } 92 93 result.PackingItemPositions = packingPositions; 69 result.PackingItemPositions = BottomLeftFunctions.BottomLeftPacking (solution, binMeasures, itemMeasures); 94 70 95 71 return result; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointGroupingVectorDecoder2D.cs
r9440 r9495 41 41 [Item("Identical bin, two dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")] 42 42 [StorableClass] 43 public class ExtremePointGroupingVectorDecoder2D : IdenticalBinPackingSolutionDecoder<43 public class ExtremePointGroupingVectorDecoder2D : PackingSolutionDecoder< 44 44 TwoDimensionalPacking, 45 45 RectangularPackingBin, 46 RectangularPackingItem, 47 PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> { 46 RectangularPackingItem> { 48 47 49 48 public ExtremePointGroupingVectorDecoder2D () … … 68 67 } 69 68 70 p rotected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {69 public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) { 71 70 72 71 var solution = encodedSolution as GroupingVectorEncoding; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointMultiComponentVectorDecoder2D.cs
r9440 r9495 42 42 [Item("Identical bin, two dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")] 43 43 [StorableClass] 44 public class ExtremePointMultiComponentVectorDecoder2D : IdenticalBinPackingSolutionDecoder<44 public class ExtremePointMultiComponentVectorDecoder2D : PackingSolutionDecoder< 45 45 TwoDimensionalPacking, 46 46 RectangularPackingBin, 47 RectangularPackingItem, 48 PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> { 47 RectangularPackingItem> { 49 48 50 49 public ExtremePointMultiComponentVectorDecoder2D () … … 69 68 } 70 69 71 p rotected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {70 public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) { 72 71 73 72 var solution = encodedSolution as MultiComponentVectorEncoding; 74 73 if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector"); 75 74 76 return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);75 return Decode(solution, binMeasures, itemMeasures); 77 76 } 78 77 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointPackingSequenceDecoder2D.cs
r9440 r9495 40 40 [Item("Identical bin, two dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")] 41 41 [StorableClass] 42 public class ExtremePointPackingSequenceDecoder2D : IdenticalBinPackingSolutionDecoder<42 public class ExtremePointPackingSequenceDecoder2D : PackingSolutionDecoder< 43 43 TwoDimensionalPacking, 44 44 RectangularPackingBin, 45 RectangularPackingItem, 46 PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem>> { 45 RectangularPackingItem> { 47 46 48 47 public ExtremePointPackingSequenceDecoder2D () … … 59 58 60 59 61 p rotected override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {60 public override PackingPlan<TwoDimensionalPacking, RectangularPackingBin, RectangularPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, RectangularPackingBin binMeasures, ItemList<RectangularPackingItem> itemMeasures) { 62 61 63 62 var solution = encodedSolution as PackingSequenceEncoding; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/2D/EP/ExtremePointsFunctions2D.cs
r9440 r9495 24 24 25 25 #region Preperations 26 int nrOfBins = solution.PackingInformations.Max(x => x.AssignedBin) + 1;26 int nrOfBins = solution.NrOfBins; 27 27 28 28 //Get all indexes of items for every bin according to grouping-vector … … 32 32 33 33 for (int i = 0; i < nrOfBins; i++) { 34 unpackedItemIndexesPerBin[i] = solution.PackingInformations 35 .Where(pi => pi.AssignedBin == i) 36 .ToList(); 34 unpackedItemIndexesPerBin[i] = new List<PackingInformation> (solution.PackingInformations[i]); 37 35 38 36 extremePointsForBin[i] = new HashSet<TwoDimensionalPacking>(); … … 52 50 var unpackedItems = unpackedItemIndexesPerBin[binNr]; 53 51 for (int i = 0; i < unpackedItems.Count; i++) { 54 var itemIndex = unpackedItems[i].ItemI ndex;52 var itemIndex = unpackedItems[i].ItemID; 55 53 var item = itemMeasures[itemIndex]; 56 54 57 extremePointsForBin[binNr] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));55 extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures); 58 56 var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated); 59 57 if (positionFound != null) { … … 62 60 occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex); 63 61 extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures); 64 } else 62 } else { 65 63 remainingItems.Add(unpackedItems[i]); 64 solution.PackingInformations[binNr].Remove(unpackedItems[i]); 65 } 66 66 } 67 67 } … … 74 74 //Iterate over all the remaining items 75 75 for (int i = 0; i < unpackedItems.Count; i++) { 76 var itemIndex = unpackedItems[i].ItemI ndex;76 var itemIndex = unpackedItems[i].ItemID; 77 77 var item = itemMeasures[itemIndex]; 78 78 79 extremePointsForBin[binNr] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));79 extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures); 80 80 var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions, unpackedItems[i].Rotated); 81 81 if (positionFound != null) { … … 85 85 extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures); 86 86 remainingItems.Remove(unpackedItems[i]); 87 solution.PackingInformations[binNr].Add(unpackedItems[i]); 87 88 } 88 89 } … … 91 92 extremePointsForBin[nrOfBins].Add(new TwoDimensionalPacking(nrOfBins, 0, 0, false)); 92 93 occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures); 94 solution.PackingInformations[nrOfBins] = new ItemList<PackingInformation>(); 93 95 nrOfBins++; 94 96 } … … 136 138 var item = itemMeasures[itemIndex]; 137 139 138 extremePointsForBin[binNr] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));140 extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures); 139 141 var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions); 140 142 if (positionFound != null) { … … 159 161 var item = itemMeasures[itemIndex]; 160 162 161 extremePointsForBin[binNr] = new HashSet<TwoDimensionalPacking>(extremePointsForBin[binNr].OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));163 extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures); 162 164 var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions); 163 165 if (positionFound != null) { … … 197 199 foreach (int itemIndex in solution.PackingSequence) { 198 200 var item = itemMeasures[itemIndex]; 199 extremePoints = new HashSet<TwoDimensionalPacking>(extremePoints.OrderBy(ep => ep.AssignedBin).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures)));201 extremePoints = OrderExtremePoints(extremePoints, occupiedPoints, binMeasures); 200 202 var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions); 201 203 if (positionFound != null) { … … 296 298 return extremePoints; 297 299 } 300 301 public static HashSet<TwoDimensionalPacking> OrderExtremePoints(HashSet<TwoDimensionalPacking> hashSet, List<int[,]> occupiedPoints, RectangularPackingBin binMeasures) { 302 return new HashSet<TwoDimensionalPacking>(hashSet.OrderBy(ep => ep.AssignedBin).ThenBy(ep => ep.X).ThenBy(ep => ep.Y).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures))); 303 } 298 304 private static int ShortestPossibleSideFromEP(TwoDimensionalPacking ep, List<int[,]> occupiedPoints, RectangularPackingBin binMeasures) { 299 305 int shortestSide = int.MaxValue; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftFunctions.cs
r9440 r9495 6 6 using HeuristicLab.Core; 7 7 using HeuristicLab.Encodings.PackingEncoding.GroupingVector; 8 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector; 8 9 using HeuristicLab.Encodings.PackingEncoding.PackingSequence; 9 10 using HeuristicLab.Problems.BinPacking.Dimensions; … … 16 17 public static class DeepestBottomLeftFunctions { 17 18 19 public static ObservableDictionary<int, ThreeDimensionalPacking> DeepestLeftBottomPacking(MultiComponentVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) { 20 int nrOfBins = solution.NrOfBins; 21 22 //Get all indexes of items for every bin according to grouping-vector 23 Dictionary<int, List<PackingInformation>> unpackedItemIndexesPerBin = new Dictionary<int, List<PackingInformation>>(); 24 25 for (int i = 0; i < nrOfBins; i++) { 26 unpackedItemIndexesPerBin[i] = new List<PackingInformation>(solution.PackingInformations[i]); 27 } 28 29 ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>(); 30 var remainingItems = new List<PackingInformation>(); 31 32 //Iterate over all bin-lists 33 for (int binNr = 0; binNr < nrOfBins; binNr++) { 34 //Iterate over the current bin-item-list and find feasible positions in the current bin for each item 35 var unpackedItems = unpackedItemIndexesPerBin[binNr]; 36 for (int i = 0; i < unpackedItems.Count; i++) { 37 var itemIndex = unpackedItems[i].ItemID; 38 var item = itemMeasures[itemIndex]; 39 ThreeDimensionalPacking position = null; 40 41 position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures, unpackedItems[i].Rotated); 42 43 if (position == null) { 44 position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures, !unpackedItems[i].Rotated); 45 } 46 if (position == null) { 47 remainingItems.Add(unpackedItems[i]); 48 solution.PackingInformations[binNr].Remove(unpackedItems[i]); 49 } else { 50 packingPositions[itemIndex] = position; 51 solution.PackingInformations[binNr].Find(pi => pi.ItemID == itemIndex).Rotated = position.Rotated; 52 } 53 } 54 } 55 56 //Packing of remaining items 57 //Iterate over all bin-lists 58 for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) { 59 var unpackedItems = new List<PackingInformation>(remainingItems); 60 for (int i = 0; i < unpackedItems.Count; i++) { 61 var itemIndex = unpackedItems[i].ItemID; 62 var item = itemMeasures[itemIndex]; 63 ThreeDimensionalPacking position = null; 64 65 //Look for space in current bin 66 position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures, unpackedItems[i].Rotated); 67 68 if (position == null) { 69 position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures, !unpackedItems[i].Rotated); 70 } 71 if (position != null) { 72 packingPositions[itemIndex] = position; 73 remainingItems.Remove(unpackedItems[i]); 74 solution.PackingInformations[binNr].Add(unpackedItems[i]); 75 solution.PackingInformations[binNr].Find(pi => pi.ItemID == itemIndex).Rotated = position.Rotated; 76 } 77 } 78 if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) { 79 solution.PackingInformations[nrOfBins] = new ItemList<PackingInformation>(); 80 nrOfBins++; 81 } 82 } 83 84 return packingPositions; 85 } 86 18 87 public static ObservableDictionary<int, ThreeDimensionalPacking> DeepestLeftBottomPacking(GroupingVectorEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) { 19 88 int nrOfBins = solution.GroupingVector.Max() + 1; … … 77 146 } 78 147 79 148 public static ObservableDictionary<int, ThreeDimensionalPacking> DeepestLeftBottomPacking(PackingSequenceEncoding solution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) { 149 ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>(); 150 int nrOfBins = 1; 151 for (int i = 0; i < solution.PackingSequence.Length; i++) { 152 var item = itemMeasures[solution.PackingSequence[i]]; 153 ThreeDimensionalPacking position = null; 154 //Look for space in existing bins 155 for (int binNr = 0; binNr < nrOfBins; binNr++) { 156 position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, binNr, item, packingPositions, itemMeasures); 157 if (position != null) 158 break; 159 } 160 //Did not find enough space in any of the existing bins => create new bin 161 if (position == null) { 162 nrOfBins++; 163 position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(binMeasures, nrOfBins - 1, item, packingPositions, itemMeasures); 164 } 165 166 if (position == null) 167 position = new ThreeDimensionalPacking(-1, 0, 0, 0); 168 169 packingPositions[solution.PackingSequence[i]] = position; 170 } 171 172 return packingPositions; 173 } 80 174 81 175 public static ThreeDimensionalPacking DeepestLeftBottomPosition(CuboidPackingBin binMeasures, int binNr, CuboidPackingItem currentItem, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, ItemList<CuboidPackingItem> itemMeasures) { -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftGroupingVectorDecoder.cs
r9440 r9495 40 40 [Item("Identical bin three dimensional direct grouping vector decoder", "<Description missing...>")] 41 41 [StorableClass] 42 public class DeepestBottomLeftGroupingVectorDecoder : IdenticalBinPackingSolutionDecoder<42 public class DeepestBottomLeftGroupingVectorDecoder : PackingSolutionDecoder< 43 43 ThreeDimensionalPacking, 44 44 CuboidPackingBin, 45 CuboidPackingItem, 46 PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> { 45 CuboidPackingItem> { 47 46 48 47 public DeepestBottomLeftGroupingVectorDecoder() … … 60 59 61 60 62 p rotected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {61 public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) { 63 62 64 63 var solution = encodedSolution as GroupingVectorEncoding; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftMultiComponentVectorDecoder.cs
r9440 r9495 41 41 [Item("Identical bin three dimensional multi component vector decoder", "<Description missing...>")] 42 42 [StorableClass] 43 public class DeepestBottomLeftMultiComponentVectorDecoder : IdenticalBinPackingSolutionDecoder<43 public class DeepestBottomLeftMultiComponentVectorDecoder : PackingSolutionDecoder< 44 44 ThreeDimensionalPacking, 45 45 CuboidPackingBin, 46 CuboidPackingItem, 47 PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> { 46 CuboidPackingItem> { 48 47 49 48 public DeepestBottomLeftMultiComponentVectorDecoder() … … 61 60 62 61 63 p rotected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {62 public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) { 64 63 65 64 var solution = encodedSolution as MultiComponentVectorEncoding; … … 68 67 PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> result = 69 68 new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue); 70 int nrOfBins = solution.PackingInformations.Max(pi => pi.AssignedBin) + 1; 71 72 //Get all indexes of items for every bin according to grouping-vector 73 Dictionary<int, List<PackingInformation>> unpackedItemIndexesPerBin = new Dictionary<int, List<PackingInformation>>(); 74 75 for (int i = 0; i < nrOfBins; i++) { 76 unpackedItemIndexesPerBin[i] = solution.PackingInformations 77 .Where(pi => pi.AssignedBin == i) 78 .ToList(); 79 } 80 81 ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>(); 82 var remainingItems = new List<PackingInformation>(); 83 84 //Iterate over all bin-lists 85 for (int binNr = 0; binNr < nrOfBins; binNr++) { 86 //Iterate over the current bin-item-list and find feasible positions in the current bin for each item 87 var unpackedItems = unpackedItemIndexesPerBin[binNr]; 88 for (int i = 0; i < unpackedItems.Count; i++) { 89 var itemIndex = unpackedItems[i].ItemIndex; 90 var item = PackingItemMeasuresParameter.ActualValue[itemIndex]; 91 ThreeDimensionalPacking position = null; 92 93 position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, unpackedItems[i].Rotated); 94 95 if (position == null) { 96 position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, !unpackedItems[i].Rotated); 97 } 98 if (position == null) { 99 remainingItems.Add(unpackedItems[i]); 100 } else { 101 packingPositions[itemIndex] = position; 102 solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).Rotated = position.Rotated; 103 } 104 } 105 } 106 107 //Packing of remaining items 108 //Iterate over all bin-lists 109 for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) { 110 var unpackedItems = new List<PackingInformation>(remainingItems); 111 for (int i = 0; i < unpackedItems.Count; i++) { 112 var itemIndex = unpackedItems[i].ItemIndex; 113 var item = PackingItemMeasuresParameter.ActualValue[itemIndex]; 114 ThreeDimensionalPacking position = null; 115 116 //Look for space in current bin 117 position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, unpackedItems[i].Rotated); 118 119 if (position == null) { 120 position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue, !unpackedItems[i].Rotated); 121 } 122 if (position != null) { 123 packingPositions[itemIndex] = position; 124 remainingItems.Remove(unpackedItems[i]); 125 solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).AssignedBin = binNr; 126 solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex).Rotated = position.Rotated; 127 } 128 } 129 if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) { 130 nrOfBins++; 131 } 132 } 133 134 result.PackingItemPositions = packingPositions; 69 70 result.PackingItemPositions = DeepestBottomLeftFunctions.DeepestLeftBottomPacking (solution, binMeasures, itemMeasures); 135 71 136 72 return result; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/DBL/DeepestBottomLeftPackingSequenceDecoder.cs
r9440 r9495 40 40 [Item("Identical bin, three dimensional, direct permutation decoder", "<Description missing...>")] 41 41 [StorableClass] 42 public class DeepestBottomLeftPackingSequenceDecoder : IdenticalBinPackingSolutionDecoder<42 public class DeepestBottomLeftPackingSequenceDecoder : PackingSolutionDecoder< 43 43 ThreeDimensionalPacking, 44 44 CuboidPackingBin, 45 CuboidPackingItem, 46 PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> { 45 CuboidPackingItem> { 47 46 48 47 public DeepestBottomLeftPackingSequenceDecoder() … … 60 59 61 60 62 p rotected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {61 public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) { 63 62 64 63 var solution = encodedSolution as PackingSequenceEncoding; … … 68 67 new PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>(PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue); 69 68 70 ObservableDictionary<int, ThreeDimensionalPacking> packingPositions = new ObservableDictionary<int, ThreeDimensionalPacking>(); 71 int nrOfBins = 1; 72 for (int i = 0; i < solution.PackingSequence.Length; i++) { 73 var item = PackingItemMeasuresParameter.ActualValue[solution.PackingSequence[i]]; 74 ThreeDimensionalPacking position = null; 75 //Look for space in existing bins 76 for (int binNr = 0; binNr < nrOfBins; binNr++) { 77 position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, binNr, item, packingPositions, PackingItemMeasuresParameter.ActualValue); 78 if (position != null) 79 break; 80 } 81 //Did not find enough space in any of the existing bins => create new bin 82 if (position == null) { 83 nrOfBins++; 84 position = DeepestBottomLeftFunctions.DeepestLeftBottomPosition(PackingBinMeasuresParameter.ActualValue, nrOfBins - 1, item, packingPositions, PackingItemMeasuresParameter.ActualValue); 85 } 86 87 if (position == null) 88 position = new ThreeDimensionalPacking(-1, 0, 0, 0); 89 90 packingPositions[solution.PackingSequence[i]] = position; 91 } 92 93 result.PackingItemPositions = packingPositions; 69 result.PackingItemPositions = DeepestBottomLeftFunctions.DeepestLeftBottomPacking (solution, binMeasures, itemMeasures); 94 70 95 71 return result; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointGroupingVectorDecoder3D.cs
r9440 r9495 41 41 [Item("Identical bin, three dimensional, extreme points based decoder for the GroupingVector encoding.", "<Description missing...>")] 42 42 [StorableClass] 43 public class ExtremePointGroupingVectorDecoder3D : IdenticalBinPackingSolutionDecoder<43 public class ExtremePointGroupingVectorDecoder3D : PackingSolutionDecoder< 44 44 ThreeDimensionalPacking, 45 45 CuboidPackingBin, 46 CuboidPackingItem, 47 PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> { 46 CuboidPackingItem> { 48 47 49 48 public ExtremePointGroupingVectorDecoder3D () … … 68 67 } 69 68 70 p rotected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {69 public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) { 71 70 72 71 var solution = encodedSolution as GroupingVectorEncoding; 73 72 if (solution == null) throw new InvalidOperationException("Encoding is not of type GroupingVector"); 74 73 75 return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);74 return Decode(solution, binMeasures, itemMeasures); 76 75 } 77 76 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointMultiComponentVectorDecoder3D.cs
r9440 r9495 42 42 [Item("Identical bin, three dimensional, extreme points based decoder for the MultiComponentVector encoding.", "<Description missing...>")] 43 43 [StorableClass] 44 public class ExtremePointMultiComponentVectorDecoder3D : IdenticalBinPackingSolutionDecoder<44 public class ExtremePointMultiComponentVectorDecoder3D : PackingSolutionDecoder< 45 45 ThreeDimensionalPacking, 46 46 CuboidPackingBin, 47 CuboidPackingItem, 48 PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> { 47 CuboidPackingItem> { 49 48 50 49 public ExtremePointMultiComponentVectorDecoder3D () … … 69 68 } 70 69 71 p rotected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {70 public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) { 72 71 73 72 var solution = encodedSolution as MultiComponentVectorEncoding; 74 73 if (solution == null) throw new InvalidOperationException("Encoding is not of type MultiComponentVector"); 75 74 76 return Decode(solution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue);75 return Decode(solution, binMeasures, itemMeasures); 77 76 } 78 77 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointPackingSequenceDecoder3D.cs
r9440 r9495 40 40 [Item("Identical bin, three dimensional, extreme points based decoder for the PackingSequence encoding.", "<Description missing...>")] 41 41 [StorableClass] 42 public class ExtremePointPackingSequenceDecoder3D : IdenticalBinPackingSolutionDecoder<42 public class ExtremePointPackingSequenceDecoder3D : PackingSolutionDecoder< 43 43 ThreeDimensionalPacking, 44 44 CuboidPackingBin, 45 CuboidPackingItem, 46 PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>> { 45 CuboidPackingItem> { 47 46 48 47 public ExtremePointPackingSequenceDecoder3D () … … 59 58 60 59 61 p rotected override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution) {60 public override PackingPlan<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem> CreatePackingPlanFromEncoding(IPackingSolutionEncoding encodedSolution, CuboidPackingBin binMeasures, ItemList<CuboidPackingItem> itemMeasures) { 62 61 63 62 var solution = encodedSolution as PackingSequenceEncoding; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Decoders/3D/EP/ExtremePointsFunctions3D.cs
r9473 r9495 9 9 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector; 10 10 using HeuristicLab.Encodings.PackingEncoding.PackingSequence; 11 using HeuristicLab.Encodings.PackingEncoding.Potvin;12 11 using HeuristicLab.Problems.BinPacking.Dimensions; 13 12 using HeuristicLab.Problems.BinPacking.Interfaces; … … 20 19 21 20 22 23 public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(ref PotvinEncoding solution,24 ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) {25 if (!solution.DelimiterInitialized) {26 #region Preperations27 var itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();28 int nrOfBins = 1;29 30 var occupiedPoints = new List<int[, ,]>();31 occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);32 33 HashSet<ThreeDimensionalPacking> extremePoints = new HashSet<ThreeDimensionalPacking>();34 extremePoints.Add(new ThreeDimensionalPacking(0, 0, 0, 0, false));35 #endregion36 37 Dictionary<int, List<int>> itemIndexesForBin = new Dictionary<int, List<int>>();38 itemIndexesForBin[0] = new List<int>();39 40 foreach (int itemIndex in solution.IntVector) {41 var item = itemMeasures[itemIndex];42 extremePoints = OrderExtremePoints(extremePoints, occupiedPoints, binMeasures);43 var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions);44 if (positionFound != null) {45 extremePoints.Remove(positionFound);46 } else {47 positionFound = new ThreeDimensionalPacking(nrOfBins, 0, 0, 0);48 occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);49 itemIndexesForBin[nrOfBins] = new List<int>();50 nrOfBins++;51 }52 itemPositions[itemIndex] = positionFound;53 itemIndexesForBin[positionFound.AssignedBin].Add(itemIndex);54 occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);55 extremePoints = GenerateNewExtremePointsForNewItem(extremePoints, occupiedPoints, item, positionFound, binMeasures);56 }57 List<int> intVector = new List<int>();58 foreach (var indexes in itemIndexesForBin) {59 foreach (var index in indexes.Value) {60 intVector.Add(index);61 }62 intVector.Add(-1);63 }64 intVector.RemoveAt(intVector.Count - 1);65 solution.IntVector = new IntegerVector (intVector.ToArray());66 67 return itemPositions;68 } else {69 #region Preperations70 int nrOfBins = solution.IntVector.Count(i => i.Equals (-1)) + 1;71 72 //Get all indexes of items for every bin according to int vector73 Dictionary<int, List<int>> unpackedItemIndexesPerBin = new Dictionary<int, List<int>>();74 Dictionary<int, HashSet<ThreeDimensionalPacking>> extremePointsForBin = new Dictionary<int, HashSet<ThreeDimensionalPacking>>();75 var occupiedPoints = new List<int[, ,]>();76 77 int binCounter = 0;78 unpackedItemIndexesPerBin[binCounter] = new List<int>();79 for (int i = 0; i < solution.IntVector.Length; i++) {80 if (solution.IntVector[i].Equals(-1)) {81 unpackedItemIndexesPerBin[binCounter++] = new List<int>();82 extremePointsForBin[i] = new HashSet<ThreeDimensionalPacking>();83 extremePointsForBin[i].Add(new ThreeDimensionalPacking(i, 0, 0, 0, false));84 occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);85 } else {86 unpackedItemIndexesPerBin[binCounter].Add(solution.IntVector[i]);87 }88 89 }90 91 92 ObservableDictionary<int, ThreeDimensionalPacking> itemPositions = new ObservableDictionary<int, ThreeDimensionalPacking>();93 var remainingItems = new List<int>();94 95 #endregion Preperations96 97 98 99 //Iterate over all bin-lists100 for (int binNr = 0; binNr < nrOfBins; binNr++) {101 //Iterate over the current bin-item-list and find feasible positions in the current bin for each item102 var unpackedItems = unpackedItemIndexesPerBin[binNr];103 for (int i = 0; i < unpackedItems.Count; i++) {104 var itemIndex = unpackedItems[i];105 var item = itemMeasures[itemIndex];106 107 extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);108 var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);109 if (positionFound != null) {110 extremePointsForBin[binNr].Remove(positionFound);111 itemPositions[itemIndex] = positionFound;112 occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);113 extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);114 } else115 remainingItems.Add(itemIndex);116 }117 }118 119 120 121 //Packing of remaining items122 //Iterate over all bin-lists123 for (int binNr = 0; binNr < nrOfBins && remainingItems.Count > 0; binNr++) {124 var unpackedItems = new List<int>(remainingItems);125 //Iterate over all the remaining items126 for (int i = 0; i < unpackedItems.Count; i++) {127 var itemIndex = unpackedItems[i];128 var item = itemMeasures[itemIndex];129 130 extremePointsForBin[binNr] = OrderExtremePoints(extremePointsForBin[binNr], occupiedPoints, binMeasures);131 var positionFound = FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePointsForBin[binNr], occupiedPoints, itemPositions);132 if (positionFound != null) {133 extremePointsForBin[binNr].Remove(positionFound);134 InsertItemgeneAfterLastItemgeneOfUsedBin(ref solution, itemIndex, binNr);135 itemPositions[itemIndex] = positionFound;136 occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex);137 extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures);138 remainingItems.Remove(itemIndex);139 }140 }141 if (remainingItems.Count > 0 && binNr + 1 >= nrOfBins) {142 extremePointsForBin[nrOfBins] = new HashSet<ThreeDimensionalPacking>();143 extremePointsForBin[nrOfBins].Add(new ThreeDimensionalPacking(nrOfBins, 0, 0, 0, false));144 occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures);145 nrOfBins++;146 }147 }148 149 return itemPositions;150 }151 }152 private static void InsertItemgeneAfterLastItemgeneOfUsedBin(ref PotvinEncoding solution, int itemIndex, int binNr) {153 List<int> temp = new List<int> (solution.IntVector);154 temp.Remove(itemIndex);155 var delimiterIndexes = temp.Select((value, index) => value == -1).Select((value, index) => index);156 int insertionIndex = temp.Count;157 if (binNr < delimiterIndexes.Count()) {158 insertionIndex = delimiterIndexes.ElementAt(binNr);159 }160 temp.Insert(insertionIndex, itemIndex);161 solution.IntVector = new IntegerVector (temp.ToArray());162 }163 164 165 21 public static ObservableDictionary<int, ThreeDimensionalPacking> ExtremePointBasedPacking(ref MultiComponentVectorEncoding solution, 166 22 ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures) { 167 23 168 24 #region Preperations 169 int lowerBound = solution.PackingInformations.Max(x => x.AssignedBin); 170 int nrOfBins = lowerBound + 1; 25 int nrOfBins = solution.NrOfBins; 171 26 172 27 //Get all indexes of items for every bin according to grouping-vector … … 176 31 177 32 for (int i = 0; i < nrOfBins; i++) { 178 unpackedItemIndexesPerBin[i] = solution.PackingInformations 179 .Where(pi => pi.AssignedBin == i) 180 .ToList(); 33 unpackedItemIndexesPerBin[i] = new List<PackingInformation> (solution.PackingInformations[i]); 181 34 182 35 extremePointsForBin[i] = new HashSet<ThreeDimensionalPacking>(); … … 196 49 var unpackedItems = unpackedItemIndexesPerBin[binNr]; 197 50 for (int i = 0; i < unpackedItems.Count; i++) { 198 var itemIndex = unpackedItems[i].ItemI ndex;51 var itemIndex = unpackedItems[i].ItemID; 199 52 var item = itemMeasures[itemIndex]; 200 53 … … 206 59 occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex); 207 60 extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures); 208 } else 61 } else { 209 62 remainingItems.Add(unpackedItems[i]); 63 solution.PackingInformations[binNr].Remove(unpackedItems[i]); 64 } 210 65 } 211 66 } … … 218 73 //Iterate over all the remaining items 219 74 for (int i = 0; i < unpackedItems.Count; i++) { 220 var itemIndex = unpackedItems[i].ItemI ndex;75 var itemIndex = unpackedItems[i].ItemID; 221 76 var item = itemMeasures[itemIndex]; 222 77 … … 227 82 itemPositions[itemIndex] = positionFound; 228 83 occupiedPoints = OccupyPointsForNewItem(occupiedPoints, item, positionFound, itemIndex); 229 extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures); 84 extremePointsForBin[binNr] = GenerateNewExtremePointsForNewItem(extremePointsForBin[binNr], occupiedPoints, item, positionFound, binMeasures); 230 85 remainingItems.Remove(unpackedItems[i]); 231 if (binNr <= lowerBound) { 232 InsertItemgeneAfterLastItemgeneOfUsedBin(ref solution, itemIndex, binNr); 233 } 86 solution.PackingInformations[binNr].Add(unpackedItems[i]); 234 87 } 235 88 } … … 238 91 extremePointsForBin[nrOfBins].Add(new ThreeDimensionalPacking(nrOfBins, 0, 0, 0, false)); 239 92 occupiedPoints = IncreaseBinCountForOccupiedPoints(occupiedPoints, binMeasures); 93 solution.PackingInformations[nrOfBins] = new ItemList<PackingInformation>(); 240 94 nrOfBins++; 241 95 } … … 243 97 244 98 return itemPositions; 245 }246 private static void InsertItemgeneAfterLastItemgeneOfUsedBin(ref MultiComponentVectorEncoding solution, int itemIndex, int binNr) {247 var itemgene = solution.PackingInformations.Find(pi => pi.ItemIndex == itemIndex);248 solution.PackingInformations.Remove (itemgene);249 itemgene.AssignedBin = binNr;250 int targetIndex = solution.PackingInformations.FindLastIndex(pi => pi.AssignedBin == binNr);251 solution.PackingInformations.Insert(targetIndex + 1, itemgene);252 99 } 253 100 … … 370 217 371 218 372 p rivatestatic ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures,219 public static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures, 373 220 HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions) { 374 221 return FindExtremePointForItem(itemIndex, itemMeasures, binMeasures, extremePoints, occupiedPoints, itemPositions, false); 375 222 } 376 p rivatestatic ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures,223 public static ThreeDimensionalPacking FindExtremePointForItem(int itemIndex, ItemList<CuboidPackingItem> itemMeasures, CuboidPackingBin binMeasures, 377 224 HashSet<ThreeDimensionalPacking> extremePoints, List<int[,,]> occupiedPoints, ObservableDictionary<int, ThreeDimensionalPacking> itemPositions, bool rotated) { 378 225 … … 397 244 return null; 398 245 } 399 p rivatestatic List<int[, ,]> IncreaseBinCountForOccupiedPoints(List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {246 public static List<int[, ,]> IncreaseBinCountForOccupiedPoints(List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) { 400 247 occupiedPoints.Add(new int[binMeasures.Width, binMeasures.Height, binMeasures.Depth]); 401 248 int lastIndex = occupiedPoints.Count - 1; … … 409 256 return occupiedPoints; 410 257 } 411 p rivatestatic bool IsStaticStable(int[, ,] occupiedPoints, CuboidPackingItem item, ThreeDimensionalPacking ep) {258 public static bool IsStaticStable(int[, ,] occupiedPoints, CuboidPackingItem item, ThreeDimensionalPacking ep) { 412 259 //Static stability is given, if item is placed on the ground 413 260 if (ep.Y == 0) … … 433 280 return false; 434 281 } 435 p rivatestatic List<int[, ,]> OccupyPointsForNewItem(List<int[, ,]> occupiedPoints, CuboidPackingItem newItem, ThreeDimensionalPacking position, int itemIndex) {282 public static List<int[, ,]> OccupyPointsForNewItem(List<int[, ,]> occupiedPoints, CuboidPackingItem newItem, ThreeDimensionalPacking position, int itemIndex) { 436 283 int width = position.Rotated ? newItem.Depth : newItem.Width; 437 284 int depth = position.Rotated ? newItem.Width : newItem.Depth; … … 445 292 return occupiedPoints; 446 293 } 447 p rivatestatic HashSet<ThreeDimensionalPacking> GenerateNewExtremePointsForNewItem(HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints,294 public static HashSet<ThreeDimensionalPacking> GenerateNewExtremePointsForNewItem(HashSet<ThreeDimensionalPacking> extremePoints, List<int[, ,]> occupiedPoints, 448 295 CuboidPackingItem newItem, ThreeDimensionalPacking position, CuboidPackingBin binMeasures) { 449 296 int currentBin = position.AssignedBin; … … 518 365 519 366 520 p rivatestatic HashSet<ThreeDimensionalPacking> OrderExtremePoints(HashSet<ThreeDimensionalPacking> hashSet, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {367 public static HashSet<ThreeDimensionalPacking> OrderExtremePoints(HashSet<ThreeDimensionalPacking> hashSet, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) { 521 368 return new HashSet<ThreeDimensionalPacking>(hashSet.OrderBy(ep => ep.AssignedBin).ThenBy(ep => ep.Z).ThenBy(ep => ep.X).ThenBy(ep => ep.Y).ThenBy(ep => ShortestPossibleSideFromEP(ep, occupiedPoints, binMeasures))); 522 369 } 523 p rivatestatic int ShortestPossibleSideFromEP(ThreeDimensionalPacking ep, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) {370 public static int ShortestPossibleSideFromEP(ThreeDimensionalPacking ep, List<int[, ,]> occupiedPoints, CuboidPackingBin binMeasures) { 524 371 int shortestSide = int.MaxValue; 525 372 -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMove.cs
r9440 r9495 22 22 using HeuristicLab.Common; 23 23 using HeuristicLab.Core; 24 using HeuristicLab.Encodings.IntegerVectorEncoding; 24 25 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable; 26 using HeuristicLab.Problems.BinPacking.Interfaces; 25 27 26 28 namespace HeuristicLab.Encodings.PackingEncoding.GroupingVector { 27 29 [Item("Single Grouping Move", "A move on a grouping vector that is specified by a single group-assignment-index.")] 28 30 [StorableClass] 29 public class SingleGroupingMove : Item 31 public class SingleGroupingMove : Item, IPackingMove{ 30 32 [Storable] 31 33 public int Index { get; protected set; } … … 53 55 return new SingleGroupingMove(this, cloner); 54 56 } 57 58 public IPackingSolutionEncoding GetSolutionAfterMove() { 59 GroupingVectorEncoding newSolution = new GroupingVectorEncoding(); 60 newSolution.GroupingVector = new IntegerVector(GroupingVector.GroupingVector); 61 newSolution.GroupingVector[Index] = NewGroup; 62 return newSolution; 63 } 55 64 } 56 65 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveGenerator.cs
r9440 r9495 38 38 get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; } 39 39 } 40 public ILookupParameter< SingleGroupingMove> SingleGroupingMoveParameter {41 get { return (LookupParameter< SingleGroupingMove>)Parameters["SingleGroupingMove"]; }40 public ILookupParameter<IPackingMove> PackingMoveParameter { 41 get { return (LookupParameter<IPackingMove>)Parameters["PackingMove"]; } 42 42 } 43 43 protected ScopeParameter CurrentScopeParameter { … … 51 51 : base() { 52 52 Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The grouping vector for which moves should be generated.")); 53 Parameters.Add(new LookupParameter< SingleGroupingMove>("SingleGroupingMove", "The moves that should be generated in subscopes."));53 Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The moves that should be generated in subscopes.")); 54 54 Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes.")); 55 55 } … … 61 61 for (int i = 0; i < moveScopes.Length; i++) { 62 62 moveScopes[i] = new Scope(i.ToString()); 63 moveScopes[i].Variables.Add(new Variable( SingleGroupingMoveParameter.ActualName, moves[i]));63 moveScopes[i].Variables.Add(new Variable(PackingMoveParameter.ActualName, moves[i])); 64 64 } 65 65 CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes); -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveHardTabuCriterion.cs
r9440 r9495 38 38 get { return false; } 39 39 } 40 public ILookupParameter< SingleGroupingMove> SingleGroupingMoveParameter {41 get { return (ILookupParameter< SingleGroupingMove>)Parameters["SingleGroupingMove"]; }40 public ILookupParameter<IPackingMove> PackingMoveParameter { 41 get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; } 42 42 } 43 43 public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter { … … 65 65 public SingleGroupingMoveHardTabuCriterion() 66 66 : base() { 67 Parameters.Add(new LookupParameter< SingleGroupingMove>("SingleGroupingMove", "The move to evaluate."));67 Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate.")); 68 68 Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution to evaluate.")); 69 69 Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu.")); … … 80 80 public override IOperation Apply() { 81 81 ItemList<IItem> tabuList = TabuListParameter.ActualValue; 82 SingleGroupingMove move = SingleGroupingMoveParameter.ActualValue;82 SingleGroupingMove move = PackingMoveParameter.ActualValue as SingleGroupingMove; 83 83 GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue; 84 84 int length = groupingVector.GroupingVector.Length; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveMaker.cs
r9440 r9495 42 42 get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; } 43 43 } 44 public ILookupParameter< SingleGroupingMove> SingleGroupingMoveParameter {45 get { return (ILookupParameter< SingleGroupingMove>)Parameters["SingleGroupingMove"]; }44 public ILookupParameter<IPackingMove> PackingMoveParameter { 45 get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; } 46 46 } 47 47 public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter { 48 48 get { return (ILookupParameter<GroupingVectorEncoding>)Parameters["GroupingVector"]; } 49 } 50 public ILookupParameter<IPackingPlan> PackingPlanParameter { 51 get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlan"]; } 52 } 53 public ILookupParameter<IPackingPlan> PackingPlanAfterMoveParameter { 54 get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlanAfterMove"]; } 49 55 } 50 56 … … 55 61 : base() { 56 62 Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution.")); 57 Parameters.Add(new LookupParameter< SingleGroupingMove>("SingleGroupingMove", "The move to evaluate."));63 Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate.")); 58 64 Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The relative quality of the move.")); 59 65 Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution as grouping vector.")); 66 Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlan", "The currently best performing, decoded bin-packing solution represented as generalized packing-plan.")); 67 Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlanAfterMove", "The moved and decoded bin-packing solution represented as generalized packing-plan.")); 60 68 } 61 69 … … 65 73 66 74 public override IOperation Apply() { 67 SingleGroupingMove move = SingleGroupingMoveParameter.ActualValue;75 IPackingMove move = PackingMoveParameter.ActualValue; 68 76 GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue; 69 77 DoubleValue moveQuality = MoveQualityParameter.ActualValue; 70 78 DoubleValue quality = QualityParameter.ActualValue; 71 79 72 groupingVector.GroupingVector[move.Index] = move.NewGroup; 80 groupingVector.GroupingVector = (move.GetSolutionAfterMove() as GroupingVectorEncoding).GroupingVector; 81 PackingPlanParameter.ActualValue = PackingPlanAfterMoveParameter.ActualValue; 73 82 74 83 quality.Value = moveQuality.Value; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingMoveSoftTabuCriterion.cs
r9440 r9495 38 38 get { return false; } 39 39 } 40 public ILookupParameter< SingleGroupingMove> SingleGroupingMoveParameter {41 get { return (ILookupParameter< SingleGroupingMove>)Parameters["SingleGroupingMove"]; }40 public ILookupParameter<IPackingMove> PackingMoveParameter { 41 get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; } 42 42 } 43 43 public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter { … … 65 65 public SingleGroupingMoveSoftTabuCriterion() 66 66 : base() { 67 Parameters.Add(new LookupParameter< SingleGroupingMove>("SingleGroupingMove", "The move to evaluate."));67 Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate.")); 68 68 Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution to evaluate.")); 69 69 Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu.")); … … 80 80 public override IOperation Apply() { 81 81 ItemList<IItem> tabuList = TabuListParameter.ActualValue; 82 SingleGroupingMove move = SingleGroupingMoveParameter.ActualValue;82 SingleGroupingMove move = PackingMoveParameter.ActualValue as SingleGroupingMove; 83 83 GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue; 84 84 int length = groupingVector.GroupingVector.Length; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/GroupingVector/Moves/SingleGrouping/SingleGroupingTabuMaker.cs
r9440 r9495 32 32 [StorableClass] 33 33 public class SingleGroupingTabuMaker : TabuMaker, IGroupingVectorMoveOperator{ 34 public ILookupParameter< SingleGroupingMove> SingleGroupingMoveParameter {35 get { return (ILookupParameter< SingleGroupingMove>)Parameters["SingleGroupingMove"]; }34 public ILookupParameter<IPackingMove> PackingMoveParameter { 35 get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; } 36 36 } 37 37 public ILookupParameter<GroupingVectorEncoding> GroupingVectorParameter { … … 44 44 public SingleGroupingTabuMaker() 45 45 : base() { 46 Parameters.Add(new LookupParameter<SingleGroupingMove>("SingleGroupingMove", "The move to evaluate."));46 Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate.")); 47 47 Parameters.Add(new LookupParameter<GroupingVectorEncoding>("GroupingVector", "The solution to evaluate.")); 48 48 } … … 53 53 54 54 protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) { 55 SingleGroupingMove move = SingleGroupingMoveParameter.ActualValue;55 IPackingMove move = PackingMoveParameter.ActualValue; 56 56 GroupingVectorEncoding groupingVector = GroupingVectorParameter.ActualValue; 57 57 double baseQuality = moveQuality; 58 58 if (maximization && quality > moveQuality || !maximization && quality < moveQuality) 59 59 baseQuality = quality; // we make an uphill move, the lower bound is the solution quality 60 61 return new SingleGroupingMoveAttribute (move.Index, move.NewGroup, baseQuality); 60 61 var sgMove = move as SingleGroupingMove; 62 if (sgMove != null) 63 return new SingleGroupingMoveAttribute(sgMove.Index, sgMove.NewGroup, baseQuality); 64 else 65 return move.GetSolutionAfterMove(); 62 66 } 63 67 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/ChangePositionMoveAttribute.cs
r9473 r9495 29 29 public class ChangePositionMoveAttribute : MultiComponentVectorMoveAttribute { 30 30 [Storable] 31 public int Index { get; protected set; } 31 public int AffectedGroup { get; protected set; } 32 [Storable] 33 public int Index { get; protected set; } 34 [Storable] 35 public int ItemID { get; protected set; } 32 36 [Storable] 33 37 public int TargetIndex { get; protected set; } 34 [Storable]35 public int ItemIndex { get; protected set; }36 38 37 39 [StorableConstructor] … … 41 43 this.Index = original.Index; 42 44 this.TargetIndex = original.TargetIndex; 43 this.ItemI ndex = original.ItemIndex;45 this.ItemID = original.ItemID; 44 46 } 45 public ChangePositionMoveAttribute() : this(-1, -1, -1, -1 ) { }46 public ChangePositionMoveAttribute(int index, int targetIndex, int itemIndex, double moveQuality)47 public ChangePositionMoveAttribute() : this(-1, -1, -1, -1, -1) { } 48 public ChangePositionMoveAttribute(int affectedGroup, int index, int itemID, int targetIndex, double moveQuality) 47 49 : base(moveQuality) { 50 AffectedGroup = affectedGroup; 48 51 Index = index; 49 52 TargetIndex = targetIndex; 50 ItemI ndex = itemIndex;53 ItemID = itemID; 51 54 } 52 55 -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/MCVTripleMoveAttribute.cs
r9473 r9495 31 31 public int Index { get; protected set; } 32 32 [Storable] 33 public int ItemI ndex{ get; protected set; }33 public int ItemID { get; protected set; } 34 34 [Storable] 35 35 public int TargetIndex { get; protected set; } 36 36 [Storable] 37 public bool RotationBefore { get; protected set; } 38 [Storable] 39 public bool RotationAfter { get; protected set; } 37 public bool Rotation { get; protected set; } 40 38 [Storable] 41 39 public int GroupBefore { get; protected set; } … … 49 47 this.Index = original.Index; 50 48 this.TargetIndex = original.TargetIndex; 51 this.ItemIndex = original.ItemIndex; 52 this.RotationAfter = original.RotationAfter; 53 this.RotationBefore = original.RotationBefore; 49 this.ItemID = original.ItemID; 50 this.Rotation = original.Rotation; 54 51 this.GroupBefore = original.GroupBefore; 55 52 this.GroupAfter = original.GroupAfter; 56 53 } 57 public MCVTripleMoveAttribute() : this(-1, -1, -1, false, false,-1, -1, -1) { }58 public MCVTripleMoveAttribute(int index, int targetIndex, int itemI ndex, bool rotationBefore, bool rotationAfter, int groupBefore, int groupAfter, double moveQuality)54 public MCVTripleMoveAttribute() : this(-1, -1, -1, false, -1, -1, -1) { } 55 public MCVTripleMoveAttribute(int index, int targetIndex, int itemID, bool rotation, int groupBefore, int groupAfter, double moveQuality) 59 56 : base(moveQuality) { 60 57 Index = index; 61 58 TargetIndex = targetIndex; 62 ItemIndex = itemIndex; 63 RotationBefore = rotationBefore; 64 RotationAfter = rotationAfter; 59 ItemID = itemID; 60 Rotation = rotation; 65 61 GroupBefore = groupBefore; 66 62 GroupAfter = groupAfter; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SingleGroupingMoveAttribute.cs
r9473 r9495 27 27 [Item("SingleGroupingMoveAttribute", "Specifies the tabu attributes for a single grouping move on an multi component vector.")] 28 28 [StorableClass] 29 public class SingleGroupingMoveAttribute : MultiComponentVectorMoveAttribute { 29 public class SingleGroupingMoveAttribute : MultiComponentVectorMoveAttribute { 30 [Storable] 31 public int OldGroup { get; protected set; } 30 32 [Storable] 31 33 public int Index { get; protected set; } 32 34 [Storable] 33 public int AssignedBin { get; protected set; } 35 public int ItemID { get; protected set; } 36 [Storable] 37 public int NewGroup { get; protected set; } 34 38 35 39 [StorableConstructor] 36 40 protected SingleGroupingMoveAttribute(bool deserializing) : base(deserializing) { } 37 41 protected SingleGroupingMoveAttribute(SingleGroupingMoveAttribute original, Cloner cloner) 38 : base(original, cloner) { 42 : base(original, cloner) { 43 this.OldGroup = original.OldGroup; 39 44 this.Index = original.Index; 40 this.AssignedBin = original.AssignedBin; 45 this.ItemID = original.ItemID; 46 this.NewGroup = original.NewGroup; 41 47 } 42 public SingleGroupingMoveAttribute() : this(-1, -1, -1 ) { }43 public SingleGroupingMoveAttribute(int index, int assignedBin, double moveQuality)48 public SingleGroupingMoveAttribute() : this(-1, -1, -1, -1, -1) { } 49 public SingleGroupingMoveAttribute(int oldGroup, int index, int itemID, int newGroup, double moveQuality) 44 50 : base(moveQuality) { 51 OldGroup = oldGroup; 45 52 Index = index; 46 AssignedBin = assignedBin; 53 ItemID = itemID; 54 NewGroup = newGroup; 47 55 } 48 56 -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SingleItemRotationMoveAttribute.cs
r9440 r9495 29 29 public class SingleItemRotationMoveAttribute : MultiComponentVectorMoveAttribute { 30 30 [Storable] 31 public int AffectedGroup { get; protected set; } 32 [Storable] 33 public int Index { get; protected set; } 34 [Storable] 31 35 public int ItemIndex { get; protected set; } 32 36 [Storable] … … 37 41 protected SingleItemRotationMoveAttribute(SingleItemRotationMoveAttribute original, Cloner cloner) 38 42 : base(original, cloner) { 43 this.AffectedGroup = original.AffectedGroup; 44 this.Index = original.Index; 39 45 this.ItemIndex = original.ItemIndex; 40 46 this.ItemRotation = original.ItemRotation; 41 47 } 42 public SingleItemRotationMoveAttribute() : this(-1, false, -1) { }43 public SingleItemRotationMoveAttribute(int itemIndex, bool itemRotation, double moveQuality)48 public SingleItemRotationMoveAttribute() : this(-1, -1, -1, false, -1) { } 49 public SingleItemRotationMoveAttribute(int affectedGroup, int index, int itemIndex, bool itemRotation, double moveQuality) 44 50 : base(moveQuality) { 51 AffectedGroup = affectedGroup; 52 Index = index; 45 53 ItemIndex = itemIndex; 46 54 ItemRotation = itemRotation; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Attributes/SwapPositionMoveAttribute.cs
r9473 r9495 29 29 public class SwapPositionMoveAttribute : MultiComponentVectorMoveAttribute { 30 30 [Storable] 31 public int AffectedGroup { get; protected set; } 32 [Storable] 31 33 public int Index1 { get; protected set; } 32 34 [Storable] 33 35 public int Index2 { get; protected set; } 34 36 [Storable] 35 public int ItemI ndex1 { get; protected set; }37 public int ItemID1 { get; protected set; } 36 38 [Storable] 37 public int ItemI ndex2 { get; protected set; }39 public int ItemID2 { get; protected set; } 38 40 39 41 [StorableConstructor] … … 41 43 protected SwapPositionMoveAttribute(SwapPositionMoveAttribute original, Cloner cloner) 42 44 : base(original, cloner) { 45 this.AffectedGroup = original.AffectedGroup; 43 46 this.Index1 = original.Index1; 44 47 this.Index2 = original.Index2; 45 this.ItemI ndex1 = original.ItemIndex1;46 this.ItemI ndex2 = original.ItemIndex2;48 this.ItemID1 = original.ItemID1; 49 this.ItemID2 = original.ItemID2; 47 50 } 48 public SwapPositionMoveAttribute() : this(-1, -1, -1, -1, -1 ) { }49 public SwapPositionMoveAttribute(int index1, int index2, int itemIndex1, int itemIndex2, double moveQuality)51 public SwapPositionMoveAttribute() : this(-1, -1, -1, -1, -1, -1) { } 52 public SwapPositionMoveAttribute(int affectedGroup, int index1, int index2, int itemID1, int itemID2, double moveQuality) 50 53 : base(moveQuality) { 54 AffectedGroup = affectedGroup; 51 55 Index1 = index1; 52 56 Index2 = index2; 53 ItemI ndex1 = itemIndex1;54 ItemI ndex2 = itemIndex2;57 ItemID1 = itemID1; 58 ItemID2 = itemID2; 55 59 } 56 60 -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/ExhaustiveMCVTripleMoveGenerator.cs
r9473 r9495 40 40 } 41 41 42 public static IEnumerable<MultiComponentVectorMove> GenerateMCVTripleMoves(MultiComponentVectorEncoding mcv) { 43 int nrOfBins = 0; 44 foreach (var pi in mcv.PackingInformations) { 45 if (pi.AssignedBin > nrOfBins) 46 nrOfBins = pi.AssignedBin; 47 } 48 nrOfBins++; 49 Dictionary<int, List<int>> indexesPerBin = new Dictionary<int, List<int>>(); 50 for (int i = 0; i < mcv.PackingInformations.Count; i++) { 51 int currentBin = mcv.PackingInformations[i].AssignedBin; 52 if (!indexesPerBin.ContainsKey(currentBin)) 53 indexesPerBin[currentBin] = new List<int>(); 54 indexesPerBin[currentBin].Add(i); 55 } 56 57 for (int index = 0; index < mcv.PackingInformations.Count; index++) { 58 for (int group = 0; group < nrOfBins; group++) { 59 foreach (int targetIndex in indexesPerBin[group]) { 60 yield return new MCVTripleMove(index, false, group, targetIndex, mcv); 61 yield return new MCVTripleMove(index, true, group, targetIndex, mcv); 62 } 63 } 64 } 42 public static IEnumerable<MultiComponentVectorMove> GenerateMCVTripleMoves(MultiComponentVectorEncoding mcv) { 43 foreach (var oldGroup in mcv.PackingInformations) 44 for (int sourceIndex = 0; sourceIndex < oldGroup.Value.Count; sourceIndex++) 45 foreach (var newGroup in mcv.PackingInformations) 46 for (int targetIndex = 0; targetIndex < newGroup.Value.Count; targetIndex++) { 47 yield return new MCVTripleMove(oldGroup.Key, newGroup.Key, sourceIndex, targetIndex, false, mcv); 48 yield return new MCVTripleMove(oldGroup.Key, newGroup.Key, sourceIndex, targetIndex, true, mcv); 49 } 65 50 } 66 51 -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/ChangePositionMove.cs
r9473 r9495 24 24 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector; 25 25 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable; 26 using HeuristicLab.Problems.BinPacking.Interfaces; 26 27 27 28 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector { … … 29 30 [StorableClass] 30 31 public class ChangePositionMove : MultiComponentVectorMove { 32 [Storable] 33 public int AffectedGroup { get; protected set; } 31 34 [Storable] 32 35 public int Index { get; protected set; } … … 38 41 protected ChangePositionMove(ChangePositionMove original, Cloner cloner) 39 42 : base(original, cloner) { 43 this.AffectedGroup = original.AffectedGroup; 40 44 this.Index = original.Index; 41 45 this.TargetIndex = original.TargetIndex; 42 46 } 43 public ChangePositionMove(int index, int targetIndex, MultiComponentVectorEncoding multiComponentVector)47 public ChangePositionMove(int affectedBin, int index, int targetIndex, MultiComponentVectorEncoding multiComponentVector) 44 48 : base(multiComponentVector) { 49 AffectedGroup = affectedBin; 45 50 Index = index; 46 51 TargetIndex = targetIndex; … … 51 56 } 52 57 53 public override MultiComponentVectorEncoding GetVectorAfterMove() {54 return GetVectorAfterMove(MultiComponentVector, Index, TargetIndex);58 public override IPackingSolutionEncoding GetSolutionAfterMove() { 59 return GetVectorAfterMove(MultiComponentVector, AffectedGroup, Index, TargetIndex); 55 60 } 56 public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int index, int targetIndex) {61 public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int affectedBin, int index, int targetIndex) { 57 62 var result = multiComponentVector.Clone(new Cloner()) as MultiComponentVectorEncoding; 58 var aux = result.PackingInformations[ index];59 result.PackingInformations .RemoveAt(index);60 result.PackingInformations .Insert(targetIndex, aux);63 var aux = result.PackingInformations[affectedBin][index]; 64 result.PackingInformations[affectedBin].Remove(aux); 65 result.PackingInformations[affectedBin].Insert(targetIndex, aux); 61 66 return result; 62 67 } … … 67 72 68 73 public override string ToString() { 69 return "PM(i=" + Index + ",ti=" + TargetIndex + ")"; 74 return "PM(g=" + AffectedGroup + ",i=" + Index + ",ti=" + TargetIndex + ")"; 75 } 76 77 public override MultiComponentVectorMoveAttribute GetAttribute(double quality) { 78 return new ChangePositionMoveAttribute(AffectedGroup, Index, 79 MultiComponentVector.PackingInformations[AffectedGroup][Index].ItemID, 80 TargetIndex, quality); 81 } 82 83 public override bool BelongsToAttribute(MultiComponentVectorMoveAttribute attribute, bool hardCriterion) { 84 ChangePositionMoveAttribute actualAttribute = attribute as ChangePositionMoveAttribute; 85 if (actualAttribute != null) { 86 if (hardCriterion) { 87 if (Index == actualAttribute.Index 88 || TargetIndex == actualAttribute.TargetIndex 89 || MultiComponentVector.PackingInformations[AffectedGroup][Index].ItemID == actualAttribute.ItemID) 90 return true; 91 } else { 92 if (Index == actualAttribute.Index 93 && TargetIndex == actualAttribute.TargetIndex 94 && MultiComponentVector.PackingInformations[AffectedGroup][Index].ItemID == actualAttribute.ItemID) 95 return true; 96 } 97 } 98 99 return false; 70 100 } 71 101 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/MCVTripleMove.cs
r9473 r9495 24 24 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector; 25 25 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable; 26 using HeuristicLab.Problems.BinPacking.Interfaces; 26 27 27 28 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector { 28 29 [Item("MCVTripleMove", "A move on a multi component vector that is specified by a rotation-value, two indexes and a groupNr.")] 29 30 [StorableClass] 30 public class MCVTripleMove : MultiComponentVectorMove { 31 public class MCVTripleMove : MultiComponentVectorMove { 31 32 [Storable] 32 public int Index { get; protected set; } 33 public int OldGroup { get; protected set; } 34 [Storable] 35 public int NewGroup { get; protected set; } 36 [Storable] 37 public int Index { get; protected set; } 38 [Storable] 39 public int TargetIndex { get; protected set; } 33 40 [Storable] 34 41 public bool Rotation { get; protected set; } 35 [Storable]36 public int Group { get; protected set; }37 [Storable]38 public int TargetIndex { get; protected set; }39 42 40 43 [StorableConstructor] 41 44 protected MCVTripleMove(bool deserializing) : base(deserializing) { } 42 45 protected MCVTripleMove(MCVTripleMove original, Cloner cloner) 43 : base(original, cloner) { 44 this.Index = original.Index; 46 : base(original, cloner) { 47 this.OldGroup = original.OldGroup; 48 this.NewGroup = original.NewGroup; 49 this.Index = original.Index; 50 this.TargetIndex = original.TargetIndex; 45 51 this.Rotation = original.Rotation; 46 this.Group = original.Group;47 this.TargetIndex = original.TargetIndex;48 52 } 49 public MCVTripleMove(int index, bool rotation, int group, int targetIndex, MultiComponentVectorEncoding multiComponentVector) 50 : base(multiComponentVector) { 51 Index = index; 53 public MCVTripleMove(int oldGroup, int newGroup, int index, int targetIndex, bool rotation, MultiComponentVectorEncoding multiComponentVector) 54 : base(multiComponentVector) { 55 OldGroup = oldGroup; 56 NewGroup = newGroup; 57 Index = index; 58 TargetIndex = targetIndex; 52 59 Rotation = rotation; 53 Group = group;54 TargetIndex = targetIndex;55 60 } 56 61 … … 59 64 } 60 65 61 public override MultiComponentVectorEncoding GetVectorAfterMove() {62 var result = MultiComponentVector ;66 public override IPackingSolutionEncoding GetSolutionAfterMove() { 67 var result = MultiComponentVector.Clone(new Cloner()) as MultiComponentVectorEncoding; 63 68 if (Rotation) 64 result = SingleItemRotationMove.GetVectorAfterMove(MultiComponentVector, Index); 65 if (!MultiComponentVector.PackingInformations[Index].AssignedBin.Equals(Group)) 66 result = SingleGroupingMove.GetVectorAfterMove(result, Index, Group); 67 if (!Index.Equals(TargetIndex)) 68 result = ChangePositionMove.GetVectorAfterMove(result, Index, TargetIndex); 69 result = SingleItemRotationMove.GetVectorAfterMove(result, OldGroup, Index); 70 if (!OldGroup.Equals(NewGroup)) { 71 result = SingleGroupingMove.GetVectorAfterMove(result, OldGroup, Index, NewGroup); 72 int newIndex = result.PackingInformations[NewGroup].Count - 1; 73 if (!newIndex.Equals(TargetIndex)) 74 result = ChangePositionMove.GetVectorAfterMove(result, NewGroup, newIndex, TargetIndex); 75 } else if (!Index.Equals(TargetIndex)) 76 result = ChangePositionMove.GetVectorAfterMove(result, NewGroup, Index, TargetIndex); 69 77 return result; 70 78 } … … 75 83 76 84 public override string ToString() { 77 return "TM(i=" + Index + ",r=" + Rotation + ",g=" + Group + ",ti=" + TargetIndex + ")"; 85 return "TM(og=" + OldGroup + ",ng=" + NewGroup + ",i=" + Index + ",ti=" + TargetIndex + ",r=" + Rotation + ")"; 86 } 87 88 89 public override MultiComponentVectorMoveAttribute GetAttribute(double quality) { 90 return new MCVTripleMoveAttribute(Index, TargetIndex, MultiComponentVector.PackingInformations[OldGroup][Index].ItemID, 91 Rotation, OldGroup, NewGroup, quality); 92 } 93 94 public override bool BelongsToAttribute(MultiComponentVectorMoveAttribute attribute, bool hardCriterion) { 95 MCVTripleMoveAttribute actualAttribute = attribute as MCVTripleMoveAttribute; 96 if (actualAttribute != null) { 97 if (hardCriterion) { 98 if ((Index == actualAttribute.Index && TargetIndex == actualAttribute.TargetIndex) 99 || MultiComponentVector.PackingInformations[OldGroup][Index].ItemID == actualAttribute.ItemID 100 || (OldGroup == actualAttribute.GroupBefore && NewGroup == actualAttribute.GroupAfter)) 101 return true; 102 } else { 103 if ((Index == actualAttribute.Index && TargetIndex == actualAttribute.TargetIndex) 104 && MultiComponentVector.PackingInformations[OldGroup][Index].ItemID == actualAttribute.ItemID 105 && Rotation == actualAttribute.Rotation 106 && (OldGroup == actualAttribute.GroupBefore && NewGroup == actualAttribute.GroupAfter)) 107 return true; 108 } 109 } 110 return false; 78 111 } 79 112 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/MultiComponentVectorMove.cs
r9440 r9495 25 25 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector; 26 26 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable; 27 using HeuristicLab.Problems.BinPacking.Interfaces; 27 28 28 29 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector { 29 30 [Item("MultiComponentVectorMove", "An abstract move for a multi component vector encoded solution.")] 30 31 [StorableClass] 31 public abstract class MultiComponentVectorMove : Item {32 public abstract class MultiComponentVectorMove : Item, IPackingMove { 32 33 [Storable] 33 34 public MultiComponentVectorEncoding MultiComponentVector { get; protected set; } … … 45 46 } 46 47 47 public abstract MultiComponentVectorEncoding GetVectorAfterMove();48 public abstract IPackingSolutionEncoding GetSolutionAfterMove(); 48 49 public abstract Type GetMoveAttributeType(); 50 public abstract MultiComponentVectorMoveAttribute GetAttribute(double quality); 51 public abstract bool BelongsToAttribute (MultiComponentVectorMoveAttribute attribute, bool hardCriterion); 49 52 } 50 53 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SingleGroupingMove.cs
r9473 r9495 24 24 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector; 25 25 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable; 26 using HeuristicLab.Problems.BinPacking.Interfaces; 26 27 27 28 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector { 28 29 [Item("SingleGroupingMove", "A move on a multi component vector that is specified by a single index and a new grouping-value. The grouping of the item on the specified index is changed to the new value.")] 29 30 [StorableClass] 30 public class SingleGroupingMove : MultiComponentVectorMove { 31 public class SingleGroupingMove : MultiComponentVectorMove { 32 [Storable] 33 public int OldGroup { get; protected set; } 31 34 [Storable] 32 35 public int Index { get; protected set; } … … 38 41 protected SingleGroupingMove(SingleGroupingMove original, Cloner cloner) 39 42 : base(original, cloner) { 43 this.OldGroup = original.OldGroup; 40 44 this.Index = original.Index; 41 45 this.NewGroup = original.NewGroup; 42 46 } 43 public SingleGroupingMove(int index, int newGroup, MultiComponentVectorEncoding multiComponentVector)47 public SingleGroupingMove(int oldGroup, int index, int newGroup, MultiComponentVectorEncoding multiComponentVector) 44 48 : base(multiComponentVector) { 45 Index = index; 46 NewGroup = newGroup; 49 OldGroup = oldGroup; 50 Index = index; 51 NewGroup = newGroup; 47 52 } 48 53 … … 51 56 } 52 57 53 public override MultiComponentVectorEncoding GetVectorAfterMove() {54 return GetVectorAfterMove(MultiComponentVector, Index, NewGroup);58 public override IPackingSolutionEncoding GetSolutionAfterMove() { 59 return GetVectorAfterMove(MultiComponentVector, OldGroup, Index, NewGroup); 55 60 } 56 public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding originalSolution, int itemIndex, int binNr) {61 public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding originalSolution, int oldBin, int index, int newBin) { 57 62 var solution = originalSolution.Clone (new Cloner()) as MultiComponentVectorEncoding; 58 var itemgene = solution.PackingInformations[itemIndex]; 59 solution.PackingInformations.Remove(itemgene); 60 itemgene.AssignedBin = binNr; 61 int targetIndex = solution.PackingInformations.FindLastIndex(pi => pi.AssignedBin == binNr); 62 solution.PackingInformations.Insert(targetIndex + 1, itemgene); 63 //solution.PackingInformations[itemIndex].AssignedBin = binNr; 63 var itemgene = solution.PackingInformations[oldBin][index]; 64 solution.PackingInformations[oldBin].Remove(itemgene); 65 solution.PackingInformations[newBin].Add(itemgene); 64 66 return solution; 65 67 } … … 70 72 71 73 public override string ToString() { 72 return "GM(i="+Index+",g="+NewGroup+")"; 74 return "GM(og"+OldGroup+",i="+Index+",ng="+NewGroup+")"; 75 } 76 77 public override MultiComponentVectorMoveAttribute GetAttribute(double quality) { 78 return new SingleGroupingMoveAttribute(OldGroup, Index, 79 MultiComponentVector.PackingInformations[OldGroup][Index].ItemID, NewGroup, quality); 80 } 81 82 public override bool BelongsToAttribute(MultiComponentVectorMoveAttribute attribute, bool hardCriterion) { 83 SingleGroupingMoveAttribute actualAttribute = attribute as SingleGroupingMoveAttribute; 84 if (actualAttribute != null) { 85 if (hardCriterion) { 86 if (MultiComponentVector.PackingInformations[OldGroup][Index].ItemID == actualAttribute.ItemID 87 || NewGroup == actualAttribute.NewGroup) 88 return true; 89 } else { 90 if (MultiComponentVector.PackingInformations[OldGroup][Index].ItemID == actualAttribute.ItemID 91 && NewGroup == actualAttribute.NewGroup) 92 return true; 93 } 94 } 95 return false; 73 96 } 74 97 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SingleItemRotationMove.cs
r9473 r9495 24 24 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector; 25 25 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable; 26 using HeuristicLab.Problems.BinPacking.Interfaces; 26 27 27 28 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector { … … 30 31 public class SingleItemRotationMove : MultiComponentVectorMove { 31 32 [Storable] 32 public int ItemIndex { get; protected set; } 33 public int AffectedGroup { get; protected set; } 34 [Storable] 35 public int Index { get; protected set; } 33 36 34 37 [StorableConstructor] … … 36 39 protected SingleItemRotationMove(SingleItemRotationMove original, Cloner cloner) 37 40 : base(original, cloner) { 38 this.ItemIndex = original.ItemIndex; 41 this.AffectedGroup = original.AffectedGroup; 42 this.Index = original.Index; 39 43 } 40 public SingleItemRotationMove(int index, MultiComponentVectorEncoding multiComponentVector)44 public SingleItemRotationMove(int affectedBin, int index, MultiComponentVectorEncoding multiComponentVector) 41 45 : base(multiComponentVector) { 42 ItemIndex = index; 46 AffectedGroup = affectedBin; 47 Index = index; 43 48 } 44 49 … … 47 52 } 48 53 49 public override MultiComponentVectorEncoding GetVectorAfterMove() {50 return GetVectorAfterMove (MultiComponentVector, ItemIndex);54 public override IPackingSolutionEncoding GetSolutionAfterMove() { 55 return GetVectorAfterMove (MultiComponentVector, AffectedGroup, Index); 51 56 } 52 public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int itemIndex) {57 public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int affectedGroup, int index) { 53 58 var result = multiComponentVector.Clone(new Cloner()) as MultiComponentVectorEncoding; 54 result.PackingInformations[ itemIndex].Rotated = !result.PackingInformations[itemIndex].Rotated;59 result.PackingInformations[affectedGroup][index].Rotated = !result.PackingInformations[affectedGroup][index].Rotated; 55 60 return result; 56 61 } … … 61 66 62 67 public override string ToString() { 63 return "RM(i=" + ItemIndex+")"; 68 return "RM(g=" + AffectedGroup + ",i=" + Index + ")"; 69 } 70 71 public override MultiComponentVectorMoveAttribute GetAttribute(double quality) { 72 return new SingleItemRotationMoveAttribute(AffectedGroup, Index, 73 MultiComponentVector.PackingInformations[AffectedGroup][Index].ItemID, 74 MultiComponentVector.PackingInformations[AffectedGroup][Index].Rotated, quality); 75 } 76 77 public override bool BelongsToAttribute(MultiComponentVectorMoveAttribute attribute, bool hardCriterion) { 78 SingleItemRotationMoveAttribute actualAttribute = attribute as SingleItemRotationMoveAttribute; 79 if (actualAttribute != null) { 80 if (hardCriterion) { 81 if (AffectedGroup == actualAttribute.AffectedGroup || MultiComponentVector.PackingInformations[AffectedGroup][Index].Rotated == actualAttribute.ItemRotation) 82 return true; 83 } else { 84 if (AffectedGroup == actualAttribute.AffectedGroup && MultiComponentVector.PackingInformations[AffectedGroup][Index].Rotated == actualAttribute.ItemRotation) 85 return true; 86 } 87 } 88 return false; 64 89 } 65 90 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/Moves/SwapPositionMove.cs
r9473 r9495 24 24 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector; 25 25 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable; 26 using HeuristicLab.Problems.BinPacking.Interfaces; 26 27 27 28 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector { … … 29 30 [StorableClass] 30 31 public class SwapPositionMove : MultiComponentVectorMove { 32 [Storable] 33 public int AffectedGroup { get; protected set; } 31 34 [Storable] 32 35 public int Index1 { get; protected set; } … … 38 41 protected SwapPositionMove(SwapPositionMove original, Cloner cloner) 39 42 : base(original, cloner) { 40 this.Index1 = original.Index1; 41 this.Index2 = original.Index2; 43 this.AffectedGroup = original.AffectedGroup; 44 this.Index1 = original.Index1; 45 this.Index2 = original.Index2; 42 46 } 43 public SwapPositionMove(int index1, int index2, MultiComponentVectorEncoding multiComponentVector)47 public SwapPositionMove(int affectedGroup, int index1, int index2, MultiComponentVectorEncoding multiComponentVector) 44 48 : base(multiComponentVector) { 49 AffectedGroup = affectedGroup; 45 50 Index1 = index1; 46 51 Index2 = index2; … … 51 56 } 52 57 53 public override MultiComponentVectorEncoding GetVectorAfterMove() {54 return GetVectorAfterMove(MultiComponentVector, Index1, Index2);58 public override IPackingSolutionEncoding GetSolutionAfterMove() { 59 return GetVectorAfterMove(MultiComponentVector, AffectedGroup, Index1, Index2); 55 60 } 56 public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int index1, int index2) {61 public static MultiComponentVectorEncoding GetVectorAfterMove(MultiComponentVectorEncoding multiComponentVector, int affectedGroup, int index1, int index2) { 57 62 var result = multiComponentVector.Clone(new Cloner()) as MultiComponentVectorEncoding; 58 var aux = result.PackingInformations[ index1];59 result.PackingInformations[ index1] = result.PackingInformations[index2];60 result.PackingInformations[ index2] = aux;63 var aux = result.PackingInformations[affectedGroup][index1]; 64 result.PackingInformations[affectedGroup][index1] = result.PackingInformations[affectedGroup][index2]; 65 result.PackingInformations[affectedGroup][index2] = aux; 61 66 return result; 62 67 } … … 67 72 68 73 public override string ToString() { 69 return "SM(i1=" + Index1 + ",i2=" + Index2 + ")"; 74 return "SPM(g=" + AffectedGroup + ",i1=" + Index1 + ",i2=" + Index2 + ")"; 75 } 76 77 public override MultiComponentVectorMoveAttribute GetAttribute(double quality) { 78 return new SwapPositionMoveAttribute(AffectedGroup, Index1, Index2, 79 MultiComponentVector.PackingInformations[AffectedGroup][Index1].ItemID, 80 MultiComponentVector.PackingInformations[AffectedGroup][Index2].ItemID, quality); 81 } 82 83 public override bool BelongsToAttribute(MultiComponentVectorMoveAttribute attribute, bool hardCriterion) { 84 SwapPositionMoveAttribute actualAttribute = attribute as SwapPositionMoveAttribute; 85 if (actualAttribute != null) { 86 if (hardCriterion) { 87 if (Index1 == actualAttribute.Index1 88 || Index2 == actualAttribute.Index2 89 || MultiComponentVector.PackingInformations[AffectedGroup][Index1].ItemID == actualAttribute.ItemID1 90 || MultiComponentVector.PackingInformations[AffectedGroup][Index2].ItemID == actualAttribute.ItemID2) 91 return true; 92 } else { 93 if (Index1 == actualAttribute.Index1 94 && Index2 == actualAttribute.Index2 95 && MultiComponentVector.PackingInformations[AffectedGroup][Index1].ItemID == actualAttribute.ItemID1 96 && MultiComponentVector.PackingInformations[AffectedGroup][Index2].ItemID == actualAttribute.ItemID2) 97 return true; 98 } 99 } 100 return false; 70 101 } 71 102 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveGenerator.cs
r9473 r9495 42 42 get { return (ILookupParameter<MultiComponentVectorEncoding>)Parameters["MultiComponentVector"]; } 43 43 } 44 public ILookupParameter< MultiComponentVectorMove> MultiComponentVectorMoveParameter {45 get { return (LookupParameter< MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }44 public ILookupParameter<IPackingMove> PackingMoveParameter { 45 get { return (LookupParameter<IPackingMove>)Parameters["PackingMove"]; } 46 46 } 47 47 protected ScopeParameter CurrentScopeParameter { … … 56 56 : base() { 57 57 Parameters.Add(new LookupParameter<MultiComponentVectorEncoding>("MultiComponentVector", "The multi component vector for which moves should be generated.")); 58 Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "The moves that should be generated in subscopes."));58 Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The moves that should be generated in subscopes.")); 59 59 Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the moves should be added as subscopes.")); 60 60 } … … 62 62 63 63 public static int NrOfRotationMoves(MultiComponentVectorEncoding mcv) { 64 return mcv. PackingInformations.Count;64 return mcv.NrOfItems; 65 65 } 66 66 public static IEnumerable<MultiComponentVectorMove> GenerateRotationMoves(MultiComponentVectorEncoding multiComponentVector) { 67 for (int i = 0; i < multiComponentVector.PackingInformations.Count; i++) 68 yield return new SingleItemRotationMove(i, multiComponentVector); 67 for (int binNr = 0; binNr < multiComponentVector.PackingInformations.Count; binNr++) 68 for (int index = 0; index < multiComponentVector.PackingInformations[binNr].Count; index++) 69 yield return new SingleItemRotationMove(binNr, index, multiComponentVector); 69 70 } 70 71 71 72 public static int NrOfSingleGroupingMoves(MultiComponentVectorEncoding mcv) { 72 int nrOfBins = 0; 73 foreach (var pi in mcv.PackingInformations) { 74 if (pi.AssignedBin > nrOfBins) 75 nrOfBins = pi.AssignedBin; 76 } 77 nrOfBins++; 78 return mcv.PackingInformations.Count * (nrOfBins - 1); 73 return mcv.NrOfItems * (mcv.NrOfBins - 1); 79 74 } 80 75 public static IEnumerable<MultiComponentVectorMove> GenerateSingleGroupingMoves(MultiComponentVectorEncoding multiComponentVector) { 81 int nrOfBins = 0; 82 foreach (var pi in multiComponentVector.PackingInformations) { 83 if (pi.AssignedBin > nrOfBins) 84 nrOfBins = pi.AssignedBin; 85 } 86 nrOfBins++; 87 for (int i = 0; i < multiComponentVector.PackingInformations.Count; i++) 88 for (int j = 0; j < nrOfBins; j++) { 89 if (j != multiComponentVector.PackingInformations[i].AssignedBin) 90 yield return new SingleGroupingMove(i, j, multiComponentVector); 91 } 76 for (int oldBin = 0; oldBin < multiComponentVector.PackingInformations.Count; oldBin++) 77 for (int index = 0; index < multiComponentVector.PackingInformations[oldBin].Count; index++) 78 for (int newBin = 0; newBin < multiComponentVector.NrOfBins; newBin++) 79 if (newBin != oldBin) 80 yield return new SingleGroupingMove(oldBin, index, newBin, multiComponentVector); 92 81 } 93 82 94 83 public static int NrOfSwapPositionMoves(MultiComponentVectorEncoding mcv) { 95 int nrOfBins = 0;96 foreach (var pi in mcv.PackingInformations) {97 if (pi.AssignedBin > nrOfBins)98 nrOfBins = pi.AssignedBin;99 }100 nrOfBins++;101 int[] itemsPerBin = new int[nrOfBins];102 foreach (var pi in mcv.PackingInformations) {103 itemsPerBin[pi.AssignedBin]++;104 }105 84 int nrOfSwapPositionMoves = 0; 106 foreach ( int items in itemsPerBin) {107 nrOfSwapPositionMoves += ( items * (items- 1)) / 2;85 foreach (var groupInformations in mcv.PackingInformations) { 86 nrOfSwapPositionMoves += (groupInformations.Value.Count * (groupInformations.Value.Count - 1)) / 2; 108 87 } 109 88 return nrOfSwapPositionMoves; 110 89 } 111 90 public static IEnumerable<MultiComponentVectorMove> GenerateSwapPositionMoves(MultiComponentVectorEncoding multiComponentVector) { 112 Dictionary<int, List<int>> indexesPerBin = new Dictionary<int, List<int>>(); 113 for (int i = 0; i < multiComponentVector.PackingInformations.Count; i++) { 114 int currentBin = multiComponentVector.PackingInformations[i].AssignedBin; 115 if (!indexesPerBin.ContainsKey(currentBin)) 116 indexesPerBin[currentBin] = new List<int>(); 117 indexesPerBin[currentBin].Add(i); 118 } 119 foreach (var entry in indexesPerBin) { 120 for (int i = 0; i < entry.Value.Count - 1; i++) 121 for (int j = i + 1; j < entry.Value.Count; j++) 122 yield return new SwapPositionMove(entry.Value[i], entry.Value[j], multiComponentVector); 123 } 91 for (int bin = 0; bin < multiComponentVector.PackingInformations.Count; bin++) 92 for (int oldIndex = 0; oldIndex < multiComponentVector.PackingInformations[bin].Count - 1; oldIndex++) 93 for (int newIndex = oldIndex + 1; newIndex < multiComponentVector.PackingInformations[bin].Count; newIndex++) 94 yield return new SwapPositionMove(bin, oldIndex, newIndex, multiComponentVector); 124 95 } 125 96 126 97 public static int NrOfChangePositionMoves(MultiComponentVectorEncoding mcv) { 127 int nrOfBins = 0; 128 foreach (var pi in mcv.PackingInformations) { 129 if (pi.AssignedBin > nrOfBins) 130 nrOfBins = pi.AssignedBin; 98 int nrOfChangePositionMoves = 0; 99 foreach (var groupInformations in mcv.PackingInformations) { 100 nrOfChangePositionMoves += (groupInformations.Value.Count * (groupInformations.Value.Count - 1)) / 2; 131 101 } 132 nrOfBins++; 133 int[] itemsPerBin = new int[nrOfBins]; 134 foreach (var pi in mcv.PackingInformations) { 135 itemsPerBin[pi.AssignedBin]++; 136 } 137 int nrOfSwapPositionMoves = 0; 138 foreach (int items in itemsPerBin) { 139 nrOfSwapPositionMoves += (items * (items - 1)) / 2; 140 } 141 return nrOfSwapPositionMoves; 102 return nrOfChangePositionMoves; 142 103 } 143 104 public static IEnumerable<MultiComponentVectorMove> GenerateChangePositionMoves(MultiComponentVectorEncoding multiComponentVector) { 144 Dictionary<int, List<int>> indexesPerBin = new Dictionary<int, List<int>>(); 145 for (int i = 0; i < multiComponentVector.PackingInformations.Count; i++) { 146 int currentBin = multiComponentVector.PackingInformations[i].AssignedBin; 147 if (!indexesPerBin.ContainsKey(currentBin)) 148 indexesPerBin[currentBin] = new List<int>(); 149 indexesPerBin[currentBin].Add(i); 150 } 151 foreach (var entry in indexesPerBin) { 152 for (int i = 0; i < entry.Value.Count - 1; i++) 153 for (int j = i + 1; j < entry.Value.Count; j++) 154 yield return new ChangePositionMove(entry.Value[i], entry.Value[j], multiComponentVector); 155 } 105 for (int bin = 0; bin < multiComponentVector.PackingInformations.Count; bin++) 106 for (int oldIndex = 0; oldIndex < multiComponentVector.PackingInformations[bin].Count - 1; oldIndex++) 107 for (int newIndex = oldIndex + 1; newIndex < multiComponentVector.PackingInformations[bin].Count; newIndex++) 108 yield return new ChangePositionMove(bin, oldIndex, newIndex, multiComponentVector); 156 109 } 157 110 … … 162 115 for (int i = 0; i < moveScopes.Length; i++) { 163 116 moveScopes[i] = new Scope(i.ToString()); 164 moveScopes[i].Variables.Add(new Variable( MultiComponentVectorMoveParameter.ActualName, moves[i]));117 moveScopes[i].Variables.Add(new Variable(PackingMoveParameter.ActualName, moves[i])); 165 118 } 166 119 CurrentScopeParameter.ActualValue.SubScopes.AddRange(moveScopes); -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveHardTabuCriterion.cs
r9473 r9495 38 38 get { return false; } 39 39 } 40 public ILookupParameter< MultiComponentVectorMove> MultiComponentVectorMoveParameter {41 get { return (ILookupParameter< MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }40 public ILookupParameter<IPackingMove> PackingMoveParameter { 41 get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; } 42 42 } 43 43 public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter { … … 65 65 public MultiComponentVectorMoveHardTabuCriterion() 66 66 : base() { 67 Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "The move to evaluate."));67 Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate.")); 68 68 Parameters.Add(new LookupParameter<MultiComponentVectorEncoding>("MultiComponentVector", "The solution to evaluate.")); 69 69 Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu.")); … … 80 80 public override IOperation Apply() { 81 81 ItemList<IItem> tabuList = TabuListParameter.ActualValue; 82 MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;82 MultiComponentVectorMove move = PackingMoveParameter.ActualValue as MultiComponentVectorMove; 83 83 MultiComponentVectorEncoding multiComponentVector = MultiComponentVectorParameter.ActualValue; 84 84 int length = multiComponentVector.PackingInformations.Count; … … 94 94 private bool IsMoveTabu(ItemList<IItem> tabuList, MultiComponentVectorMove move, MultiComponentVectorEncoding multiComponentVector, double moveQuality, bool maximization, bool useAspiration) { 95 95 bool isTabu = false; 96 SingleItemRotationMove sirm = move as SingleItemRotationMove;97 SingleGroupingMove sgm = move as SingleGroupingMove;98 SwapPositionMove spm = move as SwapPositionMove;99 ChangePositionMove cpm = move as ChangePositionMove;100 MCVTripleMove tm = move as MCVTripleMove;101 96 var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType())); 102 97 103 if (sirm != null) { 104 foreach (IItem tabuMove in attributes) { 105 SingleItemRotationMoveAttribute sirmAttr = (tabuMove as SingleItemRotationMoveAttribute); 106 if (sirmAttr.MoveQuality.Equals(moveQuality)) 107 return true; 108 if (sirmAttr != null 109 && (!useAspiration 110 || maximization && moveQuality <= sirmAttr.MoveQuality 111 || !maximization && moveQuality >= sirmAttr.MoveQuality)) { 112 if (sirm.ItemIndex == sirmAttr.ItemIndex || multiComponentVector.PackingInformations[sirm.ItemIndex].Rotated == sirmAttr.ItemRotation) 113 isTabu = true; 114 } 115 if (isTabu) break; 98 foreach (IItem attr in attributes) { 99 MultiComponentVectorMoveAttribute mcvAttr = attr as MultiComponentVectorMoveAttribute; 100 if (mcvAttr != null 101 && (!useAspiration 102 || maximization && moveQuality <= mcvAttr.MoveQuality 103 || !maximization && moveQuality >= mcvAttr.MoveQuality)) { 104 105 isTabu = move.BelongsToAttribute(mcvAttr, true); 116 106 } 117 } else if (sgm != null) { 118 foreach (IItem tabuMove in attributes) { 119 SingleGroupingMoveAttribute sgmAttr = (tabuMove as SingleGroupingMoveAttribute); 120 if (sgmAttr.MoveQuality.Equals(moveQuality)) 121 return true; 122 if (sgmAttr != null 123 && (!useAspiration 124 || maximization && moveQuality <= sgmAttr.MoveQuality 125 || !maximization && moveQuality >= sgmAttr.MoveQuality)) { 126 if ( multiComponentVector.PackingInformations[sgm.Index].ItemIndex == multiComponentVector.PackingInformations[sgmAttr.Index].ItemIndex 127 || multiComponentVector.PackingInformations[sgm.Index].AssignedBin == sgmAttr.AssignedBin) 128 isTabu = true; 129 } 130 if (isTabu) break; 131 } 132 } else if (spm != null) { 133 foreach (IItem tabuMove in attributes) { 134 SwapPositionMoveAttribute spmAttr = (tabuMove as SwapPositionMoveAttribute); 135 if (spmAttr.MoveQuality.Equals(moveQuality)) 136 return true; 137 if (spmAttr != null 138 && (!useAspiration 139 || maximization && moveQuality <= spmAttr.MoveQuality 140 || !maximization && moveQuality >= spmAttr.MoveQuality)) { 141 if (spm.Index1 == spmAttr.Index1 142 || spm.Index2 == spmAttr.Index2 143 || multiComponentVector.PackingInformations[spm.Index1].ItemIndex == spmAttr.ItemIndex1 144 || multiComponentVector.PackingInformations[spm.Index2].ItemIndex == spmAttr.ItemIndex2) 145 isTabu = true; 146 } 147 if (isTabu) break; 148 } 149 } else if (cpm != null) { 150 foreach (IItem tabuMove in attributes) { 151 ChangePositionMoveAttribute cpmAttr = (tabuMove as ChangePositionMoveAttribute); 152 if (cpmAttr.MoveQuality.Equals(moveQuality)) 153 return true; 154 if (cpmAttr != null 155 && (!useAspiration 156 || maximization && moveQuality <= cpmAttr.MoveQuality 157 || !maximization && moveQuality >= cpmAttr.MoveQuality)) { 158 if (cpm.Index == cpmAttr.Index 159 || cpm.TargetIndex == cpmAttr.TargetIndex 160 || multiComponentVector.PackingInformations[cpm.Index].ItemIndex == cpmAttr.ItemIndex) 161 isTabu = true; 162 } 163 if (isTabu) break; 164 } 165 } else if (tm != null) { 166 foreach (IItem tabuMove in attributes) { 167 MCVTripleMoveAttribute tmAttr = (tabuMove as MCVTripleMoveAttribute); 168 if (tmAttr.MoveQuality.Equals(moveQuality)) 169 return true; 170 if (tmAttr != null 171 && (!useAspiration 172 || maximization && moveQuality <= tmAttr.MoveQuality 173 || !maximization && moveQuality >= tmAttr.MoveQuality)) { 174 if ((tm.Index == tmAttr.Index && tm.TargetIndex == tmAttr.TargetIndex) 175 || tm.Index == tmAttr.Index 176 || multiComponentVector.PackingInformations[tm.Index].ItemIndex == tmAttr.ItemIndex 177 ) 178 isTabu = true; 179 } 180 if (isTabu) break; 181 } 182 } 183 184 107 if (isTabu) break; 108 } 185 109 186 110 return isTabu; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveMaker.cs
r9473 r9495 42 42 get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; } 43 43 } 44 public ILookupParameter< MultiComponentVectorMove> MultiComponentVectorMoveParameter {45 get { return (ILookupParameter< MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }44 public ILookupParameter<IPackingMove> PackingMoveParameter { 45 get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; } 46 46 } 47 47 public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter { 48 48 get { return (ILookupParameter<MultiComponentVectorEncoding>)Parameters["MultiComponentVector"]; } 49 } 50 public ILookupParameter<IPackingPlan> PackingPlanParameter { 51 get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlan"]; } 52 } 53 public ILookupParameter<IPackingPlan> PackingPlanAfterMoveParameter { 54 get { return (ILookupParameter<IPackingPlan>)Parameters["PackingPlanAfterMove"]; } 49 55 } 50 56 … … 55 61 : base() { 56 62 Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the solution.")); 57 Parameters.Add(new LookupParameter< MultiComponentVectorMove>("MultiComponentVectorMove", "The move to evaluate."));63 Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate.")); 58 64 Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The relative quality of the move.")); 59 65 Parameters.Add(new LookupParameter<MultiComponentVectorEncoding>("MultiComponentVector", "The solution as grouping vector.")); 66 Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlan", "The currently best performing, decoded bin-packing solution represented as generalized packing-plan.")); 67 Parameters.Add(new LookupParameter<IPackingPlan>("PackingPlanAfterMove", "The moved and decoded bin-packing solution represented as generalized packing-plan.")); 60 68 } 61 69 … … 65 73 66 74 public override IOperation Apply() { 67 MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;75 IPackingMove move = PackingMoveParameter.ActualValue; 68 76 MultiComponentVectorEncoding multiComponentVector = MultiComponentVectorParameter.ActualValue; 69 77 DoubleValue moveQuality = MoveQualityParameter.ActualValue; 70 78 DoubleValue quality = QualityParameter.ActualValue; 71 79 72 multiComponentVector.PackingInformations = move.GetVectorAfterMove().PackingInformations; 80 multiComponentVector.PackingInformations = (move.GetSolutionAfterMove() as MultiComponentVectorEncoding).PackingInformations; 81 PackingPlanParameter.ActualValue = PackingPlanAfterMoveParameter.ActualValue; 73 82 74 83 quality.Value = moveQuality.Value; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorMoveSoftTabuCriterion.cs
r9473 r9495 38 38 get { return false; } 39 39 } 40 public ILookupParameter< MultiComponentVectorMove> MultiComponentVectorMoveParameter {41 get { return (ILookupParameter< MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }40 public ILookupParameter<IPackingMove> PackingMoveParameter { 41 get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; } 42 42 } 43 43 public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter { … … 65 65 public MultiComponentVectorMoveSoftTabuCriterion() 66 66 : base() { 67 Parameters.Add(new LookupParameter< MultiComponentVectorMove>("MultiComponentVectorMove", "The move to evaluate."));67 Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate.")); 68 68 Parameters.Add(new LookupParameter<MultiComponentVectorEncoding>("MultiComponentVector", "The solution to evaluate.")); 69 69 Parameters.Add(new LookupParameter<BoolValue>("MoveTabu", "The variable to store if a move was tabu.")); … … 80 80 public override IOperation Apply() { 81 81 ItemList<IItem> tabuList = TabuListParameter.ActualValue; 82 MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;82 MultiComponentVectorMove move = PackingMoveParameter.ActualValue as MultiComponentVectorMove; 83 83 MultiComponentVectorEncoding multiComponentVector = MultiComponentVectorParameter.ActualValue; 84 84 int length = multiComponentVector.PackingInformations.Count; … … 94 94 private bool IsMoveTabu(ItemList<IItem> tabuList, MultiComponentVectorMove move, MultiComponentVectorEncoding multiComponentVector, double moveQuality, bool maximization, bool useAspiration) { 95 95 bool isTabu = false; 96 97 SingleItemRotationMove sirm = move as SingleItemRotationMove;98 SingleGroupingMove sgm = move as SingleGroupingMove;99 SwapPositionMove spm = move as SwapPositionMove;100 ChangePositionMove cpm = move as ChangePositionMove;101 MCVTripleMove tm = move as MCVTripleMove;102 96 var attributes = tabuList.FindAll(ta => ta.GetType().Equals(move.GetMoveAttributeType())); 103 97 104 if (sirm != null) { 105 foreach (IItem tabuMove in attributes) { 106 SingleItemRotationMoveAttribute sirmAttr = (tabuMove as SingleItemRotationMoveAttribute); 107 if (sirmAttr != null 108 && (!useAspiration 109 || maximization && moveQuality <= sirmAttr.MoveQuality 110 || !maximization && moveQuality >= sirmAttr.MoveQuality)) { 111 if (sirm.ItemIndex == sirmAttr.ItemIndex && multiComponentVector.PackingInformations[sirm.ItemIndex].Rotated == sirmAttr.ItemRotation) 112 isTabu = true; 113 } 114 if (isTabu) break; 98 foreach (IItem attr in attributes) { 99 MultiComponentVectorMoveAttribute mcvAttr = attr as MultiComponentVectorMoveAttribute; 100 if (mcvAttr != null 101 && (!useAspiration 102 || maximization && moveQuality <= mcvAttr.MoveQuality 103 || !maximization && moveQuality >= mcvAttr.MoveQuality)) { 104 105 isTabu = move.BelongsToAttribute(mcvAttr, false); 115 106 } 116 } else if (sgm != null) { 117 foreach (IItem tabuMove in attributes) { 118 SingleGroupingMoveAttribute sgmAttr = (tabuMove as SingleGroupingMoveAttribute); 119 if (sgmAttr != null 120 && (!useAspiration 121 || maximization && moveQuality <= sgmAttr.MoveQuality 122 || !maximization && moveQuality >= sgmAttr.MoveQuality)) { 123 if (multiComponentVector.PackingInformations[sgm.Index].ItemIndex == multiComponentVector.PackingInformations[sgmAttr.Index].ItemIndex 124 && multiComponentVector.PackingInformations[sgm.Index].AssignedBin == sgmAttr.AssignedBin) 125 isTabu = true; 126 } 127 if (isTabu) break; 128 } 129 } else if (spm != null) { 130 foreach (IItem tabuMove in attributes) { 131 SwapPositionMoveAttribute spmAttr = (tabuMove as SwapPositionMoveAttribute); 132 if (spmAttr != null 133 && (!useAspiration 134 || maximization && moveQuality <= spmAttr.MoveQuality 135 || !maximization && moveQuality >= spmAttr.MoveQuality)) { 136 if (spm.Index1 == spmAttr.Index1 137 && spm.Index2 == spmAttr.Index2 138 && multiComponentVector.PackingInformations[spm.Index1].ItemIndex == spmAttr.ItemIndex1 139 && multiComponentVector.PackingInformations[spm.Index2].ItemIndex == spmAttr.ItemIndex2) 140 isTabu = true; 141 } 142 if (isTabu) break; 143 } 144 } else if (cpm != null) { 145 foreach (IItem tabuMove in attributes) { 146 ChangePositionMoveAttribute cpmAttr = (tabuMove as ChangePositionMoveAttribute); 147 if (cpmAttr != null 148 && (!useAspiration 149 || maximization && moveQuality <= cpmAttr.MoveQuality 150 || !maximization && moveQuality >= cpmAttr.MoveQuality)) { 151 if (cpm.Index == cpmAttr.Index 152 && cpm.TargetIndex == cpmAttr.TargetIndex 153 && multiComponentVector.PackingInformations[cpm.Index].ItemIndex == cpmAttr.ItemIndex) 154 isTabu = true; 155 } 156 if (isTabu) break; 157 } 158 } else if (tm != null) { 159 foreach (IItem tabuMove in attributes) { 160 MCVTripleMoveAttribute tmAttr = (tabuMove as MCVTripleMoveAttribute); 161 if (tmAttr != null 162 && (!useAspiration 163 || maximization && moveQuality <= tmAttr.MoveQuality 164 || !maximization && moveQuality >= tmAttr.MoveQuality)) { 165 if ((tm.Index == tmAttr.Index && tm.TargetIndex == tmAttr.TargetIndex) 166 && multiComponentVector.PackingInformations[tm.Index].ItemIndex == tmAttr.ItemIndex 167 && tm.Rotation == !(tmAttr.RotationAfter.Equals(tmAttr.RotationBefore)) 168 && (tm.Group == tmAttr.GroupAfter && multiComponentVector.PackingInformations[tm.Index].AssignedBin == tmAttr.GroupBefore) 169 ) 170 isTabu = true; 171 } 172 if (isTabu) break; 173 } 174 } 175 176 107 if (isTabu) break; 108 } 177 109 178 110 return isTabu; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/MultiComponentVectorTabuMaker.cs
r9473 r9495 32 32 [StorableClass] 33 33 public class MultiComponentVectorTabuMaker : TabuMaker, IMultiComponentVectorMoveOperator{ 34 public ILookupParameter< MultiComponentVectorMove> MultiComponentVectorMoveParameter {35 get { return (ILookupParameter< MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }34 public ILookupParameter<IPackingMove> PackingMoveParameter { 35 get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; } 36 36 } 37 37 public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter { … … 44 44 public MultiComponentVectorTabuMaker() 45 45 : base() { 46 Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "The move to evaluate."));46 Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate.")); 47 47 Parameters.Add(new LookupParameter<MultiComponentVectorEncoding>("MultiComponentVector", "The solution to evaluate.")); 48 48 } … … 53 53 54 54 protected override IItem GetTabuAttribute(bool maximization, double quality, double moveQuality) { 55 MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;55 IPackingMove move = PackingMoveParameter.ActualValue; 56 56 MultiComponentVectorEncoding solution = MultiComponentVectorParameter.ActualValue; 57 57 double baseQuality = moveQuality; … … 59 59 baseQuality = quality; // we make an uphill move, the lower bound is the solution quality 60 60 61 SingleItemRotationMove sirm = move as SingleItemRotationMove; 62 if (sirm != null) 63 return new SingleItemRotationMoveAttribute(sirm.ItemIndex, solution.PackingInformations[sirm.ItemIndex].Rotated, baseQuality); 64 SingleGroupingMove sgm = move as SingleGroupingMove; 65 if (sgm != null) 66 return new SingleGroupingMoveAttribute(sgm.Index, solution.PackingInformations[sgm.Index].AssignedBin, baseQuality); 67 SwapPositionMove spm = move as SwapPositionMove; 68 if (spm != null) 69 return new SwapPositionMoveAttribute(spm.Index1, spm.Index2, solution.PackingInformations[spm.Index1].ItemIndex, solution.PackingInformations[spm.Index2].ItemIndex, baseQuality); 70 ChangePositionMove cpm = move as ChangePositionMove; 71 if (cpm != null) 72 return new ChangePositionMoveAttribute(cpm.Index, cpm.TargetIndex, solution.PackingInformations[cpm.Index].ItemIndex, baseQuality); 73 MCVTripleMove tm = move as MCVTripleMove; 74 if (tm != null) 75 return new MCVTripleMoveAttribute( 76 tm.Index, 77 tm.TargetIndex, 78 solution.PackingInformations[tm.Index].ItemIndex, 79 solution.PackingInformations[tm.Index].Rotated, 80 tm.Rotation ^ solution.PackingInformations[tm.Index].Rotated, 81 solution.PackingInformations[tm.Index].AssignedBin, 82 tm.Group, 83 baseQuality); 84 61 MultiComponentVectorMove mcvMove = move as MultiComponentVectorMove; 62 if (mcvMove != null) 63 return mcvMove.GetAttribute(baseQuality); 85 64 else return solution; 86 65 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/Moves/ThreeWay/StochasticMultiComponentVectorMoveGenerator.cs
r9473 r9495 29 29 30 30 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector { 31 [Item("Stochastic MultiComponentVectorMoveGenerator", "Generates all possible multi component moves from a given multiComponentVector.")]31 [Item("Stochastic MultiComponentVector Move Generator", "Generates all possible multi component moves from a given multiComponentVector.")] 32 32 [StorableClass] 33 33 public class StochasticMultiComponentVectorMoveGenerator : MultiComponentVectorMoveGenerator, IMultiMoveGenerator, IStochasticOperator { -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorEncoding.cs
r9473 r9495 37 37 38 38 [Storable] 39 public ItemList<PackingInformation> PackingInformations {get;set;} 39 public ObservableDictionary<int, ItemList<PackingInformation>> PackingInformations {get;set;} 40 41 public int NrOfBins { get { return PackingInformations.Count; } } 42 public int NrOfItems { 43 get { 44 int nrOfItems = 0; 45 foreach (var entry in PackingInformations) { nrOfItems += entry.Value.Count; } 46 return nrOfItems; 47 } 48 } 40 49 41 50 [StorableConstructor] … … 43 52 protected MultiComponentVectorEncoding(MultiComponentVectorEncoding original, Cloner cloner) 44 53 : base(original, cloner) { 45 this.PackingInformations = cloner.Clone(original.PackingInformations); 54 this.PackingInformations = new ObservableDictionary<int,ItemList<PackingInformation>>(); 55 foreach (var entry in original.PackingInformations) { 56 this.PackingInformations[entry.Key] = cloner.Clone(entry.Value); 57 } 46 58 } 47 59 public override IDeepCloneable Clone(Cloner cloner) { … … 51 63 public MultiComponentVectorEncoding() 52 64 : base() { 53 PackingInformations = new ItemList<PackingInformation>();65 PackingInformations = new ObservableDictionary<int, ItemList<PackingInformation>>(); 54 66 } 55 67 … … 57 69 StringBuilder sb = new StringBuilder(); 58 70 sb.Append("[ "); 59 foreach (var pi in PackingInformations) { 60 sb.Append(pi.ToString() + " "); 71 foreach (var gi in PackingInformations) { 72 sb.Append("g#" + gi.Key.ToString() + "{ "); 73 foreach (var pi in gi.Value) { 74 sb.Append(pi.ToString() + " "); 75 } 76 sb.Append("} "); 61 77 } 62 78 sb.Append("]"); … … 85 101 public class PackingInformation : Item { 86 102 [Storable] 87 public int ItemIndex { get; set; } 88 [Storable] 89 public int AssignedBin { get; set; } 103 public int ItemID { get; set; } 90 104 [Storable] 91 105 public bool Rotated { get; set; } 92 106 93 public PackingInformation(int itemIndex, int assignedBin, bool rotated) { 94 this.AssignedBin = assignedBin; 95 this.ItemIndex = itemIndex; 107 public PackingInformation(int itemID, bool rotated) { 108 this.ItemID = itemID; 96 109 this.Rotated = rotated; 97 110 } 98 111 public PackingInformation(PackingInformation original) { 99 this.AssignedBin = original.AssignedBin; 100 this.ItemIndex = original.ItemIndex; 112 this.ItemID = original.ItemID; 101 113 this.Rotated = original.Rotated; 102 114 } … … 106 118 protected PackingInformation(PackingInformation original, Cloner cloner) 107 119 : base(original, cloner) { 108 this.AssignedBin = original.AssignedBin; 109 this.ItemIndex = original.ItemIndex; 120 this.ItemID = original.ItemID; 110 121 this.Rotated = original.Rotated; 111 122 } … … 115 126 116 127 public override string ToString() { 117 return String.Format("({0}, {1}, {2}) ", ItemIndex, AssignedBin, Rotated); 128 return String.Format("{0}", ItemID.ToString()); 129 //return String.Format("({0}, {1}) ", ItemID, Rotated ? "t" : "f"); 118 130 } 119 131 … … 121 133 PackingInformation pi = obj as PackingInformation; 122 134 if (pi != null) 123 return this.ItemI ndex.Equals(pi.ItemIndex) && this.AssignedBin.Equals(pi.AssignedBin) && this.Rotated.Equals(pi.Rotated);135 return this.ItemID.Equals(pi.ItemID) && this.Rotated.Equals(pi.Rotated); 124 136 125 137 return false; … … 130 142 } 131 143 132 public static ItemList<PackingInformation> CreateListRandomly(int items, int lowerBound, IRandom random) { 133 Permutation permutation = new Permutation(PermutationTypes.Absolute, items, random); 134 var result = new ItemList<PackingInformation>(); 135 foreach (int itemIndex in permutation) { 136 result.Add(new PackingInformation(itemIndex, random.Next(0, lowerBound + 1), random.Next(0, 100) > 60 ? true : false)); 144 public static ObservableDictionary<int, ItemList<PackingInformation>> CreateDictionaryRandomly(int items, int nrOfBins, IRandom random) { 145 var result = new ObservableDictionary<int, ItemList<PackingInformation>>(); 146 for (int i = 0; i < nrOfBins; i++) 147 result[i] = new ItemList<PackingInformation>(); 148 149 Permutation randomItemSequence = new Permutation(PermutationTypes.Absolute, items, random); 150 foreach (int i in randomItemSequence) { 151 result[random.Next(nrOfBins)].Add(new PackingInformation(i, random.Next(100) > 60 ? true : false)); 137 152 } 138 153 return result; 139 154 } 140 155 141 public static ItemList<PackingInformation> CreateListRandomlyWithSortedSequence(int items, int lowerBound, IRandom random) { 142 Permutation permutation = new Permutation(PermutationTypes.Absolute, items); 143 var result = new ItemList<PackingInformation>(); 144 foreach (int itemIndex in permutation) { 145 result.Add(new PackingInformation(itemIndex, random.Next(0, lowerBound + 1), false)); 156 public static ObservableDictionary<int, ItemList<PackingInformation>> CreateDictionaryRandomlyWithSortedSequence(int items, int nrOfBins, IRandom random) { 157 var result = new ObservableDictionary<int, ItemList<PackingInformation>>(); 158 for (int i = 0; i < nrOfBins; i++) 159 result[i] = new ItemList<PackingInformation>(); 160 161 for (int i = 0; i < items; i++) { 162 result[random.Next(nrOfBins)].Add(new PackingInformation(i, false)); 146 163 } 147 164 return result; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/MultiComponentVectorRandomCreator.cs
r9473 r9495 70 70 var solution = new MultiComponentVectorEncoding(); 71 71 if (sortedSequence) 72 solution.PackingInformations = PackingInformation.Create ListRandomlyWithSortedSequence(items, lowerBound, random);72 solution.PackingInformations = PackingInformation.CreateDictionaryRandomlyWithSortedSequence(items, lowerBound, random); 73 73 else 74 solution.PackingInformations = PackingInformation.Create ListRandomly(items, lowerBound, random);74 solution.PackingInformations = PackingInformation.CreateDictionaryRandomly(items, lowerBound, random); 75 75 return solution; 76 76 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/MultiComponentVector/ThreeWayMultiComponentVectorManipulator.cs
r9440 r9495 28 28 29 29 namespace HeuristicLab.Encodings.PackingEncoding.MultiComponentVector { 30 [Item(" Uniform Multi Component VectorManipulator", "An operator which manipulates a PackingSequence representation.")]30 [Item("ThreeWayMultiComponentVectorManipulator", "An operator which manipulates a PackingSequence representation.")] 31 31 [StorableClass] 32 32 public class ThreeWayMultiComponentVectorManipulator : MultiComponentVectorManipulator { … … 43 43 protected override void Manipulate(IRandom random, MultiComponentVectorEncoding individual) { 44 44 int manipulatorDecision = random.Next(0, 3); 45 int affectedBin = 0; 46 do { 47 affectedBin = random.Next(individual.NrOfBins); 48 } while (individual.PackingInformations[affectedBin].Count <= 0); 49 int affectedIndex = random.Next (individual.PackingInformations[affectedBin].Count); 45 50 46 51 //Randomly rotate one item 47 52 if (manipulatorDecision == 0) { 48 bool r = individual.PackingInformations[random.Next(individual.PackingInformations.Count - 1)].Rotated; 49 individual.PackingInformations[random.Next(individual.PackingInformations.Count - 1)].Rotated = !r; 53 individual.PackingInformations = SingleItemRotationMove.GetVectorAfterMove(individual, affectedBin, affectedIndex).PackingInformations; 50 54 } 51 55 //Randomly change the bin-assignment for one item 52 56 else if (manipulatorDecision == 1) { 53 individual.PackingInformations[random.Next(individual.PackingInformations.Count - 1)].AssignedBin = 0; 57 int targetBin = 0; 58 if (individual.NrOfBins > 1) 59 do { targetBin = random.Next(individual.NrOfBins); } 60 while (targetBin != affectedBin); 61 individual.PackingInformations = SingleGroupingMove.GetVectorAfterMove(individual, affectedBin, affectedIndex, targetBin).PackingInformations; 54 62 } 55 63 //Swap the sequence of two items assigned to the same bin 56 64 else if (manipulatorDecision == 2) { 57 int length = individual.PackingInformations.Count; 58 59 int counter = 0; 60 int swappedIndex1 = random.Next(length); 61 int swappedIndex2 = random.Next(length); 62 while ((swappedIndex1 == swappedIndex2 || individual.PackingInformations[swappedIndex1].AssignedBin != individual.PackingInformations[swappedIndex2].AssignedBin) && counter < 10) 63 { 64 swappedIndex1 = random.Next(length); 65 swappedIndex2 = random.Next(length); 66 counter++; 67 } 68 69 if (swappedIndex1 != swappedIndex2 && individual.PackingInformations[swappedIndex1].AssignedBin == individual.PackingInformations[swappedIndex2].AssignedBin) { 70 int temp = individual.PackingInformations[swappedIndex1].ItemIndex; 71 individual.PackingInformations[swappedIndex1].ItemIndex = individual.PackingInformations[swappedIndex2].ItemIndex; 72 individual.PackingInformations[swappedIndex2].ItemIndex = temp; 73 } 74 65 int targetIndex = 0; 66 int nrOfItems = individual.PackingInformations[affectedBin].Count; 67 if (nrOfItems > 1) 68 do { targetIndex = random.Next(nrOfItems); } 69 while (targetIndex != affectedIndex); 70 individual.PackingInformations = ChangePositionMove.GetVectorAfterMove(individual, affectedBin, affectedIndex, targetIndex).PackingInformations; 75 71 } 76 72 -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Encodings/PackingPlans/PackingPlan.cs
r9440 r9495 60 60 [Storable] 61 61 public ObservableDictionary<int, D> PackingItemPositions { get; set; } 62 [Storable] 63 public ObservableDictionary<int, B> PackingBinMeasures { get; set; } 62 64 63 //[Storable]64 //public ItemList<BoolValue> PackingItemsRotated { get; set; }65 66 [Storable]67 public B PackingBinMeasures {68 get;69 set;70 }71 65 [Storable] 72 66 public ItemList<I> PackingItemMeasures { … … 89 83 #endregion 90 84 91 public PackingPlan(B binMeasures, ItemList<I> itemMeasures) : base() { 85 public PackingPlan(B binMeasures, ItemList<I> itemMeasures) 86 : base() { 87 this.PackingItemMeasures = itemMeasures; 88 this.PackingBinMeasures = new ObservableDictionary<int, B>(); 89 this.PackingBinMeasures[0] = binMeasures; 90 } 91 public PackingPlan(ObservableDictionary<int, B> binMeasures, ItemList<I> itemMeasures) 92 : base() { 93 this.PackingItemMeasures = itemMeasures; 92 94 this.PackingBinMeasures = binMeasures; 93 this.PackingItemMeasures = itemMeasures;94 95 } 95 96 … … 98 99 protected PackingPlan(PackingPlan<D,B,I> original, Cloner cloner) 99 100 : base(original, cloner) { 100 101 PackingBinMeasures = original.PackingBinMeasures;101 PackingItemPositions = new ObservableDictionary<int, D>(original.PackingItemPositions); 102 PackingBinMeasures = new ObservableDictionary<int, B>(original.PackingBinMeasures); 102 103 PackingItemMeasures = original.PackingItemMeasures; 103 //PackingItemsRotated = cloner.Clone(original.PackingItemsRotated); 104 } 105 public override IDeepCloneable Clone(Cloner cloner) { 106 return new PackingPlan<D,B,I>(this, cloner); 104 107 } 105 108 106 public override IDeepCloneable Clone(Cloner cloner) { 107 return new PackingPlan<D,B,I>(this, cloner); 109 public B GetPackingBinMeasuresForBinNr(int binNr) { 110 if (PackingBinMeasures.ContainsKey(binNr)) 111 return PackingBinMeasures[binNr]; 112 else 113 return PackingBinMeasures[0]; 108 114 } 109 115 -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/BinUtilizationRegularIdenticalBinEvaluator.cs
r9440 r9495 66 66 67 67 //if (itemPositionsAreValid) 68 return CalculateBinUtilization(plan as PackingPlan<D, B, I>, binMeasure, itemMeasures);68 return CalculateBinUtilization(plan as SingleBinSizePackingPlan<D, B, I>, binMeasure, itemMeasures); 69 69 70 70 //return quality; 71 71 } 72 72 73 public static DoubleValue CalculateBinUtilization( PackingPlan<D, B, I> plan, B binMeasure, ItemList<I> itemMeasures) {73 public static DoubleValue CalculateBinUtilization(SingleBinSizePackingPlan<D, B, I> plan, B binMeasure, ItemList<I> itemMeasures) { 74 74 int nrOfBins = plan.NrOfBins; 75 75 double result = 0; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Evaluators/Abstract/PackingPlanEvaluator.cs
r9440 r9495 72 72 73 73 74 protected abstract DoubleValue Evaluate(); 75 74 protected abstract DoubleValue Evaluate(); 76 75 public override IOperation Apply() { 77 76 QualityParameter.ActualValue = Evaluate(); -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/HeuristicLab.Problems.BinPacking-3.3.csproj
r9473 r9495 176 176 <Compile Include="Decoders\3D\DBL\DeepestBottomLeftMultiComponentVectorDecoder.cs" /> 177 177 <Compile Include="Decoders\3D\DBL\DeepestBottomLeftFunctions.cs" /> 178 <Compile Include="Decoders\3D\EP\ExtremePointPotvinDecoder3D.cs">179 <SubType>Code</SubType>180 </Compile>181 178 <Compile Include="Decoders\3D\EP\ExtremePointsFunctions3D.cs" /> 182 179 <Compile Include="Decoders\3D\DBL\DeepestBottomLeftGroupingVectorDecoder.cs" /> … … 184 181 <Compile Include="Decoders\3D\DBL\DeepestBottomLeftPackingSequenceDecoder.cs" /> 185 182 <Compile Include="Decoders\2D\BL\BottomLeftPackingSequenceDecoder.cs" /> 186 <Compile Include="Decoders\ IdenticalBinPackingSolutionDecoder.cs" />183 <Compile Include="Decoders\PackingSolutionDecoder.cs" /> 187 184 <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMoveSoftTabuCriterion.cs" /> 188 <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\ExhaustiveTargetBinSingleGroupingMoveGenerator.cs" />189 185 <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\ExhaustiveSingleGroupingMoveGenerator.cs" /> 190 186 <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMove.cs" /> … … 194 190 <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingTabuMaker.cs" /> 195 191 <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\SingleGroupingMoveHardTabuCriterion.cs" /> 192 <Compile Include="Encodings\GroupingVector\Moves\SingleGrouping\StochasticSingleGroupingMoveGenerator.cs" /> 196 193 <Compile Include="Encodings\GroupingVector\UniformGroupingVectorManipulator.cs" /> 197 194 <Compile Include="Encodings\GroupingVector\GroupingVectorCrossover.cs" /> … … 199 196 <Compile Include="Encodings\GroupingVector\GroupingVectorManipulator.cs" /> 200 197 <Compile Include="Encodings\GroupingVector\GroupingVectorRandomCreator.cs" /> 198 <Compile Include="Encodings\MultiComponentVector\SequencePreservingMultiComponentVectorCrossover.cs" /> 201 199 <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\ChangePositionMoveAttribute.cs" /> 202 200 <Compile Include="Encodings\MultiComponentVector\Moves\ThreeWay\Attributes\MCVTripleMoveAttribute.cs" /> … … 223 221 <SubType>Code</SubType> 224 222 </Compile> 225 <Compile Include="Encodings\MultiComponentVector\PartiallyMatchedMultiComponentVectorCrossover.cs" />226 223 <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorCrossover.cs" /> 227 224 <Compile Include="Encodings\MultiComponentVector\MultiComponentVectorManipulator.cs" /> … … 236 233 <Compile Include="Encodings\PackingSolutionCrossover.cs" /> 237 234 <Compile Include="Encodings\PackingSolutionManipulator.cs" /> 238 <Compile Include="Encodings\Potvin\PotvinEncoding.cs">239 <SubType>Code</SubType>240 </Compile>241 <Compile Include="Encodings\Potvin\PotvinRandomCreator.cs">242 <SubType>Code</SubType>243 </Compile>244 <Compile Include="Evaluators\2D\BinUtilizationRectangularIdenticalBinEvaluator.cs" />245 235 <Compile Include="Evaluators\2D\PackingRatioRectangularIdenticalBinEvaluator.cs" /> 246 <Compile Include="Evaluators\3D\BinUtilizationCuboiddenticalBinEvaluator.cs" />247 236 <Compile Include="Evaluators\3D\PackingRatioCuboidIdenticalBinEvaluator.cs" /> 248 <Compile Include="Evaluators\Abstract\BinUtilizationRegularIdenticalBinEvaluator.cs" />249 237 <Compile Include="Evaluators\Abstract\PackingRatioRegularIdenticalBinEvaluator.cs" /> 250 238 <Compile Include="Evaluators\Abstract\RegularSimpleRotationIdenticalBinPackingPlanEvaluator.cs" /> … … 257 245 <Compile Include="Instances\BPPORLIBParser.cs" /> 258 246 <Compile Include="Instances\BPPORLIBDataDescriptor.cs" /> 247 <Compile Include="Interfaces\I3DOperator.cs" /> 248 <Compile Include="Interfaces\I2DOperator.cs" /> 249 <Compile Include="Interfaces\IPackingMove.cs" /> 259 250 <Compile Include="Interfaces\IPotvinOperator.cs" /> 260 251 <Compile Include="Interfaces\IMultiComponentVectorMoveOperator.cs" /> … … 274 265 <Compile Include="Interfaces\IPackingShape.cs" /> 275 266 <Compile Include="Interfaces\IPackingDimensions.cs" /> 276 <Compile Include="MoveEvaluators\MultiComponentVectorMoveEvaluator.cs" />277 267 <Compile Include="MoveEvaluators\PackingMoveEvaluator.cs" /> 278 <Compile Include="MoveEvaluators\GroupingVectorMoveEvaluator.cs" /> 268 <Compile Include="MoveEvaluators\PackingMoveEvaluator2DGV.cs"> 269 <SubType>Code</SubType> 270 </Compile> 271 <Compile Include="MoveEvaluators\PackingMoveEvaluator2DMCV.cs"> 272 <SubType>Code</SubType> 273 </Compile> 274 <Compile Include="MoveEvaluators\PackingMoveEvaluator3DGV.cs"> 275 <SubType>Code</SubType> 276 </Compile> 277 <Compile Include="MoveEvaluators\PackingMoveEvaluator3DMCV.cs"> 278 <SubType>Code</SubType> 279 </Compile> 279 280 <Compile Include="Problem\BinPackingProblem.cs" /> 281 <Compile Include="Problem\ISOContainerBinPackingProblem.cs" /> 280 282 <Compile Include="Problem\CuboidIdenticalBinPackingProblem.cs" /> 281 283 <Compile Include="Problem\RegularIdenticalBinPackingProblem.cs" /> -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/GroupingVectorMoveEvaluator.cs
r9440 r9495 68 68 69 69 var packingPlan = ExtremePointGroupingVectorDecoder3D.Decode(newSolution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue); 70 CurrentScopeParameter.ActualValue.Variables.Add(new Variable("PackingPlanAfterMove", packingPlan)); 71 70 72 DoubleValue quality = PackingRatioRegularIdenticalBinEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.CalculatePackingRatio( 71 73 packingPlan, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue); -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/MultiComponentVectorMoveEvaluator.cs
r9440 r9495 39 39 [StorableClass] 40 40 public class MultiComponentVectorMoveEvaluator : PackingMoveEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>, ISingleObjectiveMoveEvaluator, IMultiComponentVectorMoveOperator{ 41 public ILookupParameter< MultiComponentVectorMove> MultiComponentVectorMoveParameter {42 get { return (ILookupParameter< MultiComponentVectorMove>)Parameters["MultiComponentVectorMove"]; }41 public ILookupParameter<IPackingMove> MultiComponentVectorMoveParameter { 42 get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; } 43 43 } 44 44 public ILookupParameter<MultiComponentVectorEncoding> MultiComponentVectorParameter { … … 51 51 public MultiComponentVectorMoveEvaluator() 52 52 : base() { 53 Parameters.Add(new LookupParameter<MultiComponentVectorMove>("MultiComponentVectorMove", "The move to evaluate."));53 //Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate.")); 54 54 Parameters.Add(new LookupParameter<MultiComponentVectorEncoding>("MultiComponentVector", "The solution to evaluate.")); 55 55 } … … 60 60 61 61 public override IOperation Apply() { 62 MultiComponentVectorEncoding MultiComponentVector = MultiComponentVectorParameter.ActualValue;63 MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue;62 //MultiComponentVectorEncoding MultiComponentVector = MultiComponentVectorParameter.ActualValue; 63 //MultiComponentVectorMove move = MultiComponentVectorMoveParameter.ActualValue as MultiComponentVectorMove; 64 64 65 MultiComponentVectorEncoding newSolution = new MultiComponentVectorEncoding(); 66 newSolution = move.GetVectorAfterMove(); 65 //MultiComponentVectorEncoding newSolution = new MultiComponentVectorEncoding(); 66 //newSolution = move.GetSolutionAfterMove() as MultiComponentVectorEncoding; 67 //CurrentScopeParameter.ActualValue.Variables.Add(new Variable("MovedSolution", newSolution)); 67 68 68 var packingPlan = ExtremePointMultiComponentVectorDecoder3D.Decode(newSolution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue); 69 DoubleValue quality = PackingRatioRegularIdenticalBinEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.CalculatePackingRatio( 70 packingPlan, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue); 69 //var packingPlan = ExtremePointMultiComponentVectorDecoder3D.Decode(newSolution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue); 70 //CurrentScopeParameter.ActualValue.Variables.Add(new Variable("PackingPlanAfterMove", packingPlan)); 71 71 72 double moveQuality = quality.Value; 72 //DoubleValue quality = PackingRatioRegularIdenticalBinEvaluator<ThreeDimensionalPacking, CuboidPackingBin, CuboidPackingItem>.CalculatePackingRatio( 73 // packingPlan, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue); 73 74 74 if (MoveQualityParameter.ActualValue == null) MoveQualityParameter.ActualValue = new DoubleValue(moveQuality); 75 else MoveQualityParameter.ActualValue.Value = moveQuality; 75 //double moveQuality = quality.Value; 76 77 //if (MoveQualityParameter.ActualValue == null) MoveQualityParameter.ActualValue = new DoubleValue(moveQuality); 78 //else MoveQualityParameter.ActualValue.Value = moveQuality; 76 79 return base.Apply(); 77 80 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/MoveEvaluators/PackingMoveEvaluator.cs
r9440 r9495 24 24 using HeuristicLab.Core; 25 25 using HeuristicLab.Data; 26 using HeuristicLab.Encodings.PackingEncoding.PackingPlan; 26 27 using HeuristicLab.Operators; 27 28 using HeuristicLab.Optimization; 28 29 using HeuristicLab.Parameters; 29 30 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable; 31 using HeuristicLab.Problems.BinPacking.Decoders; 32 using HeuristicLab.Problems.BinPacking.Evaluators; 30 33 using HeuristicLab.Problems.BinPacking.Interfaces; 31 34 using HeuristicLab.Problems.BinPacking.Shapes; … … 36 39 public abstract class PackingMoveEvaluator<D, B, I> : SingleSuccessorOperator, IPackingMoveEvaluator, IMoveOperator 37 40 where D : class, IPackingDimensions 38 where B : PackingShape<D>, IPackingBin 39 where I : PackingShape<D>, IPackingItem {41 where B : PackingShape<D>, IPackingBin, IRegularPackingShape 42 where I : PackingShape<D>, IPackingItem, IRegularPackingShape { 40 43 public override bool CanChangeName { 41 44 get { return false; } … … 60 63 get { return (IValueLookupParameter<IPackingPlanEvaluator>)Parameters["PackingPlanEvaluator"]; } 61 64 } 65 protected ScopeParameter CurrentScopeParameter { 66 get { return (ScopeParameter)Parameters["CurrentScope"]; } 67 } 68 public ILookupParameter<IPackingMove> PackingMoveParameter { 69 get { return (ILookupParameter<IPackingMove>)Parameters["PackingMove"]; } 70 } 62 71 63 72 [StorableConstructor] … … 72 81 Parameters.Add(new ValueLookupParameter<IPackingSolutionDecoder>("PackingSolutionDecoder", "The decoding operator that is used to calculate a packing plan from the used representation.")); 73 82 Parameters.Add(new ValueLookupParameter<IPackingPlanEvaluator>("PackingPlanEvaluator", "The actual packing plan evaluation operator.")); 83 Parameters.Add(new ScopeParameter("CurrentScope", "The current scope where the decoded solution should be added to.")); 84 Parameters.Add(new LookupParameter<IPackingMove>("PackingMove", "The move to evaluate.")); 85 } 86 87 88 89 public override IOperation Apply() { 90 IPackingMove move = PackingMoveParameter.ActualValue; 91 IPackingSolutionEncoding newSolution = move.GetSolutionAfterMove(); 92 CurrentScopeParameter.ActualValue.Variables.Add(new Variable("MovedSolution", newSolution)); 93 94 PackingPlan<D, B, I> packingPlan = (PackingSolutionDecoderParameter.ActualValue as PackingSolutionDecoder<D, B, I>). 95 CreatePackingPlanFromEncoding(newSolution, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue); 96 97 98 CurrentScopeParameter.ActualValue.Variables.Add(new Variable("PackingPlanAfterMove", packingPlan)); 99 100 DoubleValue quality = PackingRatioRegularIdenticalBinEvaluator<D, B, I>.CalculatePackingRatio( 101 packingPlan, PackingBinMeasuresParameter.ActualValue, PackingItemMeasuresParameter.ActualValue); 102 103 double moveQuality = quality.Value; 104 105 if (MoveQualityParameter.ActualValue == null) MoveQualityParameter.ActualValue = new DoubleValue(moveQuality); 106 else MoveQualityParameter.ActualValue.Value = moveQuality; 107 return base.Apply(); 74 108 } 75 109 } -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Plugin.cs
r9473 r9495 26 26 /// Plugin class for HeuristicLab.Problems.BinPacking plugin. 27 27 /// </summary> 28 [Plugin("HeuristicLab.Problems.BinPacking", "3.3.7.94 40")]28 [Plugin("HeuristicLab.Problems.BinPacking", "3.3.7.9473")] 29 29 [PluginFile("HeuristicLab.Problems.BinPacking-3.3.dll", PluginFileType.Assembly)] 30 30 [PluginDependency("HeuristicLab.Common", "3.3")] -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/CuboidIdenticalBinPackingProblem.cs
r9473 r9495 44 44 using HeuristicLab.Problems.Instances; 45 45 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector; 46 using HeuristicLab.Encodings.PackingEncoding.Potvin;47 46 48 47 namespace HeuristicLab.Problems.BinPacking.Problem { … … 120 119 #region Helpers 121 120 protected override void InitializeDecoder() { 121 Operators.RemoveAll(op => typeof(I2DOperator).IsAssignableFrom(op.GetType())); 122 122 123 if (SolutionCreator is PackingSequenceRandomCreator) { 123 124 PackingSolutionDecoder = new ExtremePointPackingSequenceDecoder3D(); … … 126 127 } else if (SolutionCreator is MultiComponentVectorRandomCreator) { 127 128 PackingSolutionDecoder = new ExtremePointMultiComponentVectorDecoder3D(); 128 } else if (SolutionCreator is PotvinRandomCreator) {129 PackingSolutionDecoder = new ExtremePointPotvinDecoder3D();130 129 } else { 131 130 string error = "The given problem does not support the selected solution-creator."; -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RectangularIdenticalBinPackingProblem.cs
r9440 r9495 114 114 #region Helpers 115 115 protected override void InitializeDecoder() { 116 Operators.RemoveAll(op => typeof(I3DOperator).IsAssignableFrom(op.GetType())); 117 116 118 if (SolutionCreator is PackingSequenceRandomCreator) { 117 119 PackingSolutionDecoder = new ExtremePointPackingSequenceDecoder2D(); -
branches/HeuristicLab.BinPacking/HeuristicLab.Problems.BinPacking/3.3/Problem/RegularIdenticalBinPackingProblem.cs
r9473 r9495 43 43 using HeuristicLab.Problems.Instances; 44 44 using HeuristicLab.Encodings.PackingEncoding.MultiComponentVector; 45 using HeuristicLab.Encodings.PackingEncoding.Potvin;46 45 47 46 namespace HeuristicLab.Problems.BinPacking.Problem { … … 67 66 set { PackingBinMeasuresParameter.Value = value; } 68 67 } 69 public IdenticalBinPackingSolutionDecoder<D,B,I, PackingPlan<D,B,I>> PackingSolutionDecoder {70 get { return PackingSolutionDecoderParameter.Value as IdenticalBinPackingSolutionDecoder<D, B, I, PackingPlan<D, B, I>>; }68 public PackingSolutionDecoder<D,B,I> PackingSolutionDecoder { 69 get { return PackingSolutionDecoderParameter.Value as PackingSolutionDecoder<D, B, I>; } 71 70 set { PackingSolutionDecoderParameter.Value = value; } 72 71 } … … 139 138 Operators.AddRange(ApplicationManager.Manager.GetInstances<IMultiComponentVectorOperator>()); 140 139 InitializeDecoder(); 141 } else if (SolutionCreator.GetType() == typeof(PotvinRandomCreator)) {142 Operators.AddRange(ApplicationManager.Manager.GetInstances<IPotvinOperator>());143 InitializeDecoder();144 140 } 145 141 }
Note: See TracChangeset
for help on using the changeset viewer.