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;
}