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 static int[] GetNeighbor(QAPInstance instance, int[] solution) { int[] neighbor = new int[instance.NumberFacilities]; 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 override void LocalSearch(int[] solution) { if (solution[0] >= Instance.NumberSubsets) { solution[0] = Statistics.RandomDiscreteUniform(0, Instance.NumberSubsets - 1); } SPPUtils.LocalSearch2OptBest(Instance, solution); }
protected override double Fitness(int[] solution) { if (solution[0] >= Instance.NumberSubsets) { solution[0] = Statistics.RandomDiscreteUniform(0, Instance.NumberSubsets - 1); } return(SPPUtils.Fitness(Instance, 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); } }
// Generate the initial meme. protected bool[] InitialMeme() { bool[] meme = new bool[LowerBounds.Length]; int points = Statistics.RandomDiscreteUniform(LowerBounds.Length / 3, (2 * LowerBounds.Length) / 3); for (int i = 0; i < points; i++) { meme[Statistics.RandomDiscreteUniform(0, LowerBounds.Length - 1)] = true; } return(meme); }
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); }
protected int[] Combine(int[] a, int[] b) { int point = Statistics.RandomDiscreteUniform(0, a.Length - 1); int[] result = new int[a.Length]; for (int i = 0; i < a.Length; i++) { result[i] = (i <= point) ? a[i] : b[i]; } Repair(result); return(result); }
public static void PerturbateSolution(int[] solution, int perturbations) { int point1 = 0; int point2 = 0; int tmp = 0; for (int i = 0; i < perturbations; i++) { point1 = Statistics.RandomDiscreteUniform(0, solution.Length - 1); point2 = Statistics.RandomDiscreteUniform(0, solution.Length - 1); tmp = solution[point1]; solution[point1] = solution[point2]; solution[point2] = tmp; } }
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 void Repair(TSPInstance instance, int[] individual) { int visitedCitiesCount = 0; bool[] visitedCities = new bool[instance.NumberCities]; bool[] repeatedPositions = new bool[instance.NumberCities]; // Get information to decide if the individual is valid. for (int i = 0; i < instance.NumberCities; i++) { if (!visitedCities[individual[i]]) { visitedCitiesCount += 1; visitedCities[individual[i]] = true; } else { repeatedPositions[i] = true; } } // If the individual is invalid, make it valid. if (visitedCitiesCount != instance.NumberCities) { for (int i = 0; i < repeatedPositions.Length; i++) { if (repeatedPositions[i]) { int count = Statistics.RandomDiscreteUniform(1, instance.NumberCities - visitedCitiesCount); for (int c = 0; c < visitedCities.Length; c++) { if (!visitedCities[c]) { count -= 1; if (count == 0) { individual[i] = c; repeatedPositions[i] = false; visitedCities[c] = true; visitedCitiesCount += 1; break; } } } } } } }
public static void Repair(QAPInstance instance, int[] individual) { int facilitiesCount = 0; bool[] facilitiesUsed = new bool[instance.NumberFacilities]; bool[] facilitiesRepeated = new bool[instance.NumberFacilities]; // Get information to decide if the individual is valid. for (int i = 0; i < instance.NumberFacilities; i++) { if (!facilitiesUsed[individual[i]]) { facilitiesCount += 1; facilitiesUsed[individual[i]] = true; } else { facilitiesRepeated[i] = true; } } // If the individual is invalid, make it valid. if (facilitiesCount != instance.NumberFacilities) { for (int i = 0; i < facilitiesRepeated.Length; i++) { if (facilitiesRepeated[i]) { int count = Statistics.RandomDiscreteUniform(1, instance.NumberFacilities - facilitiesCount); for (int f = 0; f < facilitiesUsed.Length; f++) { if (!facilitiesUsed[f]) { count -= 1; if (count == 0) { individual[i] = f; facilitiesRepeated[i] = false; facilitiesUsed[f] = true; facilitiesCount += 1; break; } } } } } } }
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 static int[] RandomSolution(QAPInstance instance) { int[] solution = new int[instance.NumberFacilities]; List <int> facilities = new List <int>(); for (int facility = 0; facility < instance.NumberFacilities; facility++) { facilities.Add(facility); } for (int i = 0; i < instance.NumberFacilities; i++) { int facilityIndex = Statistics.RandomDiscreteUniform(0, facilities.Count - 1); int facility = facilities[facilityIndex]; facilities.RemoveAt(facilityIndex); solution[i] = facility; } return(solution); }
public static int[] RandomSolution(TSPInstance instance) { int[] solution = new int[instance.NumberCities]; List <int> cities = new List <int>(); for (int city = 0; city < instance.NumberCities; city++) { cities.Add(city); } for (int i = 0; i < instance.NumberCities; i++) { int cityIndex = Statistics.RandomDiscreteUniform(0, cities.Count - 1); int city = cities[cityIndex]; cities.RemoveAt(cityIndex); solution[i] = city; } return(solution); }
protected int[] AntActivity(double[,] pheromone, double[,] heuristic) { int[] tour = new int[tourLength]; bool[] visited = new bool[tourLength]; int selectedNeighbor; double[] probabilities; List <int> neighbors; double denominator; // Select the initial vertex randomly. tour[0] = Statistics.RandomDiscreteUniform(0, tourLength - 1); visited[tour[0]] = true; // Complete the rest of the tour. for (int i = 1; i < tourLength; i++) { neighbors = FactibleNeighbors(tour[i - 1], visited); denominator = 0; for (int j = 0; j < neighbors.Count; j++) { denominator += (Math.Pow(pheromone[tour[i - 1], neighbors[j]], alpha) * Math.Pow(heuristic[tour[i - 1], neighbors[j]], beta)); } probabilities = new double[neighbors.Count]; for (int j = 0; j < neighbors.Count; j++) { probabilities[j] = (Math.Pow(pheromone[tour[i - 1], neighbors[j]], alpha) * Math.Pow(heuristic[tour[i - 1], neighbors[j]], beta)) / denominator; } selectedNeighbor = neighbors[Statistics.SampleRoulette(probabilities)]; visited[selectedNeighbor] = true; tour[i] = selectedNeighbor; } return(tour); }
// Implementation of the GRC solution's construction algorithm. public static int[] GRCSolution(QAPInstance instance, double rclThreshold) { int numFacilities = instance.NumberFacilities; int[] assigment = new int[numFacilities]; int totalFacilities = numFacilities; int index = 0; double best = 0; double cost = 0; int facility = 0; // Restricted Candidate List. SortedList <double, int> rcl = new SortedList <double, int>(); // Available cities. bool[] assigned = new bool[numFacilities]; assigment[0] = Statistics.RandomDiscreteUniform(0, numFacilities - 1); assigned[assigment[0]] = true; index++; numFacilities--; while (numFacilities > 0) { rcl = new SortedList <double, int>(); for (int i = 0; i < totalFacilities; i++) { if (!assigned[i]) { cost = 0; for (int j = 0; j < index; j++) { cost += instance.Distances[j, index] * instance.Flows[assigment[j], i]; } 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); } } } facility = rcl.Values[Statistics.RandomDiscreteUniform(0, rcl.Count - 1)]; assigned[facility] = true; assigment[index] = facility; index++; numFacilities--; } return(assigment); }
public void Run(int timeLimit) { int startTime = Environment.TickCount; int iterationStartTime = 0; int iterationTime = 0; int maxIterationTime = 0; int numVariables = LowerBounds.Length; int[][] population = new int[PopulationSize][]; double[] evaluation = new double[PopulationSize]; int[] parent1 = null; int[] parent2 = null; int[] descend1 = null; int[] descend2 = null; int[][] iterationPopulation = new int[PopulationSize][]; double[] iterationEvaluation = new double[PopulationSize]; int[][] newPopulation = null; double[] newEvaluation = null; // Generate the initial random population. for (int k = 0; k < PopulationSize; k++) { population[k] = new int[numVariables]; for (int i = 0; i < numVariables; i++) { population[k] = InitialSolution(); } } // Run a local search method for each individual in the population. if (LocalSearchEnabled) { for (int k = 0; k < PopulationSize; k++) { LocalSearch(population[k]); } } // Evaluate the population. for (int k = 0; k < PopulationSize; k++) { evaluation[k] = Fitness(population[k]); } Array.Sort(evaluation, population); BestIndividual = population[0]; BestFitness = evaluation[0]; maxIterationTime = Environment.TickCount - startTime; while (Environment.TickCount - startTime < timeLimit - maxIterationTime) { iterationStartTime = Environment.TickCount; newPopulation = new int[PopulationSize][]; newEvaluation = new double[PopulationSize]; // Apply the selection method. if (BestIndividual == null || evaluation[0] < BestFitness) { BestIndividual = population[0]; BestFitness = evaluation[0]; } // Crossover and mutation points. int crossPoint = Statistics.RandomDiscreteUniform(0, numVariables - 1); int mut1stPoint = Statistics.RandomDiscreteUniform(0, numVariables - 1); int mut2ndPoint = Statistics.RandomDiscreteUniform(0, numVariables - 1); for (int i = 0; i < PopulationSize / 2; i++) { // Selection (four individuals tournament). parent1 = population[Math.Min(Math.Min(Statistics.RandomDiscreteUniform(0, PopulationSize - 1), Statistics.RandomDiscreteUniform(0, PopulationSize - 1)), Math.Min(Statistics.RandomDiscreteUniform(0, PopulationSize - 1), Statistics.RandomDiscreteUniform(0, PopulationSize - 1)))]; parent2 = population[Math.Min(Math.Min(Statistics.RandomDiscreteUniform(0, PopulationSize - 1), Statistics.RandomDiscreteUniform(0, PopulationSize - 1)), Math.Min(Statistics.RandomDiscreteUniform(0, PopulationSize - 1), Statistics.RandomDiscreteUniform(0, PopulationSize - 1)))]; // Crossover 1X. descend1 = new int[numVariables]; descend2 = new int[numVariables]; for (int j = 0; j < numVariables; j++) { if (j < crossPoint) { descend1[j] = parent2[j]; descend2[j] = parent1[j]; } else { descend1[j] = parent1[j]; descend2[j] = parent2[j]; } } // Mutation. if (Statistics.RandomUniform() < MutationProbability) { descend1[mut1stPoint] = Statistics.RandomDiscreteUniform(LowerBounds[mut1stPoint], UpperBounds[mut1stPoint]); descend1[mut2ndPoint] = Statistics.RandomDiscreteUniform(LowerBounds[mut2ndPoint], UpperBounds[mut2ndPoint]); descend2[mut1stPoint] = Statistics.RandomDiscreteUniform(LowerBounds[mut1stPoint], UpperBounds[mut1stPoint]); descend2[mut2ndPoint] = Statistics.RandomDiscreteUniform(LowerBounds[mut2ndPoint], UpperBounds[mut2ndPoint]); } iterationPopulation[i] = descend1; iterationPopulation[i + PopulationSize / 2] = descend1; } // Handle constraints using a repairing method. if (RepairEnabled) { for (int k = 0; k < PopulationSize; k++) { Repair(iterationPopulation[k]); } } // Run a local search method for each individual in the population. if (LocalSearchEnabled && Environment.TickCount - startTime < timeLimit) { for (int k = 0; k < PopulationSize; k++) { LocalSearch(iterationPopulation[k]); } } // Evaluate the population. for (int k = 0; k < PopulationSize; k++) { iterationEvaluation[k] = Fitness(iterationPopulation[k]); } Array.Sort(iterationEvaluation, iterationPopulation); // Merge the new populations. int iterationIndex = 0; int existingIndex = 0; for (int k = 0; k < PopulationSize; k++) { if (evaluation[existingIndex] < iterationEvaluation[iterationIndex]) { newPopulation[k] = population[existingIndex]; newEvaluation[k] = evaluation[existingIndex]; existingIndex++; } else { newPopulation[k] = iterationPopulation[iterationIndex]; newEvaluation[k] = iterationEvaluation[iterationIndex]; iterationIndex++; } } population = newPopulation; evaluation = newEvaluation; iterationTime = Environment.TickCount - iterationStartTime; maxIterationTime = (maxIterationTime < iterationTime) ? iterationTime : maxIterationTime; } }
// Implementation of the GRC solution's construction algorithm. public static int[] GRCSolution(TSPInstance instance, double rclThreshold) { int numCities = instance.NumberCities; int[] path = new int[instance.NumberCities]; int totalCities = numCities; int index = 0; double best = 0; double cost = 0; int city = 0; // Restricted Candidate List. SortedList <double, int> rcl = new SortedList <double, int>(); // Available cities. bool[] visited = new bool[numCities]; path[0] = Statistics.RandomDiscreteUniform(0, numCities - 1); visited[path[0]] = true; numCities--; while (numCities > 0) { rcl = new SortedList <double, int>(); for (int i = 0; i < totalCities; i++) { if (!visited[i]) { cost = instance.Costs[path[index], i]; if (rcl.Count == 0) { best = cost; rcl.Add(cost, i); } else if (cost < best) { // The new city 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 city is a mostly good candidate. rcl.Add(cost, i); } } } city = rcl.Values[Statistics.RandomDiscreteUniform(0, rcl.Count - 1)]; index++; visited[city] = true; path[index] = city; numCities--; } return(path); }
public void Run(int timeLimit) { int startTime = Environment.TickCount; int iterationStartTime = 0; int iterationTime = 0; int maxIterationTime = 0; int numVariables = LowerBounds.Length; int selectedSize = Math.Max(1, (int)Math.Round(TruncationFactor * PopulationSize)); int[][] population = new int[PopulationSize][]; double[] evaluation = new double[PopulationSize]; double[][] model = new double[numVariables][]; for (int i = 0; i < numVariables; i++) { model[i] = new double[(UpperBounds[i] - LowerBounds[i]) + 1]; } // Generate the initial random population. for (int k = 0; k < PopulationSize; k++) { population[k] = new int[numVariables]; for (int i = 0; i < numVariables; i++) { population[k][i] = Statistics.RandomDiscreteUniform(LowerBounds[i], UpperBounds[i]); } } BestIndividual = null; maxIterationTime = Environment.TickCount - startTime; while (Environment.TickCount - startTime < timeLimit - maxIterationTime) { iterationStartTime = Environment.TickCount; // Handle constraints using a repairing method. if (RepairEnabled) { for (int k = 0; k < PopulationSize; k++) { Repair(population[k]); } } // Run a local search method for each individual in the population. if (LocalSearchEnabled) { for (int k = 0; k < PopulationSize; k++) { LocalSearch(population[k]); } } // Evaluate the population. for (int k = 0; k < PopulationSize; k++) { evaluation[k] = Fitness(population[k]); } // Apply the selection method. Array.Sort(evaluation, population); if (BestIndividual == null || evaluation[0] < BestFitness) { BestIndividual = population[0]; BestFitness = evaluation[0]; } // Learn the probabilistic model from the selected population. for (int i = 0; i < numVariables; i++) { // Set the counters to zero. for (int k = 0; k <= UpperBounds[i] - LowerBounds[i]; k++) { model[i][k] = 0; } // Count the values of the variable. for (int k = 0; k < selectedSize; k++) { model[i][population[k][i] - LowerBounds[i]] += 1; } // Calculate the frequency of each value of the variable. for (int k = 0; k <= UpperBounds[i] - LowerBounds[i]; k++) { model[i][k] /= selectedSize; } } // Sample the population for the next generation. for (int k = 0; k < PopulationSize; k++) { population[k] = new int[numVariables]; for (int i = 0; i < numVariables; i++) { population[k][i] = LowerBounds[i] + Statistics.SampleRoulette(model[i]); } } iterationTime = Environment.TickCount - iterationStartTime; maxIterationTime = (maxIterationTime < iterationTime) ? iterationTime : maxIterationTime; } }
// 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 Run(int timeLimit) { int startTime = Environment.TickCount; int iterationStartTime = 0; int iterationTime = 0; int maxIterationTime = 0; int numVariables = LowerBounds.Length; int[][] partBestPrevPosition = new int[ParticlesCount][]; int[][] partPosition = new int[ParticlesCount][]; List <Tuple <int, int> >[] partVelocitys = new List <Tuple <int, int> > [ParticlesCount]; double[] partBestPrevFitness = new double[ParticlesCount]; double rp = 1; double rg = 1; // Generate the initial random positions. for (int k = 0; k < ParticlesCount; k++) { partPosition[k] = new int[numVariables]; partVelocitys[k] = new List <Tuple <int, int> >(); partVelocitys[k].Add(new Tuple <int, int>(Statistics.RandomDiscreteUniform(LowerBounds[0], UpperBounds[0]), Statistics.RandomDiscreteUniform(LowerBounds[1], UpperBounds[1]))); partPosition[k] = InitialSolution(); partBestPrevPosition[k] = partPosition[k]; } BestPosition = null; // Run a local search method for each individual in the population. if (LocalSearchEnabled) { for (int k = 0; k < ParticlesCount; k++) { LocalSearch(partPosition[k]); } } // Evaluate the population. partBestPrevFitness[0] = Fitness(partPosition[0]); BestFitness = partBestPrevFitness[0]; BestPosition = partPosition[0]; for (int k = 1; k < ParticlesCount; k++) { partBestPrevFitness[k] = Fitness(partPosition[k]); if (partBestPrevFitness[k] < BestFitness) { BestFitness = partBestPrevFitness[k]; BestPosition = partPosition[k]; } } while (Environment.TickCount - startTime < timeLimit - maxIterationTime) { iterationStartTime = Environment.TickCount; for (int i = 0; i < ParticlesCount; i++) { rg = Statistics.RandomUniform(); rp = Statistics.RandomUniform(); List <Tuple <int, int> > vel = PlusVelocity(partVelocitys[i], PlusVelocity(Times(rp * PreviousConfidence, MinusPosition(partBestPrevPosition[i], partPosition[i])), Times(rg * NeighbourConfidence, MinusPosition(BestPosition, partPosition[i])))); partPosition[i] = Move(partPosition[i], vel); } // Run a local search method for the position of each particle. if (LocalSearchEnabled && Environment.TickCount - startTime < timeLimit) { for (int k = 0; k < ParticlesCount; k++) { LocalSearch(partPosition[k]); } } for (int k = 0; k < ParticlesCount; k++) { double fitness = Fitness(partPosition[k]); if (partBestPrevFitness[k] > fitness) { partBestPrevFitness[k] = fitness; partBestPrevPosition[k] = partPosition[k]; } if (BestFitness > fitness) { BestFitness = fitness; BestPosition = partPosition[k]; } } iterationTime = Environment.TickCount - iterationStartTime; maxIterationTime = (maxIterationTime < iterationTime) ? iterationTime : maxIterationTime; } }
public void Run(int timeLimit) { int startTime = Environment.TickCount; int iterationStartTime = 0; int iterationTime = 0; int maxIterationTime = 0; int numVariables = LowerBounds.Length; KeyValuePair <int[], bool[]>[] population = new KeyValuePair <int[], bool[]> [PopulationSize]; double[] evaluation = new double[PopulationSize]; int parent1 = 0; int parent2 = 0; KeyValuePair <int[], bool[]> descend = new KeyValuePair <int[], bool[]>(null, null); KeyValuePair <int[], bool[]>[] iterationPopulation = new KeyValuePair <int[], bool[]> [PopulationSize]; double[] iterationEvaluation = new double[PopulationSize]; KeyValuePair <int[], bool[]>[] newPopulation = null; double[] newEvaluation = null; // Generate the initial random population. for (int k = 0; k < PopulationSize; k++) { population[k] = new KeyValuePair <int[], bool[]>(InitialSolution(), InitialMeme()); } // Run a local search method for each individual in the population. if (LocalSearchEnabled) { for (int k = 0; k < PopulationSize; k++) { LocalSearch(population[k].Key); } } // Evaluate the population. for (int k = 0; k < PopulationSize; k++) { evaluation[k] = Fitness(population[k].Key); } Array.Sort(evaluation, population); BestIndividual = population[0].Key; BestFitness = evaluation[0]; maxIterationTime = Environment.TickCount - startTime; while (Environment.TickCount - startTime < timeLimit - maxIterationTime) { iterationStartTime = Environment.TickCount; newPopulation = new KeyValuePair <int[], bool[]> [PopulationSize]; newEvaluation = new double[PopulationSize]; // Apply the selection method. if (BestIndividual == null || evaluation[0] < BestFitness) { BestIndividual = population[0].Key; BestFitness = evaluation[0]; } // Mutation points. int mut1stPoint = Statistics.RandomDiscreteUniform(0, numVariables - 1); int mut2ndPoint = Statistics.RandomDiscreteUniform(0, numVariables - 1); for (int i = 0; i < PopulationSize; i++) { // Selection (four individual tournament). parent1 = Math.Min(Math.Min(Statistics.RandomDiscreteUniform(0, PopulationSize - 1), Statistics.RandomDiscreteUniform(0, PopulationSize - 1)), Math.Min(Statistics.RandomDiscreteUniform(0, PopulationSize - 1), Statistics.RandomDiscreteUniform(0, PopulationSize - 1))); parent2 = Math.Min(Math.Min(Statistics.RandomDiscreteUniform(0, PopulationSize - 1), Statistics.RandomDiscreteUniform(0, PopulationSize - 1)), Math.Min(Statistics.RandomDiscreteUniform(0, PopulationSize - 1), Statistics.RandomDiscreteUniform(0, PopulationSize - 1))); if (parent1 > parent2) { int tmp = parent1; parent1 = parent2; parent2 = tmp; } // Crossover with the meme of the best parent. descend = new KeyValuePair <int[], bool[]>(new int[numVariables], population[parent1].Value); for (int j = 0; j < numVariables; j++) { if (descend.Value[j]) { descend.Key[j] = population[parent1].Key[j]; } else { descend.Key[j] = population[parent1].Key[j]; } } // Mutation. if (Statistics.RandomUniform() < MutationProbability) { descend.Key[mut1stPoint] = Statistics.RandomDiscreteUniform(LowerBounds[mut1stPoint], UpperBounds[mut1stPoint]); descend.Key[mut2ndPoint] = Statistics.RandomDiscreteUniform(LowerBounds[mut2ndPoint], UpperBounds[mut2ndPoint]); } iterationPopulation[i] = descend; } // Handle constraints using a repairing method. if (RepairEnabled) { for (int k = 0; k < PopulationSize; k++) { Repair(iterationPopulation[k].Key); } } // Run a local search method for each individual in the population. if (LocalSearchEnabled && Environment.TickCount - startTime < timeLimit) { for (int k = 0; k < PopulationSize; k++) { LocalSearch(iterationPopulation[k].Key); } } // Evaluate the population. for (int k = 0; k < PopulationSize; k++) { iterationEvaluation[k] = Fitness(iterationPopulation[k].Key); } Array.Sort(iterationEvaluation, iterationPopulation); // Merge the new populations. int iterationIndex = 0; int existingIndex = 0; for (int k = 0; k < PopulationSize; k++) { if (evaluation[existingIndex] < iterationEvaluation[iterationIndex]) { newPopulation[k] = population[existingIndex]; newEvaluation[k] = evaluation[existingIndex]; existingIndex++; } else { newPopulation[k] = iterationPopulation[iterationIndex]; newEvaluation[k] = iterationEvaluation[iterationIndex]; iterationIndex++; } } population = newPopulation; evaluation = newEvaluation; iterationTime = Environment.TickCount - iterationStartTime; maxIterationTime = (maxIterationTime < iterationTime) ? iterationTime : maxIterationTime; } }