public Form1()
{
InitializeComponent();
beesUpDown.Value = BeesAlgorithm.getBees();
bestUpDown.Value = BeesAlgorithm.getBest();
eliteUpDown.Value = BeesAlgorithm.getElite();
iterationsUpDown.Value = BeesAlgorithm.getIterations();
bestNeiUpDown.Value = BeesAlgorithm.getBestNeighbourhood();
eliteNeiUpDown.Value = BeesAlgorithm.getEliteNeighbourhood();
seedCheck.Checked = BeesAlgorithm.getSeedSaving();
beesUpDown.Minimum = bestUpDown.Value;
bestUpDown.Maximum = beesUpDown.Value;
bestUpDown.Minimum = eliteUpDown.Value;
eliteUpDown.Maximum = bestUpDown.Value;
bestNeiUpDown.Maximum = eliteNeiUpDown.Value;
eliteNeiUpDown.Minimum = bestNeiUpDown.Value;
chart1.Series.Clear();
callbacks = new CallbackFields(firstLabel, finalLabel, improvementLabel, referenceLabel, errorLabel, chart1);
}
public static void perform(CallbackFields callback)
{
try
{
clear();
Console.WriteLine("Running algorithm with parameters:");
Console.WriteLine("\tIterations: " + ITERATIONS_NUM);
Console.WriteLine("\tBees: " + N_BEES);
Console.WriteLine("\tBest: " + N_BEST_SOLUTIONS);
Console.WriteLine("\tElite: " + N_ELITE);
Console.WriteLine("\tBest neighbourhood: " + BEST_NEIGHBOURHOOD_SIZE);
Console.WriteLine("\tElite neighbourhood: " + ELITE_NEIGHBOURHOOD_SIZE);
Console.WriteLine("\tSeed: " + seed);
CudafyModule km = CudafyTranslator.Cudafy();
GPGPU gpu = CudafyHost.GetDevice(CudafyModes.Target, CudafyModes.DeviceId);
gpu.LoadModule(km);
ReadValuesFromFile("QAPexample2.txt");
double[,] dweights = gpu.Allocate <double>(PROBLEM_SIZE, PROBLEM_SIZE);
double[,] ddistances = gpu.Allocate <double>(PROBLEM_SIZE, PROBLEM_SIZE);
int[,] dpermutations = gpu.Allocate <int>(N_BEES, PROBLEM_SIZE);
double[] dresults = gpu.Allocate <double>(N_BEES);
int NEIGHBOURHOOD_BEES = N_ELITE * ELITE_NEIGHBOURHOOD_SIZE + N_BEST_SOLUTIONS * BEST_NEIGHBOURHOOD_SIZE;
hneighbourhoods = new int[NEIGHBOURHOOD_BEES, PROBLEM_SIZE];
hnresults = new double[NEIGHBOURHOOD_BEES];
int[,] dneighbourhoods = gpu.Allocate <int>(NEIGHBOURHOOD_BEES, PROBLEM_SIZE);
double[] dnresults = gpu.Allocate <double>(NEIGHBOURHOOD_BEES);
gpu.CopyToDevice(hweights, dweights);
gpu.CopyToDevice(hdistances, ddistances);
//losowa inicjalizacja populacji
GenerateRandomPermutations(0, N_BEES);
for (int iteration = 0; iteration < ITERATIONS_NUM; iteration++)
{
gpu.CopyToDevice(hpermutations, dpermutations);
gpu.Launch(N_BEES, 1).calcCosts(dweights, ddistances, dpermutations, dresults);
gpu.CopyFromDevice(dresults, hresults);
//posortowanie permutacji wedlug kosztow
hpermutations = GetSortedPermutationsArray(hpermutations, hresults);
maxOfIteration[iteration] = hresults[0];
if (bestVal > hresults[0])
{
//zapamietanie najlepszego rozwiazania
bestVal = hresults[0];
for (int i = 0; i < PROBLEM_SIZE; i++)
{
bestPerm[i] = hpermutations[0, i];
}
PrintResult("New best");
}
bestFitnesses[iteration] = bestVal;
//przygotowanie danych do generowania sasiedztwa elity
for (int i = 0; i < N_ELITE; i++)
{
for (int j = 0; j < ELITE_NEIGHBOURHOOD_SIZE; j++)
{
int row_nr = i * ELITE_NEIGHBOURHOOD_SIZE + j;
Array.Copy(hpermutations, i * PROBLEM_SIZE, hneighbourhoods, row_nr * PROBLEM_SIZE, PROBLEM_SIZE);
}
}
//przygotowanie danych do generowania sasiedztwa dobrych rozwiazan
for (int i = N_ELITE; i < N_ELITE + N_BEST_SOLUTIONS; i++)
{
for (int j = 0; j < BEST_NEIGHBOURHOOD_SIZE; j++)
{
int row_nr = N_ELITE * ELITE_NEIGHBOURHOOD_SIZE + (i - N_ELITE) * BEST_NEIGHBOURHOOD_SIZE + j;
Array.Copy(hpermutations, i * PROBLEM_SIZE, hneighbourhoods, row_nr * PROBLEM_SIZE, PROBLEM_SIZE);
}
}
//wygenerowanie sasiedztw (losowe zamiany w permutacjach)
for (int i = 0; i < N_ELITE * ELITE_NEIGHBOURHOOD_SIZE + N_BEST_SOLUTIONS * BEST_NEIGHBOURHOOD_SIZE; i++)
{
int ind1 = random.Next(PROBLEM_SIZE);
int ind2 = random.Next(PROBLEM_SIZE); //TODO zapewnic zeby byly rozne?
int tmp = hneighbourhoods[i, ind1];
hneighbourhoods[i, ind1] = hneighbourhoods[i, ind2];
hneighbourhoods[i, ind2] = tmp;
}
//policz wyniki dla sasiedztw
gpu.CopyToDevice(hneighbourhoods, dneighbourhoods);
gpu.Launch(NEIGHBOURHOOD_BEES, 1).calcCosts(dweights, ddistances, dneighbourhoods, dnresults);
gpu.CopyFromDevice(dnresults, hnresults);
//posortuj wyniki dla wszystkich sasiedztw
hneighbourhoods = GetSortedNeibhbourhoodsArray(hneighbourhoods, hnresults);
//wybierz najlepsze permutacje z sasiedztw elity
for (int i = 0; i < N_ELITE; i++)
{
int i_n = i * ELITE_NEIGHBOURHOOD_SIZE;
Array.Copy(hneighbourhoods, i_n * PROBLEM_SIZE, hpermutations, i * PROBLEM_SIZE, PROBLEM_SIZE);
}
//wybierz najlepsze permutacje z sasiedztw dobrych rozwiazan
for (int i = N_ELITE; i < N_ELITE + N_BEST_SOLUTIONS; i++)
{
int i_n = N_ELITE * ELITE_NEIGHBOURHOOD_SIZE + (i - N_ELITE) * BEST_NEIGHBOURHOOD_SIZE;
Array.Copy(hneighbourhoods, i_n * PROBLEM_SIZE, hpermutations, i * PROBLEM_SIZE, PROBLEM_SIZE);
}
//gorsze rozwiazania pomijamy - generujemy nowe losowe permutacje
GenerateRandomPermutations(N_ELITE + N_BEST_SOLUTIONS, N_BEES);
}
PrintResult("Best");
callback.setFirstValue(bestFitnesses[0]);
callback.setFinalValue(bestFitnesses[ITERATIONS_NUM - 1]);
callback.setImprovementValue((bestFitnesses[0] - bestFitnesses[ITERATIONS_NUM - 1]) / bestFitnesses[0] * 100.0);
callback.setDatapoints(bestFitnesses, maxOfIteration);
callback.setReferenceSolution(REFERENCE_SOLUTION);
callback.setError(Math.Abs(bestFitnesses[ITERATIONS_NUM - 1] - REFERENCE_SOLUTION) / REFERENCE_SOLUTION * 100.0);
gpu.FreeAll();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.WriteLine("\nThe end");
}
