void liczWyniki2(Warstwa warstwa, int skip, double beta = 1)
        {
            int w = 0;

            for (int j = 0; j < warstwy[skip + 1]; j++)
            {
                double s = 0;
                for (int i = -1; i < warstwy[skip]; w++, i++)
                {
                    if (i == -1)
                    {
                        s += 1 * warstwa.Wagi[w];
                    }
                    else
                    {
                        s += warstwa.Neutrony[i] * warstwa.Wagi[w];
                    }
                }
                double wynik = 1 / (1 + Math.Pow(Math.E, -beta * s));
                warstwa.Dzieci[0].Neutrony[j] = wynik;
            }
            if (warstwy.Count > skip + 2)
            {
                liczWyniki2(warstwa.Dzieci[0], skip + 1);
            }
        }
        private void robWarstwy(Warstwa warstwa, List <int> warstwy, int skip, int LBnCh, Osobnik osobnik, int ZDMin, int ZDMax)
        {
            Warstwa tmp = new Warstwa();

            if (warstwy.Count - 1 != skip)
            {
                generuj(tmp, skip, LBnCh, osobnik, ZDMin, ZDMax);
            }

            warstwa.Dzieci.Add(tmp);
            if (warstwy.Count > skip + 1)
            {
                robWarstwy(tmp, warstwy, skip + 1, LBnCh, osobnik, ZDMin, ZDMax);
            }
        }
 private void generuj(Warstwa warstwa, int i, int LBnCh, Osobnik osobnik, double ZDMin, double ZDMax)
 {
     for (int j = 0; j < (warstwy[i] + 1) * warstwy[i + 1]; j++)
     {
         List <int> chromosomy = new List <int>();
         if (i == 0)
         {
             for (int k = j * LBnCh; k < LBnCh * (j + 1); k++)
             {
                 chromosomy.Add(osobnik.Chromosomy[k]);
             }
         }
         else
         {
             for (int k = j * LBnCh + i * (warstwy[i - 1] + 1) * warstwy[i] * LBnCh; k < LBnCh * (j + 1) + i * (warstwy[i - 1] + 1) * warstwy[i] * LBnCh; k++)
             {
                 chromosomy.Add(osobnik.Chromosomy[k]);
             }
         }
         warstwa.Wagi.Add(dekoduj(chromosomy, LBnCh, ZDMin, ZDMax));
     }
 }
        private void zad3Licz(List <Osobnik> populacja, int LBnCh, int ZDMin, int ZDMax)
        {
            foreach (Osobnik osobnik in populacja)
            {
                osobnik.Ocena = 0;
                start         = new Warstwa();
                for (int i = 0; i < warstwy[0]; i++)
                {
                    start.Neutrony.Add(1);
                }
                generuj(start, 0, LBnCh, osobnik, ZDMin, ZDMax);
                robWarstwy(start, warstwy, 1, LBnCh, osobnik, ZDMin, ZDMax);
                liczWyniki(start, 0);

                List <List <int> > probki = new List <List <int> >();
                probki = tworzProbki();
                foreach (List <int> probka in probki)
                {
                    for (int i = 0; i < warstwy[0]; i++)
                    {
                        start.Neutrony[i] = Convert.ToDouble(probka[i]);
                    }
                    int d = probka[0];
                    for (int i = 1; i < probka.Count; i++)
                    {
                        d ^= probka[i];
                    }

                    liczWyniki2(start, 0);
                    Warstwa warstwa = start;
                    for (int k = 0; k < warstwy.Count - 1; k++)
                    {
                        warstwa = warstwa.Dzieci[0];
                    }
                    osobnik.Ocena += Math.Pow((d - warstwa.Neutrony[0]), 2);
                }
            }
        }
        private void zad3Click(object sender, RoutedEventArgs e)
        {
            start   = new Warstwa();
            warstwy = new List <int>();
            int    LBnCh;
            String tmp = inputLBnCh.Text;

            if (!int.TryParse(tmp, out LBnCh))
            {
            }
            Regex rgx = new Regex(@"(?<=\s|^)[-+]?\d+(?=\s|$)");

            if (rgx.IsMatch(tmp) != true || LBnCh < 4)
            {
                MessageBox.Show("LBnCh- Podawaj tylko liczbe typu int i wieksza badz rowna 4!");
                inputLBnCh.Text = "4";
                return;
            }
            int ZDMin;

            tmp = inputZDMin.Text;
            if (!int.TryParse(tmp, out ZDMin))
            {
            }
            if (rgx.IsMatch(tmp) != true)
            {
                MessageBox.Show("ZDMin- Podawaj tylko liczbe typu int!");
                inputZDMin.Text = "-10";
                return;
            }
            int ZDMax;

            tmp = inputZDMax.Text;
            if (!int.TryParse(tmp, out ZDMax))
            {
            }
            if (rgx.IsMatch(tmp) != true)
            {
                MessageBox.Show("ZDMax- Podawaj tylko liczbe typu int!");
                inputZDMax.Text = "10";
                return;
            }
            int ilosc;

            tmp = inputPopulacja.Text;
            if (!int.TryParse(tmp, out ilosc))
            {
            }
            if (rgx.IsMatch(tmp) != true || ilosc < 13 || (ilosc % 2) != 1 || ((ilosc - 1) % 6) != 0)
            {
                MessageBox.Show("Populacja- Podawaj tylko liczbe typu int, nieparzysta, populacja-1 podzielna przez 6 i wieksza badz rowna 13!");
                inputPopulacja.Text = "13";
                return;
            }
            int iteracje;

            tmp = inputIteracje.Text;
            if (!int.TryParse(tmp, out iteracje))
            {
            }
            if (rgx.IsMatch(tmp) != true || iteracje < 100)
            {
                MessageBox.Show("Iteracje- Podawaj tylko liczbe typu int i wieksze lub rowne 100!");
                inputIteracje.Text = "100";
                return;
            }
            finish.Text = "";
            List <Osobnik> populacja = new List <Osobnik>();

            populacja = tworzOsobniki(ilosc, LBnCh, 9, populacja);
            warstwy.Add(2);
            warstwy.Add(2);
            warstwy.Add(1);
            zad3Licz(populacja, LBnCh, ZDMin, ZDMax);
            zad3Rek(LBnCh, ZDMin, ZDMax, iteracje, 0, populacja);
        }