Генетический алгоритм

                              int vm = ver.Next(1, 4);

                              potomki[0] = Screshivanie(weightGA[neuron][bestParent[0]], weightGA[neuron][bestParent[vm]]);

                              vm = ver.Next(0, 3);

                              potomki[1] = Screshivanie(weightGA[neuron][bestParent[3]], weightGA[neuron][bestParent[vm]]);

                              vm = ver.Next(0, 4);

                              potomki[2] = Screshivanie(weightGA[neuron][bestParent[1]], weightGA[neuron][bestParent[vm]]);

                              vm = ver.Next(0, 4);

                              potomki[3] = Screshivanie(weightGA[neuron][bestParent[2]], weightGA[neuron][bestParent[vm]]); 

                              vm = ver.Next(0,7);//определяет  для кого из потомков случайным  образом сработает мутация

                              if (vm == 0)

                              {

                                    mutation(potomki[0][0]);

                              }

                              if (vm == 1)

                              {

                                    mutation(potomki[0][1]);

                              }

                              if (vm == 2)

                              {

                                    mutation(potomki[1][0]);

                              }

                              if (vm == 3)

                              {

                                    mutation(potomki[1][1]);

                              }

                              if (vm == 4)

                              {

                                    mutation(potomki[2][0]);

                              }

                              if (vm == 5)

                              {

                                    mutation(potomki[2][1]);

                              }

                              if (vm == 6)

                              {

                                    mutation(potomki[3][0]);

                              }

                              if (vm == 7)

                              {

                                    mutation(potomki[3][1]);

                              }

                              Console.WriteLine("Целевая ф-я потомков");

                              double[][][] temp_weight = new double[kolPopul + kolPopul][][];

                              int nomer = 0;

                              for (int num = 0; num < 4; num++)//переписываем  веса потомков в один массив

                              {

                                    for (int n = 0; n < 2; n++)

                                    {

                                          temp_weight[nomer] = potomki[num][n];

                                          double temp_y = neuro(input_x0, potomki[num][n]).Y;

                                          F_potomki[neuron][nomer] = (0.5*(temp_y - d0[neuron]) * (temp_y - d0[neuron]));//целевая ф-я

                                          Console.WriteLine(F_potomki[neuron][nomer]);

                                          nomer++;

                                    }

                              }

                              for (int num = 0; num < kolPopul; num++)//добавляем к массиву веса родителей

                              {

                                    temp_weight[num + kolPopul] = weightGA[neuron][num];

                              }

                              Console.WriteLine("Целевая  ф-я расширенной популяции");

                              for (int n_osob = 0; n_osob < kolPopul + kolPopul; n_osob++)//вычисляем значение  целевой функции для каждой  особи

                              {

                                    double temp_y = neuro(input_x0, temp_weight[n_osob]).Y;

                                    F_temp[neuron][n_osob] = (0.5*(temp_y - d0[neuron]) * (temp_y - d0[neuron]));//целевая ф-я

                              } 

                              //Удаляем 4 особи  с самым большим значением  целевой функции

                              //на след. итерацию  переходят 4 особи с наименьшими  значениями целевой ф-ции

                              int[] minimum = new int[kolPopul];

                              minimum = NMinIndexesValue(8, F_temp[neuron]); 

                              for (int n = 0; n < kolPopul; n++)//копируем  данные из промежуточного массива   в исходный

                              {

                                    weightGA[neuron][n] = temp_weight[minimum[n]];

                              }

                        } 

                  }

                        Console.ReadKey();

            }

      }

}