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