protected override List <int> FactibleNeighbors(int i, bool[] visited) { List <int> neighbors = new List <int>(); if (Statistics.RandomUniform() <= this.candidateWeight) { // Only checking the candidate list. foreach (Tuple <double, int> candidate in this.candidateLists[i]) { int j = candidate.Val2; if (i != j && !visited[j]) { neighbors.Add(j); } } } if (neighbors.Count == 0) { // Checking all the neighbors. for (int j = 0; j < Instance.NumberCities; j++) { if (i != j && !visited[j]) { neighbors.Add(j); } } } return(neighbors); }
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; } }
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; } }
public void Run(int timeLimit) { List <double> solutions = new List <double>(); int startTime = Environment.TickCount; int iterationStartTime = 0; int iterationTime = 0; int maxIterationTime = 0; // Generate initial solutions and select the one with the best fitness. // This is also used to choose an initial temperature value. int[] currentSolution = null; double currentFitness = 0; for (int i = 1; i <= InitialSolutions; i++) { int[] solution = InitialSolution(); double solutionFitness = Fitness(solution); if (currentSolution == null || solutionFitness < currentFitness) { currentSolution = solution; currentFitness = solutionFitness; } solutions.Add(solutionFitness); } double temperature = Statistics.StandardDeviation(solutions); BestSolution = currentSolution; BestFitness = currentFitness; maxIterationTime = Environment.TickCount - startTime; while (temperature > 0 && Environment.TickCount - startTime < timeLimit - maxIterationTime) { iterationStartTime = Environment.TickCount; for (int level = 0; level < LevelLength; level++) { int[] newSolution = GetNeighbor(currentSolution); double newFitness = Fitness(newSolution); double fitnessDiff = newFitness - currentFitness; if (fitnessDiff <= 0) { if (newFitness < BestFitness) { BestSolution = newSolution; BestFitness = newFitness; } currentSolution = newSolution; currentFitness = newFitness; } else { double u = Statistics.RandomUniform(); if (u <= Math.Exp(-fitnessDiff / temperature)) { if (newFitness < BestFitness) { BestSolution = newSolution; BestFitness = newFitness; } currentSolution = newSolution; currentFitness = newFitness; } } } // Apply a geometric schema by default. temperature = TempReduction * temperature; iterationTime = Environment.TickCount - iterationStartTime; maxIterationTime = (maxIterationTime < iterationTime) ? iterationTime : maxIterationTime; } }