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

                  input_x0[4][0] = 0;

                  input_x0[4][1] = 1;

                  input_x0[4][2] = 1;

                  input_x0[4][3] = 1;

                  input_x0[4][4] = 0; 

                  //тестовая матрица  для 1

                  input_x1[0][0] = 0;

                  input_x1[0][1] = 0;

                  input_x1[0][2] = 1;

                  input_x1[0][3] = 0;

                  input_x1[0][4] = 0; 

                  input_x1[1][0] = 0;

                  input_x1[1][1] = 1;

                  input_x1[1][2] = 1;

                  input_x1[1][3] = 0;

                  input_x1[1][4] = 0; 

                  input_x1[2][0] = 0;

                  input_x1[2][1] = 0;

                  input_x1[2][2] = 1;

                  input_x1[2][3] = 0;

                  input_x1[2][4] = 0; 

                  input_x1[3][0] = 0;

                  input_x1[3][1] = 0;

                  input_x1[3][2] = 1;

                  input_x1[3][3] = 0;

                  input_x1[3][4] = 0; 

                  input_x1[4][0] = 0;

                  input_x1[4][1] = 0;

                  input_x1[4][2] = 1;

                  input_x1[4][3] = 0;

                  input_x1[4][4] = 0; 

                  double nu = 0.01;//скорость  обучения,которая на самом деле  никакая ни скорость а шаг  изменения веса

                  SandY[] neuro_data = new SandY[2];

                  double[] y = new double[2];//результат

                  double[] d0 = new double[2];//идеальные значения для 0

                  double[] d1 = new double[2];//идеальные  значения для 1

                  d0[0] = 1.0;

                  d0[1] = 0.0;

                  d1[0] = 0.0;

                  d1[1] = 1.0;

                  int step = 0;

                  double[] delta = new double[2];

                  /*

                  Console.WriteLine("=============================================");

                  Console.WriteLine("по алгоритму  обратного распространения ошибки");

                  Console.WriteLine("=============================================");

                  /////////////////////////////////////////////////

                  //по алгоритму  обратного распространения ошибки//

                  /////////////////////////////////////////////////

                  while(step <=1000000)

                  {

                        step++;

                        for (int neuron = 0; neuron < 2; neuron ++ )//всего два нейрона

                        {

                              neuro_data[neuron] = neuro(input_x0, weight[neuron]);

                              Console.Write("Нейрон: {0} Y={1} S={2}\n\n", neuron, neuro_data[neuron].Y, neuro_data[neuron].S);

                        }

                        if (Math.Abs(neuro_data[0].Y - neuro_data[1].Y) >= 0.9)

                              break;

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

                        {

                              delta[neuron] = (d0[neuron] - neuro_data[neuron].Y) * neuro_data[neuron].Y * (1 - neuro_data[neuron].Y);

                              for (int i = 0; i < 5; i++)

                              {

                                    for (int j = 0; j < 5; j++)

                                    {

                                          weight[neuron][i][j] = weight[neuron][i][j] - nu * delta[neuron] * input_x0[i][j];

                                    }

                              }

                        }

                  }

                  if (neuro_data[0].Y > neuro_data[1].Y)

                        Console.WriteLine("Результат 0");

                  else

                        Console.WriteLine("Результат 1");

                  */

                  //////////////////////////////

                  //по генетическому  алгоритму//

                  //////////////////////////////

                  Console.WriteLine("=============================================");

                  Console.WriteLine("=========по  генетическому алгоритму==========");

                  Console.WriteLine("=============================================");

                  //целевая функция  - это функция ошибки нейрона  E(w) = 1/2*(y-d)^2

                  // где y - реальное  значение ф-ции активизации для  нейрона, d - идеальное значенние

                  int kolPopul = 8;

                  double[][][][] weightGA = new double[2][][][];//матрицы весов для 2-х нейронов

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

                  {

                        weightGA[n] = new double[kolPopul][][];//матрицы весов для 4-х особей каждого нейрона

                        seed = 0;

                        for (int o = 0; o < kolPopul; o++)//заполняем  веса случайными значениями от 0,0 до 0,1

                        {

                              weightGA[n][o] = new double[5][];

                              for (int i = 0; i < 5; i++)

                              {

                                    weightGA[n][o][i] = new double[5];

                                    for (int j = 0; j < 5; j++)

                                    {

                                          //Console.WriteLine(new Random(seed).NextDouble()*0.1);

                                          weightGA[n][o][i][j] = new Random(seed).NextDouble() * 0.1;

                                          seed++;

                                    }

                              }

                        }

                  }

                  double[][] F = new double[2][]; // массив для хранения значений  целевой функции для 4-х поколеий  для двух нейронов

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

                  {

                        F[n] = new double[kolPopul];

                  }

                  double[][] F_temp = new double[2][]; // массив для хранения значений  целевой функции для расширенной  популяции для двух нейронов

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

                  {

                        F_temp[n] = new double[kolPopul + kolPopul];

                  }

                  double[][] F_potomki = new double[2][]; // массив для хранения значений  целевой функции для потомков  для двух нейронов

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

                  {

                        F_potomki[n] = new double[kolPopul];

                  }

                  int k = 0;

                  SandY[] neuro_dataGA = new SandY[2];

                  while (k < 10)//количество  поколений

                  {

                        Console.WriteLine("============== Поколение {0} =================", k);

                        k++;

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

                        { 

                              Console.WriteLine("======== Нейрон {0} ========", neuron);

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

                              {

                                    neuro_dataGA[neuron] = neuro(input_x0, weightGA[neuron][n_osob]);

                                    F[neuron][n_osob] = (0.5*(neuro_dataGA[neuron].Y - d0[neuron]) * (neuro_dataGA[neuron].Y - d0[neuron]));//целевая ф-я

                                    Console.WriteLine(F[neuron][n_osob]);

                              }

                              //выбираем 4 пары  особей для скрещивания

                              int[] bestParent = new int[4]; //четыре  родителя 

                              bestParent = NMinIndexesValue(4, F[neuron]);//находим  четырех лучших родителей 

                              Console.WriteLine("Особи  для размножения");

                              Console.WriteLine(F[neuron][bestParent[0]]);

                              Console.WriteLine(F[neuron][bestParent[1]]);

                              Console.WriteLine(F[neuron][bestParent[2]]);

                              Console.WriteLine(F[neuron][bestParent[3]]);

                              Console.WriteLine("####################"); 

                              double[][][][] potomki = new double[4][][][];

                              for (int num = 0; num < 4; num++)

                              {

                                    potomki[num] = new double[2][][];

                              }

                              //скрещиваем как-бы  случайным образом родителей  и плодим потомков