public int Genetic(ref Generation g, bool mut_output, GoldbergModel gm)
{
int oldMin = 0;
int repeat = 1;//для людей
g.FillArrayOfPopulation();
gm.vitality(g.quantityProcessors, g.quantityTasks, ref g.ArrayOfTasks, ref g.ArrayOfPopulation,
ref g.ArrayVitality, g.populationSize); //ф-я выживаемости
//using (StreamWriter sw = File.AppendText(Generation.Path))
//{
// sw.WriteLine("Распределение по процессорам в общем диапазоне от 0..255");
//}
//PrintArray(ref g.ArrayOfPopulation, g.populationSize, g.quantityTasks);// вывод матрицы 255 особей
//using (StreamWriter sw = File.AppendText(Generation.Path))
//{
// sw.WriteLine("Определение процессора, подсчет максимальной загрузки");
//}
//PrintArray1(ref g.ArrayOfPopulation, g.populationSize, g.quantityTasks, g.quantityProcessors, ref g.ArrayVitality); //вывод матрицы с ф-й выживаемости
//using (StreamWriter sw = File.AppendText(Generation.Path))
//{
// sw.WriteLine("Результаты поколений");
//}
while (repeat != (Convert.ToInt32(textBox7.Text)))
{
gm.Cross(mut_output, 0, g.quantityTasks, g.populationSize, ref g.ArrayOfPopulation,
g.probabilityСrossing, g.quantityProcessors, g.probabilityMutation, ref g.ArrayOfTasks, ref g.ArrayVitality);//mut_output
if (oldMin == g.ArrayVitality.Min())
{
repeat++;
}
else
{
repeat = 1;
}
oldMin = g.ArrayVitality.Min();
// using (StreamWriter sw = File.AppendText(Generation.Path))
// {
// for (int i = 0; i < g.populationSize; i++)
// {
// sw.Write(setwf(g.ArrayVitality[i].ToString(), 5));
// }
// sw.WriteLine(" = " + g.ArrayVitality.Min());
// }
//PrintArray1(ref g.ArrayOfPopulation, g.quantityTasks, g.populationSize, g.quantityProcessors, ref g.ArrayVitality);
}
return(g.ArrayVitality.Min());
}
//исследование 3
private void backgroundWorker3_DoWork(object sender, DoWorkEventArgs e)
{
Generation g = new Generation(Convert.ToInt32(textBox1.Text), Convert.ToInt32(textBox2.Text),
Convert.ToInt32(textBox3.Text), Convert.ToInt32(textBox4.Text), Convert.ToInt32(textBox5.Text), Convert.ToInt32(textBox9.Text), Convert.ToInt32(textBox10.Text));
float res = 0;
float res_sort1 = 0;
float res_sort2 = 0;
float res_sort3 = 0;
float res_sort1_genetic = 0;
float res_sort2_genetic = 0;
float res_sort3_genetic = 0;
float res_genetic = 0;
float res_genetic2 = 0;
float count_arr = Convert.ToInt32(textBox8.Text);
bool mut_output = false; //отвечает за вывод мутации и скрещивания
if (radioButton1.Checked)
{
mut_output = true;
}
else
{
mut_output = false;
}
AllSort sortTasks = new AllSort();
CriticalPathMethod cmp = new CriticalPathMethod();
GoldbergModel gm = new GoldbergModel();
//int iter = 100 / (int)count_arr;
if (!File.Exists("file.txt")) // для очистки файла
{
using (StreamWriter sw = File.CreateText(Generation.Path)) { }
}
else
{
using (File.Create(Generation.Path)) { }
}
for (int i = 1; i <= count_arr; i++) // рассчет для заданного кол-ва матриц
{
if (backgroundWorker3.CancellationPending) //если поток приостановлен
{
e.Cancel = true;
}
else // выполнение хода исследования
{
using (StreamWriter sw = File.AppendText(Generation.Path))
{
sw.WriteLine("Начальная матрица заданий");
}
g.FillArrayOfTasks(); // заполняем матрицу произвольными значениями
PrintArray(ref g.ArrayOfTasks, g.quantityTasks, g.quantityProcessors);
//одну и ту же матрицу распледеляем разлисными способами:
using (StreamWriter sw = File.AppendText(Generation.Path))
{
sw.WriteLine("Распределение заданий методом критического пути без элиты.");
}
res += cmp.distributionByProcessors(true, g.quantityTasks, g.quantityProcessors, ref g.ArrayOfTasks, ref g.ArrayOfPopulation, 0); // 1) обычным методом критического пути
using (StreamWriter sw = File.AppendText(Generation.Path))
{
sw.WriteLine("Максимальная загрузка " + res);
sw.WriteLine("Генетическим алгоритмом без элиты");
}
res_genetic += Genetic(ref g, mut_output, gm); //2) генетическим алгоритмом
sortTasks.Sort1Tasks(g.quantityProcessors, g.quantityProcessors, ref g.ArrayOfTasks);
res_sort1 += cmp.distributionByProcessors(false, g.quantityTasks, g.quantityProcessors, ref g.ArrayOfTasks, ref g.ArrayOfPopulation, 0); //3) методом критического пути с модификацией 1
res_sort1_genetic += SortArr(ref g, mut_output, 1, gm); // 4) генетическим, где этита(особь 0) получена методом критического пути с модификацией 1
//res_sort1_genetic += Genetic(ref g, mut_output, gm); // генетическим алгоритмом где нач. матрица получена модификаей 1, без элиты
sortTasks.Sort2Tasks(g.quantityProcessors, g.quantityProcessors, ref g.ArrayOfTasks);
res_sort2 += cmp.distributionByProcessors(false, g.quantityTasks, g.quantityProcessors, ref g.ArrayOfTasks, ref g.ArrayOfPopulation, 0); //5) методом критического пути с модификацией 2
res_sort2_genetic += SortArr(ref g, mut_output, 2, gm); //6) генетическим, где этита(особь 0) получена методом критического пути с модификацией 2
//res_sort2_genetic += Genetic(ref g, mut_output, gm); // генетическим алгоритмом где нач. матрица получена модификаей 1, без элиты
sortTasks.Sort3Tasks(g.quantityProcessors, g.quantityProcessors, ref g.ArrayOfTasks);
res_sort3 += cmp.distributionByProcessors(false, g.quantityTasks, g.quantityProcessors, ref g.ArrayOfTasks, ref g.ArrayOfPopulation, 0); //7) методом критического пути с модификацией 3
res_sort3_genetic += SortArr(ref g, mut_output, 3, gm); // 8) генетическим, где этита(особь 0) получена методом критического пути с модификацией 3
//res_sort3_genetic += Genetic(ref g, mut_output, gm); // генетическим алгоритмом где нач. матрица получена модификаей 1, без элиты
backgroundWorker3.ReportProgress(i);
}
}
using (StreamWriter sw = File.AppendText(Generation.Path))
{
result += "Обычное распределение = " + (res / count_arr) + Environment.NewLine;
sw.WriteLine("Обычное распределение = " + (res / count_arr));
result += "Генетический алгоритм без элиты = " + (res_genetic / count_arr) + Environment.NewLine;
sw.WriteLine("Генетический алгоритм без элиты = " + (res_genetic / count_arr));
//result += "Генетический алгоритм - нач. поколение элита = " + (res_genetic2 / count_arr) + Environment.NewLine;
//sw.WriteLine("Генетический алгоритм - нач. поколение элита = " + (res_genetic2 / count_arr));
result += "Модификации: " + Environment.NewLine;
result += "Сортировка 1 = " + (res_sort1 / count_arr) + Environment.NewLine;
result += "Сортировка 2 = " + (res_sort2 / count_arr) + Environment.NewLine;
result += "Сортировка 3 = " + (res_sort3 / count_arr) + Environment.NewLine;
sw.WriteLine("Модификации");
sw.WriteLine("Среднее максимальное значение для " + count_arr + " матриц сортировкой1 = " + (res_sort1 / count_arr));
sw.WriteLine("Среднее максимальное значение для " + count_arr + " матриц сортировкой2 = " + (res_sort2 / count_arr));
sw.WriteLine("Среднее максимальное значение для " + count_arr + " матриц сортировкой3 = " + (res_sort3 / count_arr));
result += "Генетический алгоритм с элитой" + Environment.NewLine;
result += "Сортировка 1 = " + (res_sort1_genetic / count_arr) + Environment.NewLine;
result += "Сортировка 2 = " + (res_sort2_genetic / count_arr) + Environment.NewLine;
result += "Сортировка 3 = " + (res_sort3_genetic / count_arr) + Environment.NewLine;
sw.WriteLine("Генетический алгоритм с элитой");
sw.WriteLine("Среднее максимальное значение для " + count_arr + " матриц сортировкой1 = " + (res_sort1_genetic / count_arr));
sw.WriteLine("Среднее максимальное значение для " + count_arr + " матриц сортировкой2 = " + (res_sort2_genetic / count_arr));
sw.WriteLine("Среднее максимальное значение для " + count_arr + " матриц сортировкой3 = " + (res_sort3_genetic / count_arr));
}
}
//исследование 2
private void backgroundWorker2_DoWork(object sender, DoWorkEventArgs e)
{
Generation g = new Generation(Convert.ToInt32(textBox1.Text), Convert.ToInt32(textBox2.Text),
Convert.ToInt32(textBox3.Text), Convert.ToInt32(textBox4.Text), Convert.ToInt32(textBox5.Text),
Convert.ToInt32(textBox9.Text), Convert.ToInt32(textBox10.Text));
float res = 0;
float res_genetic = 0;
float temp = 0;
float num_less = 0;
float num_more = 0;
float num_equal = 0;
float count_arr = Convert.ToInt32(textBox8.Text);
bool mut_output = false; //отвечает за вывод мутации и скрещивания
if (radioButton1.Checked)
{
mut_output = true;
}
else
{
mut_output = false;
}
AllSort sortTasks = new AllSort();
CriticalPathMethod cmp = new CriticalPathMethod();
GoldbergModel gm = new GoldbergModel();
if (!File.Exists("file.txt")) // для очистки файла
{
using (StreamWriter sw = File.CreateText(Generation.Path)) { }
}
else
{
using (File.Create(Generation.Path)) { }
}
/* Формирование начальной матрицы */
using (StreamWriter sw = File.AppendText(Generation.Path))
{
sw.WriteLine("Начальная матрица заданий");
}
for (int h = 1; h <= Convert.ToInt32(textBox11.Text); h++) //основной цикл прогона матриц !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
{
if (backgroundWorker2.CancellationPending)
{
e.Cancel = true;
}
else
{
g.FillArrayOfTasks(); // заполняем матрицу произвольными значениями
//PrintArray(ref g.ArrayOfTasks, g.quantityTasks, g.quantityProcessors);
//одну и ту же матрицу распледеляем разлиными способами:
num_equal = 0; num_less = 0; num_more = 0; res_genetic = 0;
using (StreamWriter sw = File.AppendText(Generation.Path))
{
sw.WriteLine("Распределение заданий методом критического пути без элиты.");
sw.WriteLine("Осталось запусков: " + h);
}
res = cmp.distributionByProcessors(false, g.quantityTasks, g.quantityProcessors, ref g.ArrayOfTasks, ref g.ArrayOfPopulation, 0); // 1) обычным методом критического пути
for (int i = 0; i < count_arr; i++) // рассчет для заданного кол-ва матриц
{
temp = Genetic(ref g, mut_output, gm); //2) генетическим алгоритмом
res_genetic += temp;
if (res == temp)
{
num_equal++;
}
else if (res > temp)
{
num_less++;
}
else
{
num_more++;
}
}
using (StreamWriter sw = File.AppendText(Generation.Path))
{
// textBox6.Text += "Без модификаций" + Environment.NewLine;
// textBox6.Text += "Методом критического пути " + res + Environment.NewLine;
// textBox6.Text += "Среднее значение генетическим алгоритмом: " + (res_genetic / count_arr) + Environment.NewLine;
// textBox6.Text += "Равных значений: " + num_equal + ", больше: " + num_more + ", меньше: " + num_less + Environment.NewLine;
sw.WriteLine("Без модификаций");
sw.WriteLine("Методом критического пути " + res);
sw.WriteLine("Среднее значение генетическим алгоритмом: " + (res_genetic / count_arr));
sw.WriteLine("Равных значений: " + num_equal + ", больше: " + num_more + ", меньше: " + num_less);
}
num_equal = 0; num_less = 0; num_more = 0; res_genetic = 0;
sortTasks.Sort1Tasks(g.quantityProcessors, g.quantityProcessors, ref g.ArrayOfTasks);
res = cmp.distributionByProcessors(false, g.quantityTasks, g.quantityProcessors, ref g.ArrayOfTasks, ref g.ArrayOfPopulation, 0); //3) методом критического пути с модификацией 1
for (int i = 0; i < count_arr; i++) // рассчет для заданного кол-ва матриц
{
temp = Genetic(ref g, mut_output, gm); // генетическим алгоритмом где нач. матрица получена модификаей 1, без элиты
res_genetic += temp;
if (res == temp) //подсчитываем сколько из результатов методом МКП больше генетического, сколько меньше, сколько равно.
{
num_equal++;
}
else if (res > temp)
{
num_less++;
}
else
{
num_more++;
}
}
using (StreamWriter sw = File.AppendText(Generation.Path))
{
result += "Модификация 1" + Environment.NewLine;
result += "Методом критического пути " + res + Environment.NewLine;
result += "Среднее значение генетическим алгоритмом: " + (res_genetic / count_arr) + Environment.NewLine;
result += "Равных значений: " + num_equal + ", больше: " + num_more + ", меньше: " + num_less + Environment.NewLine;
sw.WriteLine("Модификация 1");
sw.WriteLine("Методом критического пути " + res);
sw.WriteLine("Среднее значение генетическим алгоритмом: " + (res_genetic / count_arr));
sw.WriteLine("Равных значений: " + num_equal + ", больше: " + num_more + ", меньше: " + num_less);
}
num_equal = 0; num_less = 0; num_more = 0; res_genetic = 0;
sortTasks.Sort2Tasks(g.quantityProcessors, g.quantityProcessors, ref g.ArrayOfTasks);
res = cmp.distributionByProcessors(false, g.quantityTasks, g.quantityProcessors, ref g.ArrayOfTasks, ref g.ArrayOfPopulation, 0); //5) методом критического пути с модификацией 2
//res_sort2_genetic += SortArr(ref g, mut_output, 2, gm); //6) генетическим, где этита(особь 0) получена методом критического пути с модификацией 2
for (int i = 0; i < count_arr; i++) // рассчет для заданного кол-ва матриц
{
temp = Genetic(ref g, mut_output, gm); // генетическим алгоритмом где нач. матрица получена модификаей 1, без элиты
res_genetic += temp;
if (res == temp)
{
num_equal++;
}
else if (res > temp)
{
num_less++;
}
else
{
num_more++;
}
}
using (StreamWriter sw = File.AppendText(Generation.Path))
{
result += "Модификация 2" + Environment.NewLine;
result += "Методом критического пути " + res + Environment.NewLine;
result += "Среднее значение генетическим алгоритмом: " + (res_genetic / count_arr) + Environment.NewLine;
result += "Равных значений: " + num_equal + ", больше: " + num_more + ", меньше: " + num_less + Environment.NewLine;
sw.WriteLine("Модификация 2");
sw.WriteLine("Методом критического пути " + res);
sw.WriteLine("Среднее значение генетическим алгоритмом: " + (res_genetic / count_arr));
sw.WriteLine("Равных значений: " + num_equal + ", больше: " + num_more + ", меньше: " + num_less);
}
num_equal = 0; num_less = 0; num_more = 0; res_genetic = 0;
sortTasks.Sort3Tasks(g.quantityProcessors, g.quantityProcessors, ref g.ArrayOfTasks);
res = cmp.distributionByProcessors(false, g.quantityTasks, g.quantityProcessors, ref g.ArrayOfTasks, ref g.ArrayOfPopulation, 0); //7) методом критического пути с модификацией 3
for (int i = 0; i < count_arr; i++) // рассчет для заданного кол-ва матриц
{
temp = Genetic(ref g, mut_output, gm); // генетическим алгоритмом где нач. матрица получена модификаей 1, без элиты
res_genetic += temp;
if (res == temp)
{
num_equal++;
}
else if (res > temp)
{
num_less++;
}
else
{
num_more++;
}
}
using (StreamWriter sw = File.AppendText(Generation.Path))
{
result += "Модификация 3" + Environment.NewLine;
result += "Методом критического пути " + res + Environment.NewLine;
result += "Среднее значение генетическим алгоритмом: " + (res_genetic / count_arr) + Environment.NewLine;
result += "Равных значений: " + num_equal + ", больше: " + num_more + ", меньше: " + num_less + Environment.NewLine;
sw.WriteLine("Модификация 3");
sw.WriteLine("Методом критического пути " + res);
sw.WriteLine("Среднее значение генетическим алгоритмом: " + (res_genetic / count_arr));
sw.WriteLine("Равных значений: " + num_equal + ", больше: " + num_more + ", меньше: " + num_less);
}
backgroundWorker2.ReportProgress(h);
}
}
}
public int SortArr(ref Generation g, bool mut_output, int numberSort, GoldbergModel gm)
{
int oldMin = 0;
int repeat = 1;//для людей
AllSort sortTasks = new AllSort();
CriticalPathMethod cmp = new CriticalPathMethod();
int[][] ar;
using (StreamWriter sw = File.AppendText(Generation.Path))
{
switch (numberSort)
{
case 1:
sw.WriteLine("Отсортированная матрица заданий (модификация 1)");
ar = sortTasks.Sort1Tasks(g.quantityTasks, g.quantityProcessors, ref g.ArrayOfTasks);
break;
case 2:
sw.WriteLine("Отсортированная матрица заданий (модификация 2)");
ar = sortTasks.Sort2Tasks(g.quantityTasks, g.quantityProcessors, ref g.ArrayOfTasks);
break;
case 3:
sw.WriteLine("Отсортированная матрица заданий (модификация 3)");
ar = sortTasks.Sort3Tasks(g.quantityTasks, g.quantityProcessors, ref g.ArrayOfTasks);
break;
}
}
PrintArray(ref g.ArrayOfTasks, g.quantityTasks, g.quantityProcessors);
using (StreamWriter sw = File.AppendText(Generation.Path))
{
sw.WriteLine("Распределение задач по процессорам");
}
g.FillArrayOfPopulation(); //заполнение до распределения по процессорам т.к так при распределении формируется эоитная особь
int z = cmp.distributionByProcessors(false, g.quantityTasks, g.quantityProcessors, ref g.ArrayOfTasks, ref g.ArrayOfPopulation, 0); //тут записывается элитная особь 0
using (StreamWriter sw = File.AppendText(Generation.Path))
{
sw.WriteLine("Максимальная загрузка " + z);
}
using (StreamWriter sw = File.AppendText(Generation.Path))
{
sw.WriteLine("Генетическим алгоритмом, где этита(особь 0) получена методом критического пути с модификацией 1");
sw.WriteLine("Матрица особей");
}
gm.vitality(g.quantityProcessors, g.quantityTasks, ref g.ArrayOfTasks, ref g.ArrayOfPopulation,
ref g.ArrayVitality, g.populationSize); //ф-я выживаемости
PrintArray(ref g.ArrayOfPopulation, g.populationSize, g.quantityTasks); // вывод матрицы 255 особей
PrintArray1(ref g.ArrayOfPopulation, g.populationSize, g.quantityTasks, g.quantityProcessors, ref g.ArrayVitality); //вывод матрицы с ф-й выживаемости
if (Revolution(ref g))
{
PrintArray1(ref g.ArrayOfPopulation, g.populationSize, g.quantityTasks, g.quantityProcessors, ref g.ArrayVitality); //вывод матрицы с ф-й выживаемости
}
using (StreamWriter sw = File.AppendText(Generation.Path))
{
sw.WriteLine("Результаты поколений");
}
while (repeat != (Convert.ToInt32(textBox7.Text)))
{
gm.Cross(mut_output, 1, g.quantityTasks, g.populationSize, ref g.ArrayOfPopulation,
g.probabilityСrossing, g.quantityProcessors, g.probabilityMutation, ref g.ArrayOfTasks, ref g.ArrayVitality); //элита в скрещивании не участвует. mut_output
if (oldMin == g.ArrayVitality.Min())
{
repeat++;
}
else
{
repeat = 1;
}
oldMin = g.ArrayVitality.Min();
using (StreamWriter sw = File.AppendText(Generation.Path))
{
for (int i = 0; i < g.populationSize; i++)
{
sw.Write(setwf(g.ArrayVitality[i].ToString(), 5));
}
sw.WriteLine(" = " + g.ArrayVitality.Min());
}
}
return(g.ArrayVitality.Min());
}