public DiscreteSANPS42SP(TwoSPInstance instance, int initialSolutions, int levelLength, double tempReduction) : base(initialSolutions, levelLength, tempReduction) { Instance = instance; generatedSolutions = 0; }
public static void BLLocalSearch2OptFirst(TwoSPInstance instance, int[] ordering) { int tmp; double currentFitness, bestFitness; bestFitness = Fitness(instance, BLCoordinates(instance, ordering)); for (int j = 1; j < ordering.Length; j++) { for (int i = 0; i < j; i++) { // Swap the items. tmp = ordering[j]; ordering[j] = ordering[i]; ordering[i] = tmp; // Evaluate the fitness of this new solution. currentFitness = Fitness(instance, BLCoordinates(instance, ordering)); if (currentFitness < bestFitness) { return; } // Undo the swap. tmp = ordering[j]; ordering[j] = ordering[i]; ordering[i] = tmp; } } }
public DiscretePSONPS42SP(TwoSPInstance instance, int partsCount, double prevConf, double neighConf, int[] lowerBounds, int[] upperBounds) : base(partsCount, prevConf, neighConf, lowerBounds, upperBounds) { Instance = instance; generatedSolutions = 0; }
public DiscreteSSBL42SP(TwoSPInstance instance, int poolSize, int refSetSize, double explorationFactor) : base(poolSize, refSetSize, explorationFactor) { Instance = instance; generatedSolutions = 0; }
public DiscreteSSBL2OptBest42SP(TwoSPInstance instance, int poolSize, int refSetSize, double explorationFactor) : base(poolSize, refSetSize, explorationFactor) { Instance = instance; generatedSolutions = 0; }
public static int[] GetNeighbor(TwoSPInstance instance, int[] solution) { int[] neighbor = new int[instance.NumberItems]; int a = Statistics.RandomDiscreteUniform(0, solution.Length - 1); int b = a; while (b == a) { b = Statistics.RandomDiscreteUniform(0, solution.Length - 1); } for (int i = 0; i < solution.Length; i++) { if (i == a) { neighbor[i] = solution[b]; } else if (i == b) { neighbor[i] = solution[a]; } else { neighbor[i] = solution[i]; } } return(neighbor); }
public DiscreteILSBL2OptBest42SP(TwoSPInstance instance, int restartIterations, int[] lowerBounds, int[] upperBounds) : base(restartIterations, lowerBounds, upperBounds) { Instance = instance; RepairEnabled = true; generatedSolutions = 0; }
public DiscreteUMDANPS42SP(TwoSPInstance instance, int popSize, double truncFactor, int[] lowerBounds, int[] upperBounds) : base(popSize, truncFactor, lowerBounds, upperBounds) { Instance = instance; RepairEnabled = true; }
public DiscretePSOBL2OptBest42SP(TwoSPInstance instance, int partsCount, double prevConf, double neighConf, int[] lowerBounds, int[] upperBounds) : base(partsCount, prevConf, neighConf, lowerBounds, upperBounds) { Instance = instance; LocalSearchEnabled = true; generatedSolutions = 0; }
public void Start(string fileInput, string fileOutput, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(fileInput); int[] ordering = TwoSPUtils.DecreasingArea(instance); int[,] coordinates = TwoSPUtils.NPSCoordinates(instance, ordering); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(fileOutput); }
public MaxMinAntSystemBL2OptBest42SP(TwoSPInstance instance, int numberAnts, double rho, double alpha, double beta, int maxReinit) : base(instance.NumberItems, TwoSPUtils.Fitness(instance, TwoSPUtils.BLCoordinates(instance, TwoSPUtils.RandomSolution(instance))), numberAnts, rho, alpha, beta, maxReinit) { Instance = instance; }
public DiscreteGANPS42SP(TwoSPInstance instance, int popSize, double mutationProbability, int[] lowerBounds, int[] upperBounds) : base(popSize, mutationProbability, lowerBounds, upperBounds) { Instance = instance; RepairEnabled = true; generatedSolutions = 0; }
public MaxMinAntSystemBL42SP(TwoSPInstance instance, int numberAnts, double rho, double alpha, double beta, int maxReinit) : base(instance.NumberItems, TwoSPUtils.Fitness(instance, TwoSPUtils.BLCoordinates(instance, TwoSPUtils.RandomSolution(instance))), numberAnts, rho, alpha, beta, maxReinit) { Instance = instance; }
public void Start(string fileInput, string fileOutput, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(fileInput); int[] ordering = TwoSPUtils.DecreasingWidth(instance); TwoSPUtils.BLLocalSearch2OptBest(instance, ordering); int[,] coordinates = TwoSPUtils.BLCoordinates(instance, ordering); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(fileOutput); }
public void Start(string inputFile, string outputFile, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(inputFile); DiscreteSS ss = new DiscreteSSNPS42SP(instance, poolSize, refSetSize, explorationFactor); ss.Run(timeLimit - timePenalty); int[,] coordinates = TwoSPUtils.NPSCoordinates(instance, ss.BestSolution); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(outputFile); }
public DiscreteGABL42SP(TwoSPInstance instance, int popSize, double mutationProbability, int[] lowerBounds, int[] upperBounds) : base(popSize, mutationProbability, lowerBounds, upperBounds) { Instance = instance; RepairEnabled = true; generatedSolutions = 0; }
public void Start(string fileInput, string fileOutput, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(fileInput); int levelLength = (int) Math.Ceiling(levelLengthFactor * (2 * instance.NumberItems)); DiscreteSA sa = new DiscreteSABL42SP(instance, initialSolutions, levelLength, tempReduction); sa.Run(timeLimit - timePenalty); int[,] coordinates = TwoSPUtils.BLCoordinates(instance, sa.BestSolution); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(fileOutput); }
public void Start(string inputFile, string outputFile, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(inputFile); MaxMinAntSystem aco = new MaxMinAntSystemBL2OptBest42SP(instance, numberAnts, rho, alpha, beta, maxReinit); // Solving the problem and writing the best solution found. aco.Run(timeLimit - timePenalty); int[,] coordinates = TwoSPUtils.BLCoordinates(instance, aco.BestSolution); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(outputFile); }
public void Start(string inputFile, string outputFile, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(inputFile); int neighborChecks = (int) Math.Ceiling(neighborChecksFactor * (2 * instance.NumberItems)); int tabuListLength = (int) Math.Ceiling(tabuListFactor * instance.NumberItems); DiscreteTS ts = new DiscreteTSBL42SP(instance, tabuListLength, neighborChecks); ts.Run(timeLimit - timePenalty); int[,] coordinates = TwoSPUtils.BLCoordinates(instance, ts.BestSolution); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(outputFile); }
public void Start(string fileInput, string fileOutput, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(fileInput); int[] ordering = TwoSPUtils.DecreasingWidth(instance); TwoSPUtils.BLLocalSearch2OptFirst(instance, ordering); int[,] coordinates = TwoSPUtils.BLCoordinates(instance, ordering); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(fileOutput); }
public void Start(string inputFile, string outputFile, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(inputFile); DiscreteSS ss = new DiscreteSSBL42SP(instance, poolSize, refSetSize, explorationFactor); ss.Run(timeLimit - timePenalty); int[,] coordinates = TwoSPUtils.BLCoordinates(instance, ss.BestSolution); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(outputFile); }
// Bottom-Left (BL) placement heuristic. public static int[,] BLCoordinates(TwoSPInstance instance, int[] ordering) { int[,] coordinates = new int[instance.NumberItems,2]; List<int> placedItems = new List<int>(instance.NumberItems); for (int i = 0; i < instance.NumberItems; i++) { BLPlaceItem(instance, coordinates, placedItems, ordering[i]); placedItems.Add(ordering[i]); } return coordinates; }
public void Start(string inputFile, string outputFile, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(inputFile); MaxMinAntSystem aco = new MaxMinAntSystemNPS42SP(instance, numberAnts, rho, alpha, beta, maxReinit); // Solving the problem and writing the best solution found. aco.Run(timeLimit - timePenalty); int[,] coordinates = TwoSPUtils.NPSCoordinates(instance, aco.BestSolution); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(outputFile); }
public void Start(string fileInput, string fileOutput, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(fileInput); int levelLength = (int)Math.Ceiling(levelLengthFactor * (2 * instance.NumberItems)); DiscreteSA sa = new DiscreteSABL42SP(instance, initialSolutions, levelLength, tempReduction); sa.Run(timeLimit - timePenalty); int[,] coordinates = TwoSPUtils.BLCoordinates(instance, sa.BestSolution); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(fileOutput); }
// Bottom-Left (BL) placement heuristic. public static int[,] BLCoordinates(TwoSPInstance instance, int[] ordering) { int[,] coordinates = new int[instance.NumberItems, 2]; List <int> placedItems = new List <int>(instance.NumberItems); for (int i = 0; i < instance.NumberItems; i++) { BLPlaceItem(instance, coordinates, placedItems, ordering[i]); placedItems.Add(ordering[i]); } return(coordinates); }
public void Start(string inputFile, string outputFile, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(inputFile); int neighborChecks = (int)Math.Ceiling(neighborChecksFactor * (2 * instance.NumberItems)); int tabuListLength = (int)Math.Ceiling(tabuListFactor * instance.NumberItems); DiscreteTS ts = new DiscreteTSNPS42SP(instance, tabuListLength, neighborChecks); ts.Run(timeLimit - timePenalty); int[,] coordinates = TwoSPUtils.NPSCoordinates(instance, ts.BestSolution); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(outputFile); }
public static double Distance(TwoSPInstance instance, int[] a, int[] b) { double distance = 0; for (int i = 0; i < a.Length; i++) { if (a[i] != b[i]) { distance += 1; } } return(distance); }
public void Start(string inputFile, string outputFile, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(inputFile); int[] lowerBounds = new int[instance.NumberItems]; int[] upperBounds = new int[instance.NumberItems]; for (int i = 0; i < instance.NumberItems; i++) { lowerBounds[i] = 0; upperBounds[i] = instance.NumberItems - 1; } DiscreteILS ils = new DiscreteILSBL2OptBest42SP(instance, restartIterations, lowerBounds, upperBounds); ils.Run(timeLimit - timePenalty); int[,] coordinates = TwoSPUtils.BLCoordinates(instance, ils.BestSolution); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(outputFile); }
public static int Fitness(TwoSPInstance instance, int[,] coordinates) { int totalHeight = 0; for (int item = 0; item < coordinates.GetLength(0); item++) { int itemHeight = coordinates[item, 1] + instance.ItemsHeight[item]; if (itemHeight > totalHeight) { totalHeight = itemHeight; } } return(totalHeight); }
public static void Repair(TwoSPInstance instance, int[] individual) { int itemsAllocatedCount = 0; bool[] itemsAllocated = new bool[instance.NumberItems]; bool[] itemsRepeated = new bool[instance.NumberItems]; // Get information to decide if the individual is valid. for (int item = 0; item < instance.NumberItems; item++) { if (!itemsAllocated[individual[item]]) { itemsAllocatedCount += 1; itemsAllocated[individual[item]] = true; } else { itemsRepeated[item] = true; } } // If the individual is invalid, make it valid. if (itemsAllocatedCount != instance.NumberItems) { for (int item = 0; item < itemsRepeated.Length; item++) { if (itemsRepeated[item]) { int count = Statistics.RandomDiscreteUniform(1, instance.NumberItems - itemsAllocatedCount); for (int i = 0; i < itemsAllocated.Length; i++) { if (!itemsAllocated[i]) { count -= 1; if (count == 0) { individual[item] = i; itemsRepeated[item] = false; itemsAllocated[i] = true; itemsAllocatedCount += 1; break; } } } } } } }
public static int[] DecreasingArea(TwoSPInstance instance) { int[] solution = new int[instance.NumberItems]; List <Tuple <int, int> > sorting = new List <Tuple <int, int> >(); for (int i = 0; i < instance.NumberItems; i++) { int area = instance.ItemsHeight[i] * instance.ItemsWidth[i]; sorting.Add(new Tuple <int, int>(-area, i)); } sorting.Sort(); for (int i = 0; i < instance.NumberItems; i++) { solution[i] = sorting[i].Val2; } return(solution); }
public static int[] RandomSolution(TwoSPInstance instance) { int[] solution = new int[instance.NumberItems]; List <int> items = new List <int>(); for (int item = 0; item < instance.NumberItems; item++) { items.Add(item); } for (int i = 0; i < instance.NumberItems; i++) { int itemIndex = Statistics.RandomDiscreteUniform(0, items.Count - 1); int item = items[itemIndex]; items.RemoveAt(itemIndex); solution[i] = item; } return(solution); }
public void Start(string inputFile, string outputFile, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(inputFile); int[] lowerBounds = new int[instance.NumberItems]; int[] upperBounds = new int[instance.NumberItems]; for (int i = 0; i < instance.NumberItems; i++) { lowerBounds[i] = 0; upperBounds[i] = instance.NumberItems - 1; } DiscreteILS ils = new DiscreteILSBL2OptBest42SP(instance, restartIterations, perturbations, lowerBounds, upperBounds); ils.Run(timeLimit - timePenalty); int[,] coordinates = TwoSPUtils.BLCoordinates(instance, ils.BestSolution); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(outputFile); }
public void Start(string fileInput, string fileOutput, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(fileInput); // Setting the parameters of the PSO for this instance of the problem. int[] lowerBounds = new int[instance.NumberItems]; int[] upperBounds = new int[instance.NumberItems]; for (int i = 0; i < instance.NumberItems; i++) { lowerBounds[i] = 0; upperBounds[i] = instance.NumberItems - 1; } DiscretePSO pso = new DiscretePSOBL42SP(instance, (int)particlesCount, prevConf, neighConf, lowerBounds, upperBounds); // Solving the problem and writing the best solution found. pso.Run(timeLimit - (int)timePenalty); int[,] coordinates = TwoSPUtils.BLCoordinates(instance, pso.BestPosition); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(fileOutput); }
public static bool IsFeasible(TwoSPInstance instance, int[,] coordinates) { bool[] allocatedItems = new bool[instance.NumberItems]; for (int item = 0; item < allocatedItems.Length; item++) { allocatedItems[item] = true; } for (int item = 0; item < coordinates.GetLength(0); item++) { allocatedItems[item] = false; if (!IsFeasible(instance, coordinates, allocatedItems, item)) { return(false); } allocatedItems[item] = true; } return(true); }
public void Start(string fileInput, string fileOutput, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(fileInput); // Setting the parameters of the MA for this instance of the problem. int[] lowerBounds = new int[instance.NumberItems]; int[] upperBounds = new int[instance.NumberItems]; for (int i = 0; i < instance.NumberItems; i++) { lowerBounds[i] = 0; upperBounds[i] = instance.NumberItems - 1; } DiscreteMA memetic = new DiscreteMABL2OptFirst42SP(instance, (int)popSize, mutProbability, lowerBounds, upperBounds); // Solving the problem and writing the best solution found. memetic.Run(timeLimit - (int)timePenalty); int[,] coordinates = TwoSPUtils.BLCoordinates(instance, memetic.BestIndividual); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(fileOutput); }
public void Start(string fileInput, string fileOutput, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(fileInput); // Setting the parameters of the UMDA for this instance of the problem. int popSize = (int) Math.Ceiling(popFactor * instance.NumberItems); int[] lowerBounds = new int[instance.NumberItems]; int[] upperBounds = new int[instance.NumberItems]; for (int i = 0; i < instance.NumberItems; i++) { lowerBounds[i] = 0; upperBounds[i] = instance.NumberItems - 1; } DiscreteUMDA umda = new DiscreteUMDABL2OptBest42SP(instance, popSize, truncFactor, lowerBounds, upperBounds); // Solving the problem and writing the best solution found. umda.Run(timeLimit - timePenalty); int[,] coordinates = TwoSPUtils.BLCoordinates(instance, umda.BestIndividual); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(fileOutput); }
public void Start(string fileInput, string fileOutput, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(fileInput); // Setting the parameters of the MA for this instance of the problem. int[] lowerBounds = new int[instance.NumberItems]; int[] upperBounds = new int[instance.NumberItems]; for (int i = 0; i < instance.NumberItems; i++) { lowerBounds[i] = 0; upperBounds[i] = instance.NumberItems - 1; } DiscreteMA memetic = new DiscreteMABL42SP(instance, (int)popSize, mutProbability, lowerBounds, upperBounds); // Solving the problem and writing the best solution found. memetic.Run(timeLimit - (int)timePenalty); int[,] coordinates = TwoSPUtils.BLCoordinates(instance, memetic.BestIndividual); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(fileOutput); }
public void Start(string fileInput, string fileOutput, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(fileInput); // Setting the parameters of the PSO for this instance of the problem. int[] lowerBounds = new int[instance.NumberItems]; int[] upperBounds = new int[instance.NumberItems]; for (int i = 0; i < instance.NumberItems; i++) { lowerBounds[i] = 0; upperBounds[i] = instance.NumberItems - 1; } DiscretePSO pso = new DiscretePSOBL2OptBest42SP(instance, (int)particlesCount, prevConf, neighConf, lowerBounds, upperBounds); // Solving the problem and writing the best solution found. pso.Run(timeLimit - (int)timePenalty); int[,] coordinates = TwoSPUtils.BLCoordinates(instance, pso.BestPosition); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(fileOutput); }
public static void BLLocalSearch2OptBest(TwoSPInstance instance, int[] ordering) { int tmp; int firstSwapItem = 0, secondSwapItem = 0; double currentFitness, bestFitness; bestFitness = Fitness(instance, BLCoordinates(instance, ordering)); for (int j = 1; j < ordering.Length; j++) { for (int i = 0; i < j; i++) { // Swap the items. tmp = ordering[j]; ordering[j] = ordering[i]; ordering[i] = tmp; // Evaluate the fitness of this new solution. currentFitness = Fitness(instance, BLCoordinates(instance, ordering)); if (currentFitness < bestFitness) { firstSwapItem = j; secondSwapItem = i; bestFitness = currentFitness; } // Undo the swap. tmp = ordering[j]; ordering[j] = ordering[i]; ordering[i] = tmp; } } // Use the best assignment. if (firstSwapItem != secondSwapItem) { tmp = ordering[firstSwapItem]; ordering[firstSwapItem] = ordering[secondSwapItem]; ordering[secondSwapItem] = tmp; } }
private static double NPSQuality(TwoSPInstance instance, int[,] coordinates, bool[] allocatedItem, int item) { int y = 1; double numerator = 0, denominator; double currentItemHeight, maxHeight = 0; for (int currentItem = 0; currentItem < instance.NumberItems; currentItem++) { if (allocatedItem[currentItem] || currentItem == item) { currentItemHeight = coordinates[currentItem, y] + instance.ItemsHeight[currentItem]; numerator += instance.ItemsWidth[currentItem] * currentItemHeight; if (currentItemHeight > maxHeight) { maxHeight = currentItemHeight; } } } denominator = instance.StripWidth * maxHeight; return(numerator / denominator); }
public void Start(string fileInput, string fileOutput, int timeLimit) { TwoSPInstance instance = new TwoSPInstance(fileInput); // Setting the parameters of the UMDA for this instance of the problem. int popSize = (int)Math.Ceiling(popFactor * instance.NumberItems); int[] lowerBounds = new int[instance.NumberItems]; int[] upperBounds = new int[instance.NumberItems]; for (int i = 0; i < instance.NumberItems; i++) { lowerBounds[i] = 0; upperBounds[i] = instance.NumberItems - 1; } DiscreteUMDA umda = new DiscreteUMDANPS42SP(instance, popSize, truncFactor, lowerBounds, upperBounds); // Solving the problem and writing the best solution found. umda.Run(timeLimit - timePenalty); int[,] coordinates = TwoSPUtils.NPSCoordinates(instance, umda.BestIndividual); TwoSPSolution solution = new TwoSPSolution(instance, coordinates); solution.Write(fileOutput); }
private static bool IsFeasible(TwoSPInstance instance, int[,] coordinates, bool[] allocatedItem, int item) { int x = 0, y = 1; int itemXStart = coordinates[item, x]; int itemXEnd = coordinates[item, x] + instance.ItemsWidth[item]; int itemYStart = coordinates[item, y]; int itemYEnd = coordinates[item, y] + instance.ItemsHeight[item]; // Checking if the item is located inside the strip. if (itemXStart < 0 || itemXEnd > instance.StripWidth) { return(false); } // Check if the item collapses with other item. for (int otherItem = 0; otherItem < coordinates.GetLength(0); otherItem++) { if (allocatedItem[otherItem]) { int otherItemXStart = coordinates[otherItem, x]; int otherItemXEnd = coordinates[otherItem, x] + instance.ItemsWidth[otherItem]; int otherItemYStart = coordinates[otherItem, y]; int otherItemYEnd = coordinates[otherItem, y] + instance.ItemsHeight[otherItem]; if (((otherItemXStart >= itemXStart && otherItemXStart < itemXEnd) || (otherItemXEnd > itemXStart && otherItemXEnd <= itemXEnd)) && ((otherItemYStart >= itemYStart && otherItemYStart < itemYEnd) || (otherItemYEnd > itemYStart && otherItemYEnd <= itemYEnd))) { return(false); } } } return(true); }
private static bool IsFeasible(TwoSPInstance instance, int[,] coordinates, bool[] allocatedItem, int item) { int x = 0, y = 1; int itemXStart = coordinates[item,x]; int itemXEnd = coordinates[item,x] + instance.ItemsWidth[item]; int itemYStart = coordinates[item,y]; int itemYEnd = coordinates[item,y] + instance.ItemsHeight[item]; // Checking if the item is located inside the strip. if (itemXStart < 0 || itemXEnd > instance.StripWidth) { return false; } // Check if the item collapses with other item. for (int otherItem = 0; otherItem < coordinates.GetLength(0); otherItem++) { if (allocatedItem[otherItem]) { int otherItemXStart = coordinates[otherItem,x]; int otherItemXEnd = coordinates[otherItem,x] + instance.ItemsWidth[otherItem]; int otherItemYStart = coordinates[otherItem,y]; int otherItemYEnd = coordinates[otherItem,y] + instance.ItemsHeight[otherItem]; if (((otherItemXStart >= itemXStart && otherItemXStart < itemXEnd) || (otherItemXEnd > itemXStart && otherItemXEnd <= itemXEnd)) && ((otherItemYStart >= itemYStart && otherItemYStart < itemYEnd) || (otherItemYEnd > itemYStart && otherItemYEnd <= itemYEnd))) { return false; } } } return true; }
public static bool IsFeasible(TwoSPInstance instance, int[,] coordinates) { bool[] allocatedItems = new bool[instance.NumberItems]; for (int item = 0; item < allocatedItems.Length; item++) { allocatedItems[item] = true; } for (int item = 0; item < coordinates.GetLength(0); item++) { allocatedItems[item] = false; if (!IsFeasible(instance, coordinates, allocatedItems, item)) { return false; } allocatedItems[item] = true; } return true; }
public static int[] DecreasingArea(TwoSPInstance instance) { int[] solution = new int[instance.NumberItems]; List<Tuple<int,int>> sorting = new List<Tuple<int,int>>(); for (int i = 0; i < instance.NumberItems; i++) { int area = instance.ItemsHeight[i] * instance.ItemsWidth[i]; sorting.Add(new Tuple<int,int>(-area, i)); } sorting.Sort(); for (int i = 0; i < instance.NumberItems; i++) { solution[i] = sorting[i].Val2; } return solution; }
private static double NPSQuality(TwoSPInstance instance, int[,] coordinates, bool[] allocatedItem, int item) { int y = 1; double numerator = 0, denominator; double currentItemHeight, maxHeight = 0; for (int currentItem = 0; currentItem < instance.NumberItems; currentItem++) { if (allocatedItem[currentItem] || currentItem == item) { currentItemHeight = coordinates[currentItem,y] + instance.ItemsHeight[currentItem]; numerator += instance.ItemsWidth[currentItem] * currentItemHeight; if (currentItemHeight > maxHeight) { maxHeight = currentItemHeight; } } } denominator = instance.StripWidth * maxHeight; return numerator / denominator; }
// Normal Pattern Shifting (NPS) placement heuristic. public static int[,] NPSCoordinates(TwoSPInstance instance, int[] ordering) { int x = 0, y = 1; int xpos, ypos; int currentItem; int[,] coordinates = new int[instance.NumberItems,2]; List<int[]> topLeftSeeds = new List<int[]>(instance.NumberItems); List<int[]> bottomRightSeeds = new List<int[]>(instance.NumberItems); bool[] allocatedItems = new bool[instance.NumberItems]; double finalQuality, currentQuality; int[] finalPosition = new int[2]; // Set the coordinates of the first item. currentItem = ordering[0]; coordinates[currentItem,x] = 0; coordinates[currentItem,y] = 0; allocatedItems[currentItem] = true; topLeftSeeds.Add(new int[] {0, instance.ItemsHeight[currentItem]}); bottomRightSeeds.Add(new int[] {instance.ItemsWidth[currentItem], 0}); // Set the coordinates of the rest of the items. for (int i = 1; i < instance.NumberItems; i++) { currentItem = ordering[i]; finalQuality = double.MinValue; foreach (int[] position in topLeftSeeds) { // Move left the item as much as possible. // Check if we can put the item next to the left border of the strip. coordinates[currentItem,x] = 0; coordinates[currentItem,y] = position[y]; if (NPSFeasible(instance, coordinates, allocatedItems, currentItem)) { // If this is valid, it's the best position. finalPosition[x] = coordinates[currentItem,x]; finalPosition[y] = coordinates[currentItem,y]; finalQuality = NPSQuality(instance, coordinates, allocatedItems, currentItem); } else { // Try to put the item next to other items. xpos = int.MaxValue; for (int otherItem = 0; otherItem < instance.NumberItems; otherItem++) { coordinates[currentItem,x] = coordinates[otherItem,x] + instance.ItemsWidth[otherItem]; if (allocatedItems[otherItem] && coordinates[currentItem,x] < xpos) { if (NPSFeasible(instance, coordinates, allocatedItems, currentItem)) { currentQuality = NPSQuality(instance, coordinates, allocatedItems, currentItem); if (currentQuality > finalQuality || (currentQuality == finalQuality && coordinates[currentItem,x] <= finalPosition[x] && coordinates[currentItem,y] <= finalPosition[y])) { xpos = coordinates[currentItem,x]; finalPosition[x] = coordinates[currentItem,x]; finalPosition[y] = coordinates[currentItem,y]; finalQuality = currentQuality; } } } } } } foreach (int[] position in bottomRightSeeds) { // Move down the item as much as possible. // Check if we can put the item at the bottom of the strip. coordinates[currentItem,x] = position[x]; coordinates[currentItem,y] = 0; if (NPSFeasible(instance, coordinates, allocatedItems, currentItem)) { // If this is valid, it's the best position. finalPosition[x] = coordinates[currentItem,x]; finalPosition[y] = coordinates[currentItem,y]; finalQuality = NPSQuality(instance, coordinates, allocatedItems, currentItem); } else { // Try to put the item on top of other item. ypos = int.MaxValue; for (int otherItem = 0; otherItem < instance.NumberItems; otherItem++) { coordinates[currentItem,y] = coordinates[otherItem,y] + instance.ItemsHeight[otherItem]; if (allocatedItems[otherItem] && coordinates[currentItem,y] < ypos) { if (NPSFeasible(instance, coordinates, allocatedItems, currentItem)) { currentQuality = NPSQuality(instance, coordinates, allocatedItems, currentItem); if (currentQuality > finalQuality || (currentQuality == finalQuality && coordinates[currentItem,x] <= finalPosition[x] && coordinates[currentItem,y] <= finalPosition[y])) { ypos = coordinates[currentItem,y]; finalPosition[x] = coordinates[currentItem,x]; finalPosition[y] = coordinates[currentItem,y]; finalQuality = currentQuality; } } } } } } // Set the position of the current item. allocatedItems[currentItem] = true; coordinates[currentItem,x] = finalPosition[x]; coordinates[currentItem,y] = finalPosition[y]; // Update the lists with the seed positions. topLeftSeeds.Add(new int[] {coordinates[currentItem,x], coordinates[currentItem,y] + instance.ItemsHeight[currentItem]}); bottomRightSeeds.Add(new int[] {coordinates[currentItem,x] + instance.ItemsWidth[currentItem], coordinates[currentItem,y]}); } return coordinates; }
private static bool NPSFeasible(TwoSPInstance instance, int[,] coordinates, bool[] allocatedItems, int item) { int x = 0, y = 1; int itemXStart = coordinates[item,x]; int itemXEnd = coordinates[item,x] + instance.ItemsWidth[item]; int itemYStart = coordinates[item,y]; int itemYEnd = coordinates[item,y] + instance.ItemsHeight[item]; bool leftAdjacent = false; bool bottomAdjacent = false; // The left-hand edge and the bottom edges should be both adjacent to other // items or to the edges of the strip. if (itemXStart == 0) leftAdjacent = true; if (itemYStart == 0) bottomAdjacent = true; // Checking if the item is located inside the strip. if (itemXStart < 0 || itemXEnd > instance.StripWidth) { return false; } // Check if the item collapses with other item. for (int otherItem = 0; otherItem < coordinates.GetLength(0); otherItem++) { if (allocatedItems[otherItem]) { int otherItemXStart = coordinates[otherItem,x]; int otherItemXEnd = coordinates[otherItem,x] + instance.ItemsWidth[otherItem]; int otherItemYStart = coordinates[otherItem,y]; int otherItemYEnd = coordinates[otherItem,y] + instance.ItemsHeight[otherItem]; if ((((otherItemXStart >= itemXStart && otherItemXStart < itemXEnd) || (otherItemXEnd > itemXStart && otherItemXEnd <= itemXEnd)) && ((otherItemYStart >= itemYStart && otherItemYStart < itemYEnd) || (otherItemYEnd > itemYStart && otherItemYEnd <= itemYEnd))) || (((otherItemXStart >= itemXStart && otherItemXStart < itemXEnd) || (otherItemXEnd > itemXStart && otherItemXEnd <= itemXEnd)) && (otherItemYStart < itemYStart && otherItemYEnd > itemYEnd)) || (((otherItemYStart >= itemYStart && otherItemYStart < itemYEnd) || (otherItemYEnd > itemYStart && otherItemYEnd <= itemYEnd)) && (otherItemXStart < itemXStart && otherItemXEnd > itemXEnd))) { return false; } // The left-hand edge and the bottom edges should be both adjacent to other // items or to the edges of the strip. if (((otherItemXStart >= itemXStart && otherItemXStart < itemXEnd) || (otherItemXEnd > itemXStart && otherItemXEnd <= itemXEnd)) && (itemYStart == otherItemYEnd)) { bottomAdjacent = true; } if (((otherItemYStart >= itemYStart && otherItemYStart < itemYEnd) || (otherItemYEnd > itemYStart && otherItemYEnd <= itemYEnd)) && (itemXStart == otherItemXEnd)) { leftAdjacent = true; } } } return (leftAdjacent && bottomAdjacent); }
private static void BLPlaceItem(TwoSPInstance instance, int[,] coordinates, List<int> placedItems, int item) { int x = 0, y = 1; int[] currentPosition = new int[2]; int[] oldPosition = new int[2]; bool moveLeft = false, moveDown = true; int itemXStart, itemXEnd, itemYStart, itemYEnd; int otherItemXStart, otherItemXEnd, otherItemYStart, otherItemYEnd; // Setting the starting position. currentPosition[x] = instance.StripWidth - instance.ItemsWidth[item]; currentPosition[y] = int.MaxValue - instance.ItemsHeight[item]; while (moveLeft || moveDown) { if (moveDown) { itemXStart = currentPosition[x]; itemXEnd = itemXStart + instance.ItemsWidth[item]; itemYStart = currentPosition[y]; itemYEnd = itemYStart + instance.ItemsHeight[item]; oldPosition[y] = currentPosition[y]; currentPosition[y] = 0; foreach (int otherItem in placedItems) { otherItemXStart = coordinates[otherItem,x]; otherItemXEnd = otherItemXStart + instance.ItemsWidth[otherItem]; otherItemYStart = coordinates[otherItem,y]; otherItemYEnd = otherItemYStart + instance.ItemsHeight[otherItem]; if ((otherItemXStart >= itemXStart && otherItemXStart < itemXEnd) || (otherItemXEnd > itemXStart && otherItemXEnd <= itemXEnd) || (otherItemXStart < itemXStart && otherItemXEnd > itemXEnd)) { if (otherItemYEnd > currentPosition[y] && otherItemYEnd <= oldPosition[y]) { currentPosition[y] = otherItemYEnd; } } } moveDown = false; moveLeft = currentPosition[y] != oldPosition[y]; } if (moveLeft) { itemXStart = currentPosition[x]; itemXEnd = itemXStart + instance.ItemsWidth[item]; itemYStart = currentPosition[y]; itemYEnd = itemYStart + instance.ItemsHeight[item]; oldPosition[x] = currentPosition[x]; currentPosition[x] = 0; foreach (int otherItem in placedItems) { otherItemXStart = coordinates[otherItem,x]; otherItemXEnd = otherItemXStart + instance.ItemsWidth[otherItem]; otherItemYStart = coordinates[otherItem,y]; otherItemYEnd = otherItemYStart + instance.ItemsHeight[otherItem]; if ((otherItemYStart >= itemYStart && otherItemYStart < itemYEnd) || (otherItemYEnd > itemYStart && otherItemYEnd <= itemYEnd) || (otherItemYStart < itemYStart && otherItemYEnd > itemYEnd)) { if (otherItemXEnd > currentPosition[x] && otherItemXEnd <= oldPosition[x]) { currentPosition[x] = otherItemXEnd; } } } moveLeft = false; moveDown = currentPosition[x] != oldPosition[x]; } } coordinates[item,x] = currentPosition[x]; coordinates[item,y] = currentPosition[y]; }
public static int[] RandomSolution(TwoSPInstance instance) { int[] solution = new int[instance.NumberItems]; List<int> items = new List<int>(); for (int item = 0; item < instance.NumberItems; item++) { items.Add(item); } for (int i = 0; i < instance.NumberItems; i++) { int itemIndex = Statistics.RandomDiscreteUniform(0, items.Count - 1); int item = items[itemIndex]; items.RemoveAt(itemIndex); solution[i] = item; } return solution; }