public override ReprezentacjaRozwiazania Krzyzowanie(ReprezentacjaRozwiazania genotyp1, ReprezentacjaRozwiazania genotyp2) { // zwrócenie rozwiązań dla wektora rozwiązania Problemu Komiwojażera ushort[] przodek1 = genotyp1.ZwrocGenotyp1Wymiarowy(), przodek2 = genotyp2.ZwrocGenotyp1Wymiarowy(), potomek = new ushort[przodek1.Length]; // określenie rodzaju krzyżowania dla Problemu Komiwojażera switch (rodzajKrzyzowania) { case "PMX": potomek = (ushort[])PMX(przodek1, przodek2).Clone(); break; case "OX": potomek = (ushort[])OX(przodek1, przodek2).Clone(); break; case "CX": potomek = (ushort[])CX(przodek1, przodek2).Clone(); break; default: throw new Exception(); } return(new ReprezentacjaRozwiazania((ushort[])Mutacja(potomek).Clone())); }
public override ReprezentacjaRozwiazania Krzyzowanie(ReprezentacjaRozwiazania genotyp1, ReprezentacjaRozwiazania genotyp2) { // pobranie wektorów rozwiązań dla Problemu Plecakowego ushort[] przodek1 = genotyp1.ZwrocGenotyp1Wymiarowy(), przodek2 = genotyp2.ZwrocGenotyp1Wymiarowy(), dzieciak = new ushort[przodek1.Length]; // punkt w którym tniemy dwa wektory rozwiązań int ciecie = losowy.Next(0, przodek1.Length); dzieciak = (ushort[])przodek1.Clone(); // przepisanie 1 do 1 genów z pierwszego przodka for (int i = 0; i < ciecie; i++) { try { dzieciak[i] = przodek2[i]; // od puktu cięcia zmiana genów na te z przo drugiego } catch (System.Exception e) { System.Console.WriteLine(e); System.Console.WriteLine(dzieciak.Length + " " + dzieciak[i]); System.Console.WriteLine(przodek2.Length + " " + przodek2[i]); } } ReprezentacjaRozwiazania genotypDziecka = new ReprezentacjaRozwiazania((ushort[])Mutacja(dzieciak).Clone()); if (czySprawdzacOgraniczenia) { return(SprawdzNaruszenieOgraniczen(genotypDziecka)); // sprawdzanie czy nie przekraczamy wagi plecaka } return(genotypDziecka); }
public override ReprezentacjaRozwiazania[] LosujRozwiazania(ProblemOptymalizacyjny problemOptymalizacyjny, int iloscRozwiazan, int iloscElementow) { Random losowy = new Random(); ReprezentacjaRozwiazania[] rozwiazania = new ReprezentacjaRozwiazania[iloscRozwiazan]; float[] ograniczeniaProblemu = problemOptymalizacyjny.ZwrocOgraniczeniaProblemu(); for (int i = 0; i < iloscRozwiazan; i++) { ushort[] elementy = new ushort[iloscElementow]; for (int j = 0; j < iloscElementow; j++) { elementy[j] = (ushort)losowy.Next(2); Dictionary <string, float[]> zysk = problemOptymalizacyjny.ObliczZysk(problemOptymalizacyjny.ZwrocWybraneElementy(elementy)); if (zysk["min"][0] > ograniczeniaProblemu[0]) { elementy[j] = 0; } } rozwiazania[i] = new ReprezentacjaRozwiazania(elementy); } return(rozwiazania); }
public override string DekodujRozwiazanie(ReprezentacjaRozwiazania reprezentacjaGenotypu) { string wynik = ""; ushort[][] genotyp = reprezentacjaGenotypu.ZwrocGenotyp2Wymiarowy(); // przechodząc po całej macierzy for (int i = 0; i < genotyp.Length; i++) { // w pierwszej kolejności wypisujemy numer miasta wynik += Environment.NewLine + " - Miasto " + genotyp[i][0] + ", przedmioty: "; bool brakPrzedmiotow = true; for (int j = 1; j < genotyp[i].Length; j++) { // jeżeli zebraliśmy przedmioty z danego miasta to if (genotyp[i][j] == 1) { wynik += (j + " "); // wypisujemy je po spacji, przy danym mieście if (brakPrzedmiotow) { brakPrzedmiotow = false; } } } // w innym wypadku wypisujemy, ze nie pobieramy przedmiotów z `i-tego` miasta if (brakPrzedmiotow) { wynik += "brak"; } } return(wynik); }
/// <summary> /// Metoda poszukująca najlepszego rozwiązania znalezionego do tej pory /// </summary> /// <param name="geny">Tablica definiująca dziedzinę rozwiązania</param> public void DopiszWartoscProcesu(short index, int czas, ReprezentacjaRozwiazania genotyp) { if (czas <= czasDzialaniaAlgorytmu) { Dictionary <string, float[]> wartosc = rozwiazanie.FunkcjaDopasowania(genotyp); if (najlepszaWartoscFunkcji["max"][0] < wartosc["max"][0]) { najlepszeRozwiazanie = genotyp; najlepszaWartoscFunkcji = wartosc; } if (minWartoscProcesuPoszukiwan[index][czas] > wartosc["max"][0] || maxWartoscProcesuPoszukiwan[index][czas] == 0) { minWartoscProcesuPoszukiwan[index][czas] = wartosc["max"][0]; } if (maxWartoscProcesuPoszukiwan[index][czas] < wartosc["max"][0] || maxWartoscProcesuPoszukiwan[index][czas] == 0) { maxWartoscProcesuPoszukiwan[index][czas] = wartosc["max"][0]; } liczbaWCzasie[index][czas]++; sredniaWartoscProcesuPoszukiwan[index][czas] += wartosc["max"][0]; } }
public override void ZnajdzOptimum() { int poprawy = 0; ushort[] genotyp = reprezentacjaRozwiazania.ZwrocGenotyp1Wymiarowy(), tmpGenotyp = (ushort[])genotyp.Clone(); AOsobnik osobnik = losowanie.ZwrocOsobnika(); ProblemOptymalizacyjny problemOptymalizacyjny = osobnik.ZwrocInstancjeProblemu(); Dictionary <string, float[]> wynik = osobnik.FunkcjaDopasowania(reprezentacjaRozwiazania); ReprezentacjaRozwiazania tmpReprezentacjaRozwiazanie = new ReprezentacjaRozwiazania(tmpGenotyp); do { int start = 1, koniec = problemOptymalizacyjny.ZwrocDlugoscGenotypu() - 1; poprawy = 0; for (int i = start; i < koniec; i++) { int liczba1 = losowy.Next(2, problemOptymalizacyjny.ZwrocDlugoscGenotypu()), liczba2 = losowy.Next(2, problemOptymalizacyjny.ZwrocDlugoscGenotypu()); ushort tmpWartosc = tmpGenotyp[liczba1]; tmpGenotyp[liczba1] = tmpGenotyp[liczba2]; tmpGenotyp[liczba2] = tmpWartosc; tmpReprezentacjaRozwiazanie.ZmienGenotyp(tmpGenotyp); Dictionary <string, float[]> tmpWynik = osobnik.FunkcjaDopasowania(tmpReprezentacjaRozwiazanie); if (tmpWynik["max"][0] > wynik["max"][0]) { if (problemOptymalizacyjny.CzyIstniejaOgraniczenia() && (tmpWynik["min"][0] > problemOptymalizacyjny.ZwrocOgraniczeniaProblemu()[0])) { continue; } genotyp = (ushort[])tmpGenotyp.Clone(); reprezentacjaRozwiazania.ZmienGenotyp(genotyp); wynik["max"][0] = tmpWynik["max"][0]; wynik["min"][0] = tmpWynik["min"][0]; poprawy++; } else { tmpGenotyp = (ushort[])genotyp.Clone(); tmpReprezentacjaRozwiazanie.ZmienGenotyp(genotyp); } } } while (poprawy > 0); }
public override ReprezentacjaRozwiazania[] LosujRozwiazania(ProblemOptymalizacyjny problemOptymalizacyjny, int iloscRozwiazan, int iloscElementow) { Random losowy = new Random(); ReprezentacjaRozwiazania[] rozwiazania = new ReprezentacjaRozwiazania[iloscRozwiazan]; int losoweElementy = 0, zroznicowaniePopulacji = (int)(0.1 * iloscRozwiazan); for (int i = 0; i < iloscRozwiazan; i++) { ushort[] genotyp = new ushort[iloscElementow + 1]; genotyp[0] = 1; if ((losoweElementy > zroznicowaniePopulacji) && (losowy.Next(100) > 50)) { ArrayList wykorzystane = new ArrayList(); wykorzystane.Add(1); for (int j = 1; j < iloscElementow; j++) { while (true) { int wynik = (ushort)losowy.Next(1, iloscElementow + 1); if (wykorzystane.IndexOf(wynik) == -1) { wykorzystane.Add(wynik); genotyp[j] = (ushort)wynik; break; } } } losoweElementy++; wykorzystane.Clear(); } else { for (int j = 1; j < iloscElementow; j++) { genotyp[j] = (ushort)(j + 1); } losoweElementy++; } genotyp[iloscElementow] = 1; rozwiazania[i] = new ReprezentacjaRozwiazania(genotyp); } return(rozwiazania); }
protected override ReprezentacjaRozwiazania SprawdzNaruszenieOgraniczen(ReprezentacjaRozwiazania genotyp) { ushort[] geny = genotyp.ZwrocGenotyp1Wymiarowy(); float[] ograniczenie = rozwiazanie.ZwrocInstancjeProblemu().ZwrocOgraniczeniaProblemu(); // naprawa genów do momentu spełniania ograniczeń while (rozwiazanie.FunkcjaDopasowania(genotyp)["min"][0] > ograniczenie[0]) { genotyp.ZmienGenotyp((ushort[])NaprawGenotypKP(geny).Clone()); } return(genotyp); }
/// <summary> /// Metoda przeszukuje przestrzeń w celu znalezienia najlepszego rozwiązania dla tablicy 1 wymiarowej /// </summary> /// <param name="listaRozwiazan">Wartość pozwalająca ustalić, czy sprawdzamy ograniczenia</param> public void SzukajNajlepszegoRozwiazania(int iloscRozwiazan, int iloscElementow) { ProblemOptymalizacyjny problemOptymalizacyjny = osobnik.ZwrocInstancjeProblemu(); ReprezentacjaRozwiazania[] listaRozwiazan = LosujRozwiazania(problemOptymalizacyjny, iloscRozwiazan, iloscElementow); najlepszeRozwiazanie = listaRozwiazan[0]; najlepszyWynik = osobnik.FunkcjaDopasowania(listaRozwiazan[0]); int iterator = 1; while (problemOptymalizacyjny.CzyIstniejaOgraniczenia()) { //System.Console.WriteLine("while: "+osobnik.FunkcjaDopasowania(listaRozwiazan[iterator])["max"][0] + " " + osobnik.FunkcjaDopasowania(listaRozwiazan[iterator])["min"][0]); if (osobnik.FunkcjaDopasowania(listaRozwiazan[iterator])["min"][0] <= problemOptymalizacyjny.ZwrocOgraniczeniaProblemu()[0]) { najlepszeRozwiazanie = listaRozwiazan[iterator]; najlepszyWynik = osobnik.FunkcjaDopasowania(listaRozwiazan[iterator]); } iterator++; if (listaRozwiazan.Length == iterator) { break; } } foreach (ReprezentacjaRozwiazania rozwiazanie in listaRozwiazan) { Dictionary <string, float[]> wynikElementu = osobnik.FunkcjaDopasowania(rozwiazanie); if ((najlepszyWynik != null) && (wynikElementu["max"][0] > najlepszyWynik["max"][0])) { if (problemOptymalizacyjny.CzyIstniejaOgraniczenia() && (wynikElementu["min"][0] > problemOptymalizacyjny.ZwrocOgraniczeniaProblemu()[0])) { continue; } najlepszeRozwiazanie = rozwiazanie; najlepszyWynik = wynikElementu; } } }
protected override ReprezentacjaRozwiazania SprawdzNaruszenieOgraniczen(ReprezentacjaRozwiazania genotyp) { ushort[][] geny = genotyp.ZwrocGenotyp2Wymiarowy(); Dictionary <string, float[]> zysk = rozwiazanie.ZwrocInstancjeProblemu().ObliczZysk(rozwiazanie.ZwrocInstancjeProblemu().ZwrocWybraneElementy(geny)); if (zysk["min"][0] > rozwiazanie.ZwrocInstancjeProblemu().ZwrocOgraniczeniaProblemu()[0]) { while (true) { int wspolczynnik = (int)(zysk["min"][0] / rozwiazanie.ZwrocInstancjeProblemu().ZwrocOgraniczeniaProblemu()[0]); for (int i = 0; i < geny.Length; i++) { for (int j = 1; j < geny[i].Length; j++) { if (geny[i][j] == 1) { if (wspolczynnik > 1) { if (losowy.Next(wspolczynnik) != 0) { geny[i][j] = 0; } } else { geny[i][j] = 0; break; } } } } zysk = rozwiazanie.ZwrocInstancjeProblemu().ObliczZysk(rozwiazanie.ZwrocInstancjeProblemu().ZwrocWybraneElementy(geny)); if (zysk["min"][0] <= rozwiazanie.ZwrocInstancjeProblemu().ZwrocOgraniczeniaProblemu()[0]) { break; } } } genotyp.ZmienGenotyp(geny); return(genotyp); }
public override string DekodujRozwiazanie(ReprezentacjaRozwiazania reprezentacjaGenotypu) { string wynik = ""; ushort[] genotyp = reprezentacjaGenotypu.ZwrocGenotyp1Wymiarowy(); // każdy z wybranych przedmiotów jest zapisywany w rozwiązaniu po spacji for (int i = 1; i <= genotyp.Length; i++) { // tylko wybrane przedmioty if (genotyp[i - 1] == 1) { wynik += (i + " "); } } return(wynik); }
protected override ReprezentacjaRozwiazania MetodaRuletki(ReprezentacjaRozwiazania[] populacja) { double pwo = losowy.NextDouble(), poprzednik = 0; ReprezentacjaRozwiazania osobnik = populacja[0]; for (int i = 0; i < populacja.Length; i++) { if (poprzednik <= pwo && pwo < (double)wskazniki[i]) { osobnik = populacja[i]; break; } poprzednik = (double)wskazniki[i]; } return(osobnik); }
protected override ReprezentacjaRozwiazania Turniej(ReprezentacjaRozwiazania[] populacja) { ReprezentacjaRozwiazania zwyciezca = populacja[0]; Dictionary <string, float[]> dopasowanieZwyciezcy = rozwiazanie.FunkcjaDopasowania(populacja[0]); for (int i = 0; i <= 5; i++) { int k = losowy.Next(populacja.Length - 1); Dictionary <string, float[]> dopasowanie = rozwiazanie.FunkcjaDopasowania(populacja[k]); if (dopasowanieZwyciezcy["max"][0] < dopasowanie["max"][0]) { zwyciezca = populacja[k]; dopasowanieZwyciezcy = dopasowanie; } } return(zwyciezca); }
public override ReprezentacjaRozwiazania Krzyzowanie(ReprezentacjaRozwiazania genotyp1, ReprezentacjaRozwiazania genotyp2) { ushort[][] przodek1 = genotyp1.ZwrocGenotyp2Wymiarowy(), przodek2 = genotyp2.ZwrocGenotyp2Wymiarowy(), potomekTTP = new ushort[przodek1.Length][], przodkowieTSP = new ushort[2][]; ushort[][][] przodkowieKP = new ushort[przodek1.Length][][]; for (int i = 0; i < przodkowieTSP.Length; i++) { przodkowieTSP[i] = new ushort[przodek1.Length]; przodkowieKP[i] = new ushort[przodek1.Length][]; for (int j = 0; j < przodek1.Length; j++) { przodkowieTSP[i][j] = (i == 0) ? przodek1[j][0] : przodek2[j][0]; int index = ((przodkowieTSP[i][j] - 1) == 0 && j != 0) ? przodek1.Length - 1 : przodkowieTSP[i][j] - 1; przodkowieKP[i][index] = new ushort[przodek1[0].Length - 1]; for (int k = 1; k <= przodkowieKP[i][index].Length; k++) { przodkowieKP[i][index][k - 1] = (i == 0) ? przodek1[j][k] : przodek2[j][k]; } } } ReprezentacjaRozwiazania przodekTSP1 = new ReprezentacjaRozwiazania(przodkowieTSP[0]), przodekTSP2 = new ReprezentacjaRozwiazania(przodkowieTSP[1]), genotypPotomkaTSP = rekombinacjaTSP.Krzyzowanie(przodekTSP1, przodekTSP2); ushort[] potomekTSP = genotypPotomkaTSP.ZwrocGenotyp1Wymiarowy(); ushort[][] potomkowieKP = new ushort[przodek1.Length][]; for (int i = 0; i < przodek1.Length; i++) { ReprezentacjaRozwiazania przodekKP1 = new ReprezentacjaRozwiazania(przodkowieKP[0][i]), przodekKP2 = new ReprezentacjaRozwiazania(przodkowieKP[1][i]); potomkowieKP[i] = new ushort[przodkowieKP[0].Length]; ReprezentacjaRozwiazania genotypPotomkaKP = rekombinacjaKP.Krzyzowanie(przodekKP1, przodekKP2); potomkowieKP[i] = genotypPotomkaKP.ZwrocGenotyp1Wymiarowy(); } ushort[][] dostepnoscPrzedmiotow = rozwiazanie.ZwrocInstancjeProblemu().ZwrocDostepnePrzedmioty(); for (int i = 0; i < potomekTSP.Length; i++) { int index = potomekTSP[i] - 1; potomekTTP[i] = new ushort[potomkowieKP[0].Length + 1]; potomekTTP[i][0] = potomekTSP[i]; for (int j = 1; j <= potomkowieKP[0].Length; j++) { potomekTTP[i][j] = potomkowieKP[index][(j - 1)]; } potomekTTP[i] = (ushort[])(Mutacja(potomekTTP[i], dostepnoscPrzedmiotow[index]).Clone()); } return(SprawdzNaruszenieOgraniczen(new ReprezentacjaRozwiazania(potomekTTP))); }
/// <summary> /// Metoda tworząca nowego osobnika za pomocą wymiany materiału genetycznego pomiędzy wybranymi przodkami /// </summary> /// <param name="przodek1">1 przodek do krzyżowania</param> /// <param name="przodek2">2 przodek do krzyżowania</param> /// <returns>Osobnik - rozwiązanie</returns> public abstract ReprezentacjaRozwiazania Krzyzowanie(ReprezentacjaRozwiazania przodek1, ReprezentacjaRozwiazania przodek2);
public override Dictionary <string, float[]> FunkcjaDopasowania(ReprezentacjaRozwiazania reprezentacjaGenotypu) { return(problemOptymalizacyjny.ObliczZysk(Fenotyp(reprezentacjaGenotypu.ZwrocGenotyp1Wymiarowy()))); }
/// <summary> /// Metoda rozkodowująca rozwiązanie danego problemu optymalizacyjnego. /// </summary> /// <param name="rozwiazanie">Zakodowane rozwiązanie problemu optymalizacyjnego</param> /// <returns>Zwraca rozkodowane rozwiązanie problemu optymalizacyjnego</returns> public abstract string DekodujRozwiazanie(ReprezentacjaRozwiazania reprezentacjaGenotypu);
/// <summary> /// Metoda zwraca wartość funkcji celu /// </summary> /// <param name="genotyp">Tablica definiująca dziedzinę rozwiązania</param> /// <returns>Wartość / Wartości funkcji celu</returns> public abstract Dictionary <string, float[]> FunkcjaDopasowania(ReprezentacjaRozwiazania reprezentacjaGenotypu);
public override void ZnajdzOptimum() { int poprawy = 0, marginesBledu = parametrP; ushort[][] genotyp = reprezentacjaRozwiazania.ZwrocGenotyp2Wymiarowy(), tmpGenotyp = (ushort[][])genotyp.Clone(); string stan = "kp"; AOsobnik osobnik = losowanie.ZwrocOsobnika(); ProblemOptymalizacyjny problemOptymalizacyjny = osobnik.ZwrocInstancjeProblemu(); Dictionary <string, float[]> wynik = osobnik.FunkcjaDopasowania(reprezentacjaRozwiazania); ReprezentacjaRozwiazania tmpReprezentacjaRozwiazanie = new ReprezentacjaRozwiazania(tmpGenotyp); ushort[][] dostepnePrzedmioty = (ushort[][])problemOptymalizacyjny.ZwrocDostepnePrzedmioty().Clone(); Dictionary <string, float[]> tmpWynik = wynik; double wspolczynnik = wynik["min"][0] / problemOptymalizacyjny.ZwrocOgraniczeniaProblemu()[0]; do { poprawy = 0; if (stan == "kp") { // problem plecakowy for (int i = 1; i < tmpGenotyp.Length - 1; i++) { for (int j = 1; j < tmpGenotyp[i].Length; j++) { if (dostepnePrzedmioty[i][j - 1] == 1) { if (wspolczynnik < 1) { tmpGenotyp[i][j] = 1; } else { tmpGenotyp[i][j] = 0; } tmpReprezentacjaRozwiazanie.ZmienGenotyp(tmpGenotyp); tmpWynik = osobnik.FunkcjaDopasowania(tmpReprezentacjaRozwiazanie); wspolczynnik = tmpWynik["min"][0] / problemOptymalizacyjny.ZwrocOgraniczeniaProblemu()[0]; if (wspolczynnik > 1) { tmpGenotyp[i][j] = 0; } } } } stan = "tsp"; } if (stan == "tsp") { // problem komiwojażera for (int i = 1; i < tmpGenotyp.Length - 1; i++) { int los = losowy.Next(2, tmpGenotyp.Length - 2); ushort[] tmp = (ushort[])tmpGenotyp[i].Clone(); tmpGenotyp[i] = (ushort[])tmpGenotyp[los].Clone(); tmpGenotyp[los] = (ushort[])tmp.Clone(); } tmpReprezentacjaRozwiazanie.ZmienGenotyp(tmpGenotyp); tmpWynik = osobnik.FunkcjaDopasowania(tmpReprezentacjaRozwiazanie); stan = "kp"; } if (tmpWynik["min"][0] > problemOptymalizacyjny.ZwrocOgraniczeniaProblemu()[0]) { tmpGenotyp = (ushort[][])genotyp.Clone(); if (marginesBledu > 0) { poprawy++; marginesBledu--; } } else { if (tmpWynik["max"][0] > wynik["max"][0]) { wynik = tmpWynik; genotyp = (ushort[][])tmpGenotyp.Clone(); reprezentacjaRozwiazania.ZmienGenotyp(genotyp); poprawy++; marginesBledu = 50; } else { if (marginesBledu > 0) { poprawy++; marginesBledu--; } } } } while (poprawy > 0); }
protected override ReprezentacjaRozwiazania SprawdzNaruszenieOgraniczen(ReprezentacjaRozwiazania genotyp) { throw new NotImplementedException(); }
/// <summary> /// Metoda odpowiedzialna za naprawę osobników naruszających ograniczenia problemu /// </summary> /// <param name="genotyp">Genotyp osobnika, sprawdzany pod naruszeń ograniczeń</param> /// <returns>Naprawiony lub nie osobnik - rozwiązanie</returns> protected abstract ReprezentacjaRozwiazania SprawdzNaruszenieOgraniczen(ReprezentacjaRozwiazania genotyp);
public override string DekodujRozwiazanie(ReprezentacjaRozwiazania reprezentacjaGenotypu) { // kolejność wyboru miast zapisywana jest po spacjach return(string.Join(" ", reprezentacjaGenotypu.ZwrocGenotyp1Wymiarowy())); }
public override ReprezentacjaRozwiazania[] LosujRozwiazania(ProblemOptymalizacyjny problemOptymalizacyjny, int iloscRozwiazan, int iloscElementow) { bool startowyWektor = true; Random losowy = new Random(); ReprezentacjaRozwiazania[] rozwiazania = new ReprezentacjaRozwiazania[iloscRozwiazan]; ushort[][] dostepnoscPrzedmiotow = problemOptymalizacyjny.ZwrocDostepnePrzedmioty(); LosowanieTSP losowanieTSP = new LosowanieTSP(); ReprezentacjaRozwiazania[] rozwiazaniaTSP = losowanieTSP.LosujRozwiazania(problemOptymalizacyjny, iloscRozwiazan, problemOptymalizacyjny.ZwrocDlugoscGenotypu()); for (int i = 0; i < iloscRozwiazan; i++) { ushort[] wektorTSP = rozwiazaniaTSP[i].ZwrocGenotyp1Wymiarowy(); ushort[][] macierzTTP = new ushort[wektorTSP.Length][]; double polowa = (Math.Pow(iloscRozwiazan, 2) / 2), rozpietosc = Math.Abs(Math.Pow(iloscRozwiazan, 2) - (i + losowy.Next(iloscRozwiazan)) * iloscRozwiazan); for (int j = 0; j < wektorTSP.Length; j++) { int index = wektorTSP[j] - 1, wartosc = (int)Math.Abs(polowa - rozpietosc); double dziesiecProcent = 0.1 * wartosc; macierzTTP[j] = new ushort[dostepnoscPrzedmiotow[0].Length + 1]; macierzTTP[j][0] = wektorTSP[j]; for (int k = 1; k < macierzTTP[j].Length; k++) { if ((dostepnoscPrzedmiotow[index][(k - 1)] == 1) && !startowyWektor) { if (polowa >= rozpietosc) { macierzTTP[j][k] = (ushort)((wartosc < dziesiecProcent) ? 1 : 0); if (wartosc > 0) { wartosc -= losowy.Next(wartosc); } } else { macierzTTP[j][k] = (ushort)((wartosc < dziesiecProcent) ? 1 : 0); if (wartosc > 0) { wartosc -= (losowy.Next(wartosc) * 2); } } } else { macierzTTP[j][k] = 0; } } } rozwiazania[i] = new ReprezentacjaRozwiazania(macierzTTP); startowyWektor = false; } return(rozwiazania); }
public Task Start(IProgress <PostepBadania> postep) { int czas = 0, poprzedniaSekunda = -1, calkowityCzas = analityka.ZwrocLiczbeIteracji() * analityka.ZwrocCzasDzialaniaAlgorytmu(); PostepBadania postepBadania = new PostepBadania(); short liczbaOsobnikowPopulacji = (short)(populacjaBazowa.Length * 2 * pwoKrzyzowania); return(Task.Run(() => { for (short i = 0; i < analityka.ZwrocLiczbeIteracji(); i++) { int liczbaPokolen = 0; ReprezentacjaRozwiazania[] nowaPopulacja = new ReprezentacjaRozwiazania[liczbaOsobnikowPopulacji]; analityka.RozpocznijPomiarCzasu(); // rozpoczęcie pomiaru czasu ReprezentacjaRozwiazania[] tmpPopulacja = (ReprezentacjaRozwiazania[])populacjaBazowa.Clone(); // iterując przez wszystkie pokolenia while (analityka.IleCzasuDzialaAlgorytm("s") < analityka.ZwrocCzasDzialaniaAlgorytmu()) { // wczytujemy pewną liczbę osobników z populacji for (short j = 0; j < liczbaOsobnikowPopulacji; j += 2) { // zależną od prawdopodobieństwa kzyżowania // i przeprowadzamy operację tworzenia nowych osobników, pobierając rodziców z populacji ReprezentacjaRozwiazania mama = selekcja.WybierzOsobnika(tmpPopulacja, liczbaPokolen), tata = selekcja.WybierzOsobnika(tmpPopulacja, liczbaPokolen), dziecko1 = rekombinacja.Krzyzowanie(mama, tata), // tworząc 1 dziecko dziecko2 = rekombinacja.Krzyzowanie(tata, mama); // oraz 2 dziecko // dzieci dodajemy do nowej populacji nowaPopulacja[j] = dziecko1; // sprawdzając czy nie stworzyliśmy najlepszego rozwiązania do tej pory analityka.DopiszWartoscProcesu(i, (int)analityka.IleCzasuDzialaAlgorytm("s"), dziecko1); if (j + 1 < liczbaOsobnikowPopulacji) { nowaPopulacja[j + 1] = dziecko2; analityka.DopiszWartoscProcesu(i, (int)analityka.IleCzasuDzialaAlgorytm("s"), dziecko2); } } // wymieniamy starą populację na nową populację tmpPopulacja = (ReprezentacjaRozwiazania[])nowaPopulacja.Clone(); liczbaPokolen++; // zwiększając liczbę pokoleń if (poprzedniaSekunda == -1 || poprzedniaSekunda != (int)analityka.IleCzasuDzialaAlgorytm("s")) { czas++; poprzedniaSekunda = (int)analityka.IleCzasuDzialaAlgorytm("s"); } postepBadania.ProcentUkonczenia = (czas * 100 / calkowityCzas) - 1; if (postepBadania.ProcentUkonczenia < 0) { postepBadania.ProcentUkonczenia = 0; } if (postepBadania.ProcentUkonczenia > 100) { postepBadania.ProcentUkonczenia = 100; } postep.Report(postepBadania); } // reset pomiaru czasu analityka.ResetPomiaruCzasu(); poprzedniaSekunda = -1; } analityka.ObliczSrednieWartosciProcesu(); })); }
/// <summary> /// Metoda ustawia rozwiązanie /// </summary> /// <param name="reprezentacjaRozwiazania">Reprezentacja rozwiązania</param> public void UstawRozwiazanie(ReprezentacjaRozwiazania reprezentacjaRozwiazania) { this.reprezentacjaRozwiazania = reprezentacjaRozwiazania; }