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;
}
}
