public DiscreteTS4SPP(SPPInstance instance, double rclTreshold, int tabuListLength, int neighborChecks) : base(tabuListLength, neighborChecks) { Instance = instance; RclTreshold = rclTreshold; }
public DiscreteSS2OptFirst4SPP(SPPInstance instance, int poolSize, int refSetSize, double explorationFactor) : base(poolSize, refSetSize, explorationFactor) { Instance = instance; generatedSolutions = 0; }
public DiscreteGA4SPP(SPPInstance instance, int popSize, double mutationProbability, int[] lowerBounds, int[] upperBounds) : base(popSize, mutationProbability, lowerBounds, upperBounds) { Instance = instance; generatedSolutions = 0; }
public MaxMinAntSystem2OptBest4SPP(SPPInstance instance, int numberAnts, double rho, double alpha, double beta, int maxReinit) : base(instance.NumberItems, SPPUtils.Fitness(instance, SPPUtils.RandomSolution(instance)), numberAnts, rho, alpha, beta, maxReinit) { Instance = instance; }
public DiscreteSA4SPP(SPPInstance instance, int initialSolutions, int levelLength, double tempReduction) : base(initialSolutions, levelLength, tempReduction) { Instance = instance; generatedSolutions = 0; }
public MaxMinAntSystem4SPP(SPPInstance instance, int numberAnts, double rho, double alpha, double beta, int maxReinit) : base(instance.NumberItems, SPPUtils.Fitness(instance, SPPUtils.RandomSolution(instance)), numberAnts, rho, alpha, beta, maxReinit) { Instance = instance; }
public DiscreteUMDA4SPP(SPPInstance instance, int popSize, double truncFactor, int[] lowerBounds, int[] upperBounds) : base(popSize, truncFactor, lowerBounds, upperBounds) { Instance = instance; }
// Implementation of the 2-opt (first improvement) local search algorithm. public static void LocalSearch2OptFirst(SPPInstance instance, int[] assignment) { int tmp; double currentFitness, bestFitness; bestFitness = Fitness(instance, assignment); for (int j = 1; j < assignment.Length; j++) { for (int i = 0; i < j; i++) { if (assignment[i] != assignment[j]) { // Swap the items. tmp = assignment[j]; assignment[j] = assignment[i]; assignment[i] = tmp; // Evaluate the fitness of this new solution. currentFitness = Fitness(instance, assignment); if (currentFitness < bestFitness) { return; } // Undo the swap. tmp = assignment[j]; assignment[j] = assignment[i]; assignment[i] = tmp; } } } }
public static int[] GetNeighbor(SPPInstance instance, int[] solution) { int[] neighbor = new int[instance.NumberItems]; int index = Statistics.RandomDiscreteUniform(0, solution.Length - 1); int oldSubset = solution[index]; int newSubset = oldSubset; while (newSubset == oldSubset) { newSubset = Statistics.RandomDiscreteUniform(0, instance.NumberSubsets - 1); } for (int i = 0; i < solution.Length; i++) { if (i == index) { neighbor[i] = newSubset; } else { neighbor[i] = solution[i]; } } return(neighbor); }
public DiscreteUMDA2OptBest4SPP(SPPInstance instance, int popSize, double truncFactor, int[] lowerBounds, int[] upperBounds) : base(popSize, truncFactor, lowerBounds, upperBounds) { Instance = instance; LocalSearchEnabled = true; }
public DiscreteGA2OptFirst4SPP(SPPInstance instance, int popSize, double mutationProbability, int[] lowerBounds, int[] upperBounds) : base(popSize, mutationProbability, lowerBounds, upperBounds) { Instance = instance; LocalSearchEnabled = true; generatedSolutions = 0; }
public DiscreteILS2OptFirst4SPP(SPPInstance instance, int restartIterations, int[] lowerBounds, int[] upperBounds) : base(restartIterations, lowerBounds, upperBounds) { Instance = instance; RepairEnabled = false; generatedSolutions = 0; }
public DiscreteUMDA2OptFirst4SPP(SPPInstance instance, int popSize, double truncFactor, int[] lowerBounds, int[] upperBounds) : base(popSize, truncFactor, lowerBounds, upperBounds) { Instance = instance; LocalSearchEnabled = true; }
public DiscreteGA2OptBest4SPP(SPPInstance instance, int popSize, double mutationProbability, int[] lowerBounds, int[] upperBounds) : base(popSize, mutationProbability, lowerBounds, upperBounds) { Instance = instance; LocalSearchEnabled = true; generatedSolutions = 0; }
public void Start(string fileInput, string fileOutput, int timeLimit) { SPPInstance instance = new SPPInstance(fileInput); int[] assignment = SPPUtils.GRCSolution(instance, 1.0); SPPUtils.LocalSearch2OptFirst(instance, assignment); SPPSolution solution = new SPPSolution(instance, assignment); solution.Write(fileOutput); }
public void Start(string inputFile, string outputFile, int timeLimit) { SPPInstance instance = new SPPInstance(inputFile); DiscreteSS ss = new DiscreteSS4SPP(instance, poolSize, refSetSize, explorationFactor); ss.Run(timeLimit - timePenalty); SPPSolution solution = new SPPSolution(instance, ss.BestSolution); solution.Write(outputFile); }
public DiscreteILS2OptBest4SPP(SPPInstance instance, int restartIterations, int[] lowerBounds, int[] upperBounds) : base(restartIterations, lowerBounds, upperBounds) { Instance = instance; RepairEnabled = false; generatedSolutions = 0; }
public DiscreteHMTSwGRASP2OptFirst4SPP(SPPInstance instance, double rclThreshold, int graspIterations, int tabuListLength, int neighborChecks) : base(tabuListLength, neighborChecks) { GRASP = new DiscreteGRASP2OptFirst4SPP(instance, rclThreshold); Instance = instance; GRASPIterations = graspIterations; }
public void Start(string inputFile, string outputFile, int timeLimit) { SPPInstance instance = new SPPInstance(inputFile); int levelLength = (int) Math.Ceiling(levelLengthFactor * (instance.NumberSubsets - 1)); DiscreteHMSAwGRASP2OptBest4SPP hm = new DiscreteHMSAwGRASP2OptBest4SPP(instance, rclTreshold, graspIterations, initialSolutions, levelLength, tempReduction); hm.Run(timeLimit - timePenalty); SPPSolution solution = new SPPSolution(instance, hm.BestSolution); solution.Write(outputFile); }
public DiscreteHMSAwGRASP2OptFirst4SPP(SPPInstance instance, double rclThreshold, int graspIterations, int initialSolutions, int levelLength, double tempReduction) : base(initialSolutions, levelLength, tempReduction) { GRASP = new DiscreteGRASP2OptFirst4SPP(instance, rclThreshold); Instance = instance; GRASPIterations = graspIterations; }
public void Start(string inputFile, string outputFile, int timeLimit) { SPPInstance instance = new SPPInstance(inputFile); MaxMinAntSystem aco = new MaxMinAntSystem2OptFirst4SPP(instance, numberAnts, rho, alpha, beta, maxReinit); // Solving the problem and writing the best solution found. aco.Run(timeLimit - timePenalty); SPPSolution solution = new SPPSolution(instance, aco.BestSolution); solution.Write(outputFile); }
public void Start(string fileInput, string fileOutput, int timeLimit) { SPPInstance instance = new SPPInstance(fileInput); int levelLength = (int) Math.Ceiling(levelLengthFactor * (instance.NumberSubsets - 1)); DiscreteSA sa = new DiscreteSA4SPP(instance, initialSolutions, levelLength, tempReduction); sa.Run(timeLimit - timePenalty); SPPSolution solution = new SPPSolution(instance, sa.BestSolution); solution.Write(fileOutput); }
public void Start(string inputFile, string outputFile, int timeLimit) { SPPInstance instance = new SPPInstance(inputFile); DiscreteSS ss = new DiscreteSS2OptBest4SPP(instance, poolSize, refSetSize, explorationFactor); ss.Run(timeLimit - timePenalty); SPPSolution solution = new SPPSolution(instance, ss.BestSolution); solution.Write(outputFile); }
public void Start(string inputFile, string outputFile, int timeLimit) { SPPInstance instance = new SPPInstance(inputFile); int neighborChecks = (int) Math.Ceiling(neighborChecksFactor * (instance.NumberSubsets - 1)); int tabuListLength = (int) Math.Ceiling(tabuListFactor * instance.NumberItems); DiscreteTS ts = new DiscreteTS4SPP(instance, rclTreshold, tabuListLength, neighborChecks); ts.Run(timeLimit - timePenalty); SPPSolution solution = new SPPSolution(instance, ts.BestSolution); solution.Write(outputFile); }
public static void PerturbateSolution(SPPInstance instance, int[] solution, int perturbations) { int point1 = 0; for (int i = 0; i < perturbations; i++) { point1 = Statistics.RandomDiscreteUniform(0, solution.Length - 1); solution[point1] = Statistics.RandomDiscreteUniform(0, instance.NumberSubsets - 1); } }
public void Start(string inputFile, string outputFile, int timeLimit) { SPPInstance instance = new SPPInstance(inputFile); int levelLength = (int)Math.Ceiling(levelLengthFactor * (instance.NumberSubsets - 1)); DiscreteHMSAwGRASP2OptBest4SPP hm = new DiscreteHMSAwGRASP2OptBest4SPP(instance, rclTreshold, graspIterations, initialSolutions, levelLength, tempReduction); hm.Run(timeLimit - timePenalty); SPPSolution solution = new SPPSolution(instance, hm.BestSolution); solution.Write(outputFile); }
public void Start(string inputFile, string outputFile, int timeLimit) { SPPInstance instance = new SPPInstance(inputFile); MaxMinAntSystem aco = new MaxMinAntSystem2OptBest4SPP(instance, numberAnts, rho, alpha, beta, maxReinit); // Solving the problem and writing the best solution found. aco.Run(timeLimit - timePenalty); SPPSolution solution = new SPPSolution(instance, aco.BestSolution); solution.Write(outputFile); }
public static int[] RandomSolution(SPPInstance instance) { int[] solution = new int[instance.NumberItems]; for (int i = 0; i < instance.NumberItems; i++) { solution[i] = Statistics.RandomDiscreteUniform(0, instance.NumberSubsets - 1); } return(solution); }
public void Start(string fileInput, string fileOutput, int timeLimit) { SPPInstance instance = new SPPInstance(fileInput); int levelLength = (int)Math.Ceiling(levelLengthFactor * (instance.NumberSubsets - 1)); DiscreteSA sa = new DiscreteSA4SPP(instance, initialSolutions, levelLength, tempReduction); sa.Run(timeLimit - timePenalty); SPPSolution solution = new SPPSolution(instance, sa.BestSolution); solution.Write(fileOutput); }
public static double Distance(SPPInstance 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; }
// Implementation of the GRC solution's construction algorithm. public static int[] GRCSolution(SPPInstance instance, double rclThreshold) { int numItems = instance.NumberItems; int numSets = instance.NumberSubsets; int[] assigment = new int[numItems]; int index = 0; double best = 0; double cost = 0; int setItem = 0; double[] setWeigths = new double[instance.NumberSubsets]; instance.SubsetsWeight.CopyTo(setWeigths, 0); // Restricted Candidate List. SortedList<double, int> rcl = new SortedList<double, int>(); assigment[0] = Statistics.RandomDiscreteUniform(0, numSets-1); index++; numItems --; while (numItems > 0) { rcl = new SortedList<double, int>(); for (int i = 0; i < numSets; i++) { cost = Math.Abs(setWeigths[i] - instance.ItemsWeight[index]); if(rcl.Count == 0) { best = cost; rcl.Add(cost, i); } else if(cost < best) { // The new assignment is the new best; best = cost; for (int j = rcl.Count-1; j > 0; j--) { if (rcl.Keys[j] > rclThreshold * best) { rcl.RemoveAt(j); } else { break; } } rcl.Add(cost, i); } else if (cost < rclThreshold * best) { // The new assigment is a mostly good candidate. rcl.Add(cost, i); } } setItem = rcl.Values[Statistics.RandomDiscreteUniform(0, rcl.Count-1)]; assigment[index] = setItem; setWeigths[setItem] -= instance.ItemsWeight[index]; index++; numItems--; } return assigment; }
public void Start(string fileInput, string fileOutput, int timeLimit) { SPPInstance instance = new SPPInstance(fileInput); // Setting the parameters of the GRASP for this instance of the problem. DiscreteGRASP grasp = new DiscreteGRASP2OptFirst4SPP(instance, rclThreshold); // Solving the problem and writing the best solution found. grasp.Run(timeLimit - (int)timePenalty, RunType.TimeLimit); SPPSolution solution = new SPPSolution(instance, grasp.BestSolution); solution.Write(fileOutput); }
public void Start(string inputFile, string outputFile, int timeLimit) { SPPInstance instance = new SPPInstance(inputFile); int neighborChecks = (int)Math.Ceiling(neighborChecksFactor * (instance.NumberSubsets - 1)); int tabuListLength = (int)Math.Ceiling(tabuListFactor * instance.NumberItems); DiscreteTS ts = new DiscreteTS4SPP(instance, rclTreshold, tabuListLength, neighborChecks); ts.Run(timeLimit - timePenalty); SPPSolution solution = new SPPSolution(instance, ts.BestSolution); solution.Write(outputFile); }
public void Start(string fileInput, string fileOutput, int timeLimit) { SPPInstance instance = new SPPInstance(fileInput); // Setting the parameters of the GRASP for this instance of the problem. DiscreteGRASP grasp = new DiscreteGRASP2OptBest4SPP(instance, rclThreshold); // Solving the problem and writing the best solution found. grasp.Run(timeLimit - (int)timePenalty, RunType.TimeLimit); SPPSolution solution = new SPPSolution(instance, grasp.BestSolution); solution.Write(fileOutput); }
public static double Distance(SPPInstance 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) { SPPInstance instance = new SPPInstance(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.NumberSubsets - 1; } DiscreteILS ils = new DiscreteILS2OptFirst4SPP(instance, restartIterations, lowerBounds, upperBounds); ils.Run(timeLimit - timePenalty); SPPSolution solution = new SPPSolution(instance, ils.BestSolution); solution.Write(outputFile); }
public static double Fitness(SPPInstance instance, int[] assignment) { double deviation = 0; for (int subset = 0; subset < instance.NumberSubsets; subset++) { double subsetWeight = 0; for (int item = 0; item < instance.NumberItems; item++) { if (subset == assignment[item]) { subsetWeight += instance.ItemsWeight[item]; } } deviation += Math.Abs(subsetWeight - instance.SubsetsWeight[subset]); } return deviation; }
public void Start(string fileInput, string fileOutput, int timeLimit) { SPPInstance instance = new SPPInstance(fileInput); // Setting the parameters of the GA 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.NumberSubsets - 1; } DiscreteGA genetic = new DiscreteGA2OptBest4SPP(instance, (int)popSize, mutProbability, lowerBounds, upperBounds); // Solving the problem and writing the best solution found. genetic.Run(timeLimit); SPPSolution solution = new SPPSolution(instance, genetic.BestIndividual); solution.Write(fileOutput); }
public static double Fitness(SPPInstance instance, int[] assignment) { double deviation = 0; for (int subset = 0; subset < instance.NumberSubsets; subset++) { double subsetWeight = 0; for (int item = 0; item < instance.NumberItems; item++) { if (subset == assignment[item]) { subsetWeight += instance.ItemsWeight[item]; } } deviation += Math.Abs(subsetWeight - instance.SubsetsWeight[subset]); } return(deviation); }
public void Start(string fileInput, string fileOutput, int timeLimit) { SPPInstance instance = new SPPInstance(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.NumberSubsets - 1; } DiscreteUMDA umda = new DiscreteUMDA4SPP(instance, popSize, truncFactor, lowerBounds, upperBounds); // Solving the problem and writing the best solution found. umda.Run(timeLimit - (int) timePenalty); SPPSolution solution = new SPPSolution(instance, umda.BestIndividual); solution.Write(fileOutput); }
// Implementation of the 2-opt (best improvement) local search algorithm. public static void LocalSearch2OptBest(SPPInstance instance, int[] assignment) { int tmp; int firstSwapItem = 0, secondSwapItem = 0; double currentFitness, bestFitness; bestFitness = Fitness(instance, assignment); for (int j = 1; j < assignment.Length; j++) { for (int i = 0; i < j; i++) { if (assignment[i] != assignment[j]) { // Swap the items. tmp = assignment[j]; assignment[j] = assignment[i]; assignment[i] = tmp; // Evaluate the fitness of this new solution. currentFitness = Fitness(instance, assignment); if (currentFitness < bestFitness) { firstSwapItem = j; secondSwapItem = i; bestFitness = currentFitness; } // Undo the swap. tmp = assignment[j]; assignment[j] = assignment[i]; assignment[i] = tmp; } } } // Use the best assignment. if (firstSwapItem != secondSwapItem) { tmp = assignment[firstSwapItem]; assignment[firstSwapItem] = assignment[secondSwapItem]; assignment[secondSwapItem] = tmp; } }
public void Start(string fileInput, string fileOutput, int timeLimit) { SPPInstance instance = new SPPInstance(fileInput); // Setting the parameters of the GA 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.NumberSubsets - 1; } DiscreteGA genetic = new DiscreteGA2OptFirst4SPP(instance, (int)popSize, mutProbability, lowerBounds, upperBounds); // Solving the problem and writing the best solution found. genetic.Run(timeLimit); SPPSolution solution = new SPPSolution(instance, genetic.BestIndividual); solution.Write(fileOutput); }
public static int[] GetNeighbor(SPPInstance instance, int[] solution) { int[] neighbor = new int[instance.NumberItems]; int index = Statistics.RandomDiscreteUniform(0, solution.Length - 1); int oldSubset = solution[index]; int newSubset = oldSubset; while (newSubset == oldSubset) { newSubset = Statistics.RandomDiscreteUniform(0, instance.NumberSubsets - 1); } for (int i = 0; i < solution.Length; i++) { if (i == index) { neighbor[i] = newSubset; } else { neighbor[i] = solution[i]; } } return neighbor; }
public void Start(string fileInput, string fileOutput, int timeLimit) { SPPInstance instance = new SPPInstance(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.NumberSubsets - 1; } DiscreteUMDA umda = new DiscreteUMDA2OptBest4SPP(instance, popSize, truncFactor, lowerBounds, upperBounds); // Solving the problem and writing the best solution found. umda.Run(timeLimit - (int)timePenalty); SPPSolution solution = new SPPSolution(instance, umda.BestIndividual); solution.Write(fileOutput); }
// Implementation of the GRC solution's construction algorithm. public static int[] GRCSolution(SPPInstance instance, double rclThreshold) { int numItems = instance.NumberItems; int numSets = instance.NumberSubsets; int[] assigment = new int[numItems]; int index = 0; double best = 0; double cost = 0; int setItem = 0; double[] setWeigths = new double[instance.NumberSubsets]; instance.SubsetsWeight.CopyTo(setWeigths, 0); // Restricted Candidate List. SortedList <double, int> rcl = new SortedList <double, int>(); assigment[0] = Statistics.RandomDiscreteUniform(0, numSets - 1); index++; numItems--; while (numItems > 0) { rcl = new SortedList <double, int>(); for (int i = 0; i < numSets; i++) { cost = Math.Abs(setWeigths[i] - instance.ItemsWeight[index]); if (rcl.Count == 0) { best = cost; rcl.Add(cost, i); } else if (cost < best) { // The new assignment is the new best; best = cost; for (int j = rcl.Count - 1; j > 0; j--) { if (rcl.Keys[j] > rclThreshold * best) { rcl.RemoveAt(j); } else { break; } } rcl.Add(cost, i); } else if (cost < rclThreshold * best) { // The new assigment is a mostly good candidate. rcl.Add(cost, i); } } setItem = rcl.Values[Statistics.RandomDiscreteUniform(0, rcl.Count - 1)]; assigment[index] = setItem; setWeigths[setItem] -= instance.ItemsWeight[index]; index++; numItems--; } return(assigment); }
public SPPSolution(SPPInstance instance, int[] assignment) { Instance = instance; Assignment = assignment; }
public static int[] RandomSolution(SPPInstance instance) { int[] solution = new int[instance.NumberItems]; for (int i = 0; i < instance.NumberItems; i++) { solution[i] = Statistics.RandomDiscreteUniform(0, instance.NumberSubsets - 1); } return solution; }
public static void PerturbateSolution(SPPInstance instance, int[] solution, int perturbations) { int point1 = 0; for (int i = 0; i < perturbations; i++) { point1 = Statistics.RandomDiscreteUniform(0, solution.Length -1 ); solution[point1] = Statistics.RandomDiscreteUniform(0, instance.NumberSubsets - 1); } }