Exemple #1
0
        public void wylosujPotencjalnychRodzicow()
        {
            Selekcja Selekcja = new Selekcja(populacja);

            Selekcja.obliczWartoscPopulacji();
            Selekcja.obliczPrawdopodobienstwo();
            Selekcja.setDystrybuantyDlaOsobnikow();

            // tu można wybrać interesującą nas selekcje:

            //List<Osobnik> WylosowaniOsobnicySukcesji = Selekcja.obracanieRulatki();
            List <Osobnik> WylosowaniOsobnicySukcesji = Selekcja.wyborOsobnikowMetodaRankingowaMalejaco();
            //List<Osobnik> WylosowaniOsobnicySukcesji = Selekcja.wyborOsobnikowMetodaRankingowaRosnaco();
            //List<Osobnik> WylosowaniOsobnicySukcesji = Selekcja.ZwracajacaWyborOsobnikowMetodaTurniejowaMalejaco(2);  //w nawiasie ilość osób w grupie
            //List<Osobnik> WylosowaniOsobnicySukcesji = Selekcja.ZwracajacaWyborOsobnikowMetodaTurniejowaRosnaco(2);
            //List<Osobnik> WylosowaniOsobnicySukcesji = Selekcja.wyborOsobnikowMetodaTurniejowaMalejaco(2);
            //List<Osobnik> WylosowaniOsobnicySukcesji = Selekcja.wyborOsobnikowMetodaTurniejowaRosnaco(2);
            List <Osobnik> potencjalniRodzice = new List <Osobnik>();

            for (int i = 0; i < WylosowaniOsobnicySukcesji.Count; i++)
            {
                string  imie = "Potencjalny rodzic " + i;
                Osobnik potencjalnyRodzic = new Osobnik(imie, WylosowaniOsobnicySukcesji[i]);
                potencjalnyRodzic.SetIndex(i);
                potencjalniRodzice.Add(potencjalnyRodzic);
            }

            Populacja PopulacjaPotencjalnychRodzicow = new Populacja();

            PopulacjaPotencjalnychRodzicow.SetListaOsobnikowNowaPopulacja(WylosowaniOsobnicySukcesji.Count, potencjalniRodzice, populacja.poczatkiLista, populacja.konceLista, populacja.precyzjaLista);

            this.PopulacjaPotencjalnychRodzicow = PopulacjaPotencjalnychRodzicow;
        }
Exemple #2
0
        public void wybierzNastepnePokolenie()
        {
            List <Osobnik> nowePokolenie = new List <Osobnik>();

            for (int i = 0; i < populacja.listaOsobnikow.Count; i++)
            {
                string  imie    = "Krolik " + i;
                Osobnik Potomek = new Osobnik(imie, WszyscyOsobnicy[i]);
                Potomek.SetIndex(i);
                nowePokolenie.Add(Potomek);
            }

            List <Osobnik> Potomkowie = new List <Osobnik>();

            for (int i = 0; i < nowePokolenie.Count; i++)
            {
                string  imie    = "Krolik " + i;
                Osobnik Potomek = new Osobnik(imie, nowePokolenie[i]);
                Potomek.SetIndex(i);
                Potomkowie.Add(Potomek);
            }

            Populacja NowePokolenie = populacja;

            NowePokolenie.SetListaOsobnikow(Potomkowie);

            this.populacja = NowePokolenie;
        }
Exemple #3
0
        public void wybierzNastepnePokolenie()
        {
            List <Osobnik> nowePokolenie = new List <Osobnik>();
            var            rng           = new Random(Guid.NewGuid().GetHashCode());

            for (int i = 0; i < populacja.listaOsobnikow.Count; i++)
            {
                int     index   = rng.Next(0, (WszyscyOsobnicy.Count - 1));
                string  imie    = "Krolik " + i;
                Osobnik Potomek = new Osobnik(imie, WszyscyOsobnicy[index]);
                Potomek.SetIndex(i);
                nowePokolenie.Add(Potomek);
            }

            List <Osobnik> Potomkowie = new List <Osobnik>();

            for (int i = 0; i < nowePokolenie.Count; i++)
            {
                string  imie    = "Krolik " + i;
                Osobnik Potomek = new Osobnik(imie, nowePokolenie[i]);
                Potomek.SetIndex(i);
                Potomkowie.Add(Potomek);
            }

            Populacja NowePokolenie = populacja;

            NowePokolenie.SetListaOsobnikow(Potomkowie);

            this.populacja = NowePokolenie;
        }
        public void krzyzujOsobnikow()
        {
            Selekcja Krzyzowanie = new Selekcja(PopulacjaPotencjalnychRodzicow);

            Krzyzowanie.wyborOsobnikowDoKrzyzowania();

            List <Osobnik> przyszliRodzice = new List <Osobnik>();

            for (int i = 0; i < Krzyzowanie.osobnicyDoSparowania.Count; i++)
            {
                string  imie   = "Rodzic " + i;
                Osobnik Rodzic = new Osobnik(imie, Krzyzowanie.osobnicyDoSparowania[i]);
                Rodzic.SetIndex(i);
                przyszliRodzice.Add(Rodzic);
            }

            Populacja PopulacjaRodzicow = new Populacja();

            PopulacjaRodzicow = PopulacjaPotencjalnychRodzicow;
            PopulacjaRodzicow.SetListaOsobnikow(przyszliRodzice);

            Selekcja Parowanie = new Selekcja(PopulacjaRodzicow);

            Parowanie.SetOsobnicyDoSparowania(przyszliRodzice);

            List <Osobnik> PotomkowieKrzyzowania = new List <Osobnik>();

            for (int i = 0; i < (Krzyzowanie.osobnicyDoSparowania.Count / 2); i++)
            {
                Parowanie.stworzPare();

                // tu można wybrać interesujący nas rodzaj krzyżowania:

                //PopulacjaRodzicow.krzyzowanieJednopunktowe(Parowanie.para[0].calyLancuchBinarny, Parowanie.para[1].calyLancuchBinarny);
                //PopulacjaRodzicow.krzyzowanieDwupunktowe(Parowanie.para[0].calyLancuchBinarny, Parowanie.para[1].calyLancuchBinarny);
                //PopulacjaRodzicow.krzyzowanieWielopunktowe(Parowanie.para[0].calyLancuchBinarny, Parowanie.para[1].calyLancuchBinarny);
                PopulacjaRodzicow.krzyzowanieRownomierne(Parowanie.para[0].calyLancuchBinarny, Parowanie.para[1].calyLancuchBinarny);

                for (int j = 0; j < PopulacjaRodzicow.listaPotomkow.Count; j++)
                {
                    PotomkowieKrzyzowania.Add(PopulacjaRodzicow.listaPotomkow[j]);
                }
            }

            List <Osobnik> Potomkowie = new List <Osobnik>();

            for (int i = 0; i < PotomkowieKrzyzowania.Count; i++)
            {
                string  imie    = "Potomek " + i;
                Osobnik Potomek = new Osobnik(imie, PotomkowieKrzyzowania[i]);
                Potomek.SetIndex(i);
                Potomkowie.Add(Potomek);
            }

            Populacja PotomkowiePoKrzyzowaniu = PopulacjaRodzicow;

            PotomkowiePoKrzyzowaniu.SetListaOsobnikow(Potomkowie);

            this.PotomkowiePoKrzyzowaniu = PotomkowiePoKrzyzowaniu;
        }
Exemple #5
0
        public void stworzOsobnikowPoInwersji()
        {
            Populacja PopulacjaOsobnikowPoInwersji = new Populacja();

            PopulacjaOsobnikowPoMutacji.SetListaOsobnikowNowaPopulacja(populacja.listaOsobnikow.Count, populacja.listaOsobnikow, populacja.poczatkiLista, populacja.konceLista, populacja.precyzjaLista);
            PopulacjaOsobnikowPoInwersji.generyjPopulacjePoInwersji(populacja.listaOsobnikow);

            this.PopulacjaOsobnikowPoInwersji = PopulacjaOsobnikowPoInwersji;
        }
Exemple #6
0
        public void zmutujOsobnikow()
        {
            Populacja PopulacjaOsobnikowPoMutacji = new Populacja();

            PopulacjaOsobnikowPoMutacji.SetListaOsobnikowNowaPopulacja(populacja.listaOsobnikow.Count, populacja.listaOsobnikow, populacja.poczatkiLista, populacja.konceLista, populacja.precyzjaLista);
            PopulacjaOsobnikowPoMutacji.generyjZmutowanaPopulacje(populacja.listaOsobnikow);

            this.PopulacjaOsobnikowPoMutacji = PopulacjaOsobnikowPoMutacji;
        }
Exemple #7
0
        public void wybierzNastepnePokolenie()
        {
            List <Osobnik> nowePokolenie = WszyscyOsobnicy;

            nowePokolenie = usunPodobnychOsobnikow(nowePokolenie);

            var rng = new Random(Guid.NewGuid().GetHashCode());

            while (nowePokolenie.Count < populacja.listaOsobnikow.Count)
            {
                for (int i = 0; i < (populacja.listaOsobnikow.Count - nowePokolenie.Count); i++)
                {
                    int     index   = rng.Next(0, (nowePokolenie.Count - 1));
                    string  imie    = "Krolik " + i;
                    Osobnik Potomek = new Osobnik(imie, nowePokolenie[index]);
                    Potomek.SetIndex(i);
                    nowePokolenie.Add(Potomek);
                }

                nowePokolenie = usunPodobnychOsobnikow(nowePokolenie);
            }

            if (nowePokolenie.Count > populacja.listaOsobnikow.Count)
            {
                List <Osobnik> nowePokoleniePoOdjeciuNadmiaru = new List <Osobnik>();

                for (int i = 0; i < populacja.listaOsobnikow.Count; i++)
                {
                    nowePokoleniePoOdjeciuNadmiaru.Add(nowePokolenie[i]);
                }

                nowePokolenie = nowePokoleniePoOdjeciuNadmiaru;
            }

            List <Osobnik> Potomkowie = new List <Osobnik>();

            for (int i = 0; i < nowePokolenie.Count; i++)
            {
                string  imie    = "Krolik " + i;
                Osobnik Potomek = new Osobnik(imie, nowePokolenie[i]);
                Potomek.SetIndex(i);
                Potomkowie.Add(Potomek);
            }

            Populacja NowePokolenie = populacja;

            NowePokolenie.SetListaOsobnikow(Potomkowie);

            this.populacja = NowePokolenie;
        }
        public void wybierzNastepnePokolenie()
        {
            List <Osobnik> nowePokolenie  = new List <Osobnik>();
            List <Osobnik> listaOsobnikow = populacja.listaOsobnikow;
            List <Osobnik> listaRodzicow  = PopulacjaPotencjalnychRodzicow.listaOsobnikow;
            List <Osobnik> listaPotomkow  = PotomkowiePoKrzyzowaniu.listaOsobnikow;

            Osobnik Wybraniec;
            Osobnik rodzicDoWyrzucenia;
            Osobnik potomekDoWyrzucenia;

            for (int i = 0; i < listaOsobnikow.Count; i++)
            {
                Wybraniec = listaOsobnikow[i];

                for (int j = 0; j < listaRodzicow.Count; j++)
                {
                    rodzicDoWyrzucenia  = listaRodzicow[j];
                    potomekDoWyrzucenia = listaPotomkow[j];

                    if (Wybraniec.Equals(rodzicDoWyrzucenia))
                    {
                        nowePokolenie.Add(potomekDoWyrzucenia);
                        listaOsobnikow = wyrzucanieOsobnika(Wybraniec, listaOsobnikow);
                        listaRodzicow  = wyrzucanieOsobnika(rodzicDoWyrzucenia, listaRodzicow);
                        listaPotomkow  = wyrzucanieOsobnika(potomekDoWyrzucenia, listaPotomkow);
                    }
                }
            }

            for (int i = 0; i < listaOsobnikow.Count; i++)
            {
                nowePokolenie.Add(listaOsobnikow[i]);
            }

            Populacja PopulacjaZPotomkami = new Populacja();

            PopulacjaZPotomkami.SetListaOsobnikowNowaPopulacja(populacja.listaOsobnikow.Count, nowePokolenie, populacja.poczatkiLista, populacja.konceLista, populacja.precyzjaLista);

            this.populacja = PopulacjaZPotomkami;
        }
Exemple #9
0
 public SukcesjaUsuwaniePodobnych(Populacja populacja)
 {
     this.populacja = populacja;
 }
Exemple #10
0
 public SukcesjaElitarna(Populacja populacja)
 {
     this.populacja = populacja;
 }
 public SukcesjaZCzesciowaWymiana(Populacja populacja)
 {
     this.populacja = populacja;
 }
        public void wybierzNastepnePokolenie()
        {
            List <Osobnik> nowePokolenie = new List <Osobnik>();
            List <Osobnik> WszyscyOsobnicyBezTychZPierwotnejPopulacji = WszyscyNowiOsobnicy;

            Osobnik doWyrzucenia;
            Osobnik Wybraniec;

            for (int i = 0; i < populacja.listaOsobnikow.Count; i++)
            {
                Wybraniec = populacja.listaOsobnikow[i];

                for (int j = 0; j < WszyscyOsobnicyBezTychZPierwotnejPopulacji.Count; j++)
                {
                    doWyrzucenia = WszyscyOsobnicyBezTychZPierwotnejPopulacji[j];

                    if (Wybraniec.Equals(doWyrzucenia))
                    {
                        WszyscyOsobnicyBezTychZPierwotnejPopulacji = wyrzucanieOsobnika(doWyrzucenia, WszyscyOsobnicyBezTychZPierwotnejPopulacji);
                    }
                }
            }

            // tu można wybrać rodzaj sortowania osobników:

            //WszyscyOsobnicyBezTychZPierwotnejPopulacji = posortujOsobnikowRosnaco(WszyscyOsobnicyBezTychZPierwotnejPopulacji);
            WszyscyOsobnicyBezTychZPierwotnejPopulacji = posortujOsobnikowMalejaco(WszyscyOsobnicyBezTychZPierwotnejPopulacji);

            var rng = new Random(Guid.NewGuid().GetHashCode());

            int iloscOsobnikowZNastepnejPopulacji  = rng.Next(0, (populacja.listaOsobnikow.Count - 1));
            int iloscOsobnikowZPierwotnejPopulacji = populacja.listaOsobnikow.Count - iloscOsobnikowZNastepnejPopulacji;
            int index = 0;

            for (int i = 0; i < iloscOsobnikowZPierwotnejPopulacji; i++)
            {
                string  imie    = "Krolik " + i;
                Osobnik Potomek = new Osobnik(imie, populacja.listaOsobnikow[i]);
                Potomek.SetIndex(i);
                nowePokolenie.Add(Potomek);
            }

            for (int i = 0; i < iloscOsobnikowZNastepnejPopulacji; i++)
            {
                index = rng.Next(0, (WszyscyOsobnicyBezTychZPierwotnejPopulacji.Count - 1));
                string  imie    = "Krolik " + i;
                Osobnik Potomek = new Osobnik(imie, WszyscyOsobnicyBezTychZPierwotnejPopulacji[index]);
                Potomek.SetIndex(i);
                nowePokolenie.Add(Potomek);
            }

            List <Osobnik> Potomkowie = new List <Osobnik>();

            for (int i = 0; i < nowePokolenie.Count; i++)
            {
                string  imie    = "Krolik " + i;
                Osobnik Potomek = new Osobnik(imie, nowePokolenie[i]);
                Potomek.SetIndex(i);
                Potomkowie.Add(Potomek);
            }

            Populacja NowePokolenie = new Populacja();

            NowePokolenie.SetListaOsobnikowNowaPopulacja(populacja.listaOsobnikow.Count, Potomkowie, populacja.poczatkiLista, populacja.konceLista, populacja.precyzjaLista);

            this.populacja = NowePokolenie;
        }
Exemple #13
0
 public Selekcja(Populacja listaOsobnikow)
 {
     this.popul = listaOsobnikow;
 }
Exemple #14
0
        static void Main(string[] args)
        {
            List <double> a, b, d;

            a = new List <double>
            {
                -4, -3, -2
            };
            b = new List <double>
            {
                4, 3, 2
            };
            d = new List <double>
            {
                3, 5, 7
            };

            Populacja test = new Populacja(a, b, d);

            test.generujPopulacje(10);
            test.policzSredniaWartoscPopulacji();

            foreach (var result in test.listaOsobnikow)
            {
                Console.WriteLine(result);
            }
            Console.WriteLine();
            Console.WriteLine("Srednia wartosc pierwotnej populacji to: " + test.sredniaWartosciPokolenia);


            Console.WriteLine();
            Console.WriteLine("Wybierz selekcje: \n 1. Sukcesja elitarna. \n 2. Sukcesja losowa. \n 3. Sukcesja z usuwaniem podobnych. \n 4. Sukcesja z częściowym zastępowaniem. \n 5. Sukcesja z całkowitym zastępowaniem.");
            string numer         = Console.ReadLine();
            int    numerSukcesji = 0;

            if (Int32.TryParse(numer, out numerSukcesji))
            {
                ;
            }

            switch (numerSukcesji)
            {
            case 1:
            {
                // ________SUKCESJA ELITARNA:________  //

                SukcesjaElitarna Elita = new SukcesjaElitarna(test);

                for (int i = 0; i < 50; i++)
                {
                    Elita.zmutujOsobnikow();
                    Elita.stworzOsobnikowPoInwersji();
                    Elita.wylosujPotencjalnychRodzicow();
                    Elita.krzyzujOsobnikow();
                    Elita.zbierzWszystkichOsobnikow();
                    Elita.usunTakichSamychOsobnikow();

                    //tu można wybrać sposób sortowania osobników:

                    //Elita.posortujWszystkichOsobnikowRosnaco();
                    Elita.posortujWszystkichOsobnikowMalejaco();
                    Elita.usunTakichSamychOsobnikow();

                    //tu można wybrać sposób sortowania osobników:

                    //Elita.posortujWszystkichOsobnikowRosnaco();
                    Elita.posortujWszystkichOsobnikowMalejaco();
                    Elita.wybierzNastepnePokolenie();
                    Elita.populacja.policzSredniaWartoscPopulacji();

                    if (((i + 1) % 10) == 0)
                    {
                        Console.WriteLine();
                        Console.WriteLine("Srednia wartosc populacji po {0} epokach to: {1}", (i + 1), Elita.populacja.sredniaWartosciPokolenia);
                    }
                }

                Console.WriteLine();
                Console.WriteLine("---------*--------*--------*--------*---------*--------*--------*--------*---------");
                Console.WriteLine("Populacja po przeprowadzeniu sukcesji elitarnej:");
                Console.WriteLine("---------*--------*--------*--------*---------*--------*--------*--------*---------");
                Console.WriteLine();

                for (int j = 0; j < Elita.populacja.listaOsobnikow.Count; j++)
                {
                    Console.WriteLine(Elita.populacja.listaOsobnikow[j]);
                }
            }
            break;

            case 2:
            {
                // ________SUKCESJA LOSOWA:________  //

                SukcesjaLosowa Losowa = new SukcesjaLosowa(test);

                for (int i = 0; i < 50; i++)
                {
                    Losowa.zmutujOsobnikow();
                    Losowa.stworzOsobnikowPoInwersji();
                    Losowa.wylosujPotencjalnychRodzicow();
                    Losowa.krzyzujOsobnikow();
                    Losowa.zbierzWszystkichOsobnikow();
                    Losowa.usunTakichSamychOsobnikow();

                    //tu można wybrać sposób sortowania osobników:

                    //Losowa.posortujWszystkichOsobnikowRosnaco();
                    Losowa.posortujWszystkichOsobnikowMalejaco();
                    Losowa.usunTakichSamychOsobnikow();

                    //tu można wybrać sposób sortowania osobników:

                    //Losowa.posortujWszystkichOsobnikowRosnaco();
                    Losowa.posortujWszystkichOsobnikowMalejaco();
                    Losowa.usunTakichSamychOsobnikow();
                    Losowa.posortujWszystkichOsobnikowMalejaco();
                    Losowa.wybierzNastepnePokolenie();
                    Losowa.populacja.policzSredniaWartoscPopulacji();

                    if (((i + 1) % 10) == 0)
                    {
                        Console.WriteLine();
                        Console.WriteLine("Srednia wartosc populacji po {0} epokach to: {1}", (i + 1), Losowa.populacja.sredniaWartosciPokolenia);
                    }
                }

                Console.WriteLine();
                Console.WriteLine("---------*--------*--------*--------*---------*--------*--------*--------*---------");
                Console.WriteLine("Populacja po przeprowadzeniu sukcesji losowej:");
                Console.WriteLine("---------*--------*--------*--------*---------*--------*--------*--------*---------");
                Console.WriteLine();

                for (int j = 0; j < Losowa.populacja.listaOsobnikow.Count; j++)
                {
                    Console.WriteLine(Losowa.populacja.listaOsobnikow[j]);
                }
            }
            break;

            case 3:
            {
                // ________SUKCESJA Z USUWANIEM PODOBNYCH:________  //

                SukcesjaUsuwaniePodobnych Niepodobni = new SukcesjaUsuwaniePodobnych(test);

                for (int i = 0; i < 50; i++)
                {
                    Niepodobni.zmutujOsobnikow();
                    Niepodobni.stworzOsobnikowPoInwersji();
                    Niepodobni.wylosujPotencjalnychRodzicow();
                    Niepodobni.krzyzujOsobnikow();
                    Niepodobni.zbierzWszystkichOsobnikow();
                    Niepodobni.usunTakichSamychOsobnikow();

                    //tu można wybrać sposób sortowania osobników:

                    //Niepodobni.posortujWszystkichOsobnikowRosnaco();
                    Niepodobni.posortujWszystkichOsobnikowMalejaco();
                    Niepodobni.usunTakichSamychOsobnikow();

                    //tu można wybrać sposób sortowania osobników:

                    //Niepodobni.posortujWszystkichOsobnikowRosnaco();
                    Niepodobni.posortujWszystkichOsobnikowMalejaco();
                    Niepodobni.wybierzNastepnePokolenie();
                    Niepodobni.populacja.policzSredniaWartoscPopulacji();

                    if (((i + 1) % 10) == 0)
                    {
                        Console.WriteLine();
                        Console.WriteLine("Srednia wartosc populacji po {0} epokach to: {1}", (i + 1), Niepodobni.populacja.sredniaWartosciPokolenia);
                    }
                }

                Console.WriteLine();
                Console.WriteLine("---------*--------*--------*--------*---------*--------*--------*--------*---------");
                Console.WriteLine("Populacja po przeprowadzeniu sukcesji z usuwaniem podobnych osobnikow:");
                Console.WriteLine("---------*--------*--------*--------*---------*--------*--------*--------*---------");
                Console.WriteLine();

                for (int j = 0; j < Niepodobni.populacja.listaOsobnikow.Count; j++)
                {
                    Console.WriteLine(Niepodobni.populacja.listaOsobnikow[j]);
                }
            }
            break;

            case 4:
            {
                // ________SUKCESJA Z CZĘŚCIOWĄ WYMINĄ:________  //

                SukcesjaZCzesciowaWymiana Czesc = new SukcesjaZCzesciowaWymiana(test);

                for (int i = 0; i < 50; i++)
                {
                    Czesc.zmutujOsobnikow();
                    Czesc.stworzOsobnikowPoInwersji();
                    Czesc.wylosujPotencjalnychRodzicow();
                    Czesc.krzyzujOsobnikow();
                    Czesc.zbierzWszystkichOsobnikow();
                    Czesc.usunTakichSamychOsobnikow();

                    //tu można wybrać sposób sortowania osobników:

                    //Czesc.posortujWszystkichOsobnikowRosnaco();
                    Czesc.posortujWszystkichOsobnikowMalejaco();
                    Czesc.usunTakichSamychOsobnikow();

                    //tu można wybrać sposób sortowania osobników:

                    //Czesc.posortujWszystkichOsobnikowRosnaco();
                    //Czesc.posortujWszystkichOsobnikowRosnaco();
                    Czesc.posortujWszystkichOsobnikowMalejaco();

                    //tu można wybrać sposób sortowania osobników:

                    //Czesc.posortujOsobnikowPoczatkowychRosnaco();
                    Czesc.posortujOsobnikowPoczatkowychMalejaco();
                    Czesc.wybierzNastepnePokolenie();
                    Czesc.populacja.policzSredniaWartoscPopulacji();

                    if (((i + 1) % 10) == 0)
                    {
                        Console.WriteLine();
                        Console.WriteLine("Srednia wartosc populacji po {0} epokach to: {1}", (i + 1), Czesc.populacja.sredniaWartosciPokolenia);
                    }
                }

                Console.WriteLine();
                Console.WriteLine("---------*--------*--------*--------*---------*--------*--------*--------*---------");
                Console.WriteLine("Populacja po przeprowadzeniu sukcesji z czesciowa wymiana:");
                Console.WriteLine("---------*--------*--------*--------*---------*--------*--------*--------*---------");
                Console.WriteLine();

                for (int i = 0; i < Czesc.populacja.listaOsobnikow.Count; i++)
                {
                    Console.WriteLine(Czesc.populacja.listaOsobnikow[i]);
                }
            }
            break;

            case 5:
            {
                // ________SUKCESJA Z CAŁKOWITYM ZASTĘPOWANIEM:________  //

                SukcesjaZCalkowitymZastepowaniem Calosc = new SukcesjaZCalkowitymZastepowaniem(test);

                for (int i = 0; i < 50; i++)
                {
                    Calosc.zmutujOsobnikow();
                    Calosc.stworzOsobnikowPoInwersji();
                    Calosc.wylosujPotencjalnychRodzicow();
                    Calosc.krzyzujOsobnikow();
                    Calosc.wybierzNastepnePokolenie();
                    Calosc.populacja.policzSredniaWartoscPopulacji();

                    if (((i + 1) % 10) == 0)
                    {
                        Console.WriteLine();
                        Console.WriteLine("Srednia wartosc populacji po {0} epokach to: {1}", (i + 1), Calosc.populacja.sredniaWartosciPokolenia);
                    }
                }

                Console.WriteLine();
                Console.WriteLine("---------*--------*--------*--------*---------*--------*--------*--------*---------");
                Console.WriteLine("Populacja po przeprowadzeniu sukcesji z całkowitym zastępowaniem:");
                Console.WriteLine("---------*--------*--------*--------*---------*--------*--------*--------*---------");
                Console.WriteLine();

                for (int i = 0; i < Calosc.populacja.listaOsobnikow.Count; i++)
                {
                    Console.WriteLine(Calosc.populacja.listaOsobnikow[i]);
                }
            }
            break;

            default:
                Console.WriteLine("Nie wybrano żadnej opcji z listy.");
                break;
            }

            Console.ReadKey();
        }
 public SukcesjaZCalkowitymZastepowaniem(Populacja populacja)
 {
     this.populacja = populacja;
 }
Exemple #16
0
 public SukcesjaLosowa(Populacja populacja)
 {
     this.populacja = populacja;
 }