From 677cd02e6f070d333fd70b91a512910e07bb922e Mon Sep 17 00:00:00 2001 From: Piotr Rychlicki Date: Mon, 11 May 2020 17:01:29 +0000 Subject: [PATCH] =?UTF-8?q?algorytm=20genetyczny=20do=20momentu=20krzy?= =?UTF-8?q?=C5=BCowania?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Piotrek.py | 206 ++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 197 insertions(+), 9 deletions(-) diff --git a/Piotrek.py b/Piotrek.py index 208057e..f79ae05 100644 --- a/Piotrek.py +++ b/Piotrek.py @@ -1,6 +1,5 @@ -import field - -tabela_wystapien = [0,0,0,0] +import field, pathfinding_tractorless +import random class main(): @@ -9,13 +8,15 @@ class main(): self.field = field self.ui = ui self.path = path + self.pathfinding = pathfinding_tractorless.pathfinding_tractorless() - def main(self): + def zliczanie_wystapien(self): #zlicza wystepowanie kazdego z rodzajow pol na planszy + tabela_wystapien = [0,0,0,0] for i in self.field.field_matrix: for j in i: if j == 1 or j == 3 or j == 5 or j == 7: #zliczanie zachwaszczonych pól tabela_wystapien[0] = tabela_wystapien[0] + 1 - if j == 1 or j == 2 or j == 3: #zliczanie nienawodnionych pól + elif j == 1 or j == 2 or j == 3: #zliczanie nienawodnionych pól tabela_wystapien[1] = tabela_wystapien[1] + 1 elif j == 4: #zliczanie pól gotowych do zasadzenia tabela_wystapien[2] = tabela_wystapien[2] + 1 @@ -23,7 +24,194 @@ class main(): tabela_wystapien[3] = tabela_wystapien[3] + 1 else: pass - print(j, end=" ") - print("") - print("###################") - print(tabela_wystapien) \ No newline at end of file + + def wspolrzedne(self): #wyznacza wspolrzedne pol danego rodzaju na planszy + pola_buraczane = [] + k = 0 + for i in self.field.field_matrix: + l = 0 + for j in i: + if j == 8: #w tym przypadku pol z burakami + pola_buraczane.append(k*10+l) + l = l + 1 + k = k + 1 + pierwsze_szukane_pole = pola_buraczane[0] + pola_buraczane.append(pierwsze_szukane_pole) + print("Współrzędne pól buraczanych: " + str(pola_buraczane)) + return pola_buraczane + + def trasa_buraczana(self,pola_buraczane): #wyznacza koszt trasy przez pola danego rodzaju w zadanej kolejnosci + self.liczba_pol = len(pola_buraczane) + total_cost = 0 + i = 0 + while i < (self.liczba_pol-1): + total_cost = total_cost + self.pathfinding.pathfinding_tractorless(self.field,pola_buraczane,i) + i = i + 1 + #print("Koszt przejścia przez pola buraczane rzędami: " + str(total_cost)) + #print("###################") + return total_cost + + def tworzenie_pokolenia(self,pola_buraczane,i): + x = len(pola_buraczane) - 2 + wspolrzedne_shuffle = [] + while x > 1: + wspolrzedne_shuffle.append(pola_buraczane[x]) + x = x - 1 + x = len(pola_buraczane) - 2 + lista_osobnikow = [] + while i > 0: #liczebność pierwszego pokolenia (domyślnie 10) + nowy_osobnik = random.sample(wspolrzedne_shuffle, len(wspolrzedne_shuffle)) + nowy_osobnik.insert(0,0) #dodanie na początek listy 0, jako współrzenej startowej + nowy_osobnik.insert(x,0) #dodanie na koniec listy 0, jako współrzenej końcowej + lista_osobnikow.append(nowy_osobnik) + i = i - 1 + print(lista_osobnikow) + return lista_osobnikow + + def ocena_przystosowania(self,pokolenia): + suma_kosztow_tras = 0 + ile_osobnikow = 0 + koszty_tras_osobnikow = [] + for i in pokolenia: + koszty_tras_osobnikow.append(self.trasa_buraczana(i)) + suma_kosztow_tras = suma_kosztow_tras + self.trasa_buraczana(i) + ile_osobnikow = ile_osobnikow + 1 + srednie_przystosowanie = suma_kosztow_tras/ile_osobnikow #parametr potrzebny do oceny przystosowania osobnikow + przystosowanie_osobnikow = [] + sumaryczne_przystosowanie_osobnikow = 0 + l = 0 + for i in koszty_tras_osobnikow: + przystosowanie_osobnikow.append(round(((srednie_przystosowanie/koszty_tras_osobnikow[l])*10),2)) + sumaryczne_przystosowanie_osobnikow += round(((srednie_przystosowanie/koszty_tras_osobnikow[l])*10),2) + l = l + 1 + print(str(round(sumaryczne_przystosowanie_osobnikow,2))) + print("Ocena przystosowania każdego z osobników: " + str(przystosowanie_osobnikow)) + print("Koszty tras każdego z osobników: " + str(koszty_tras_osobnikow)) + print("Średnie przystosowanie wszystkich osobników: " + str(srednie_przystosowanie)) + return(przystosowanie_osobnikow) + + def wybor_populacji_posredniej(self,pierwsze_pokolenie,przystosowanie_osobnikow): + x = len(przystosowanie_osobnikow) + tabela_ruletki = [] + populacja_posrednia = [] + i = 0 + przedzial = 0 + while x > 0: #stworzenie "koła ruletki" do selecji osobników populacji pośredniej + przedzial = przedzial + przystosowanie_osobnikow[i] + tabela_ruletki.append(round(przedzial,2)) + x = x - 1 + i = i + 1 + print(str(tabela_ruletki)) + x = len(przystosowanie_osobnikow)/2 #losowanie połowy liczby osobników populacji początkowej do populacji pośredniej + maks = tabela_ruletki[i-1] + while x > 0: + i = 0 + n = random.uniform(0, maks) #losowanie przedziału + while n > tabela_ruletki[i]: + i = i + 1 + populacja_posrednia.append(pierwsze_pokolenie[i]) + x = x - 1 + print(str(populacja_posrednia)) #populacja posrednia, z której zostanie utworzona populacja potomków + return populacja_posrednia + + def krzyzowanie(self,populacja_posrednia): + x = len(populacja_posrednia) - 1 + while x > 0: + rodzic_1 = populacja_posrednia[x] + print("Rodzic nr 1: " + str(rodzic_1)) + rodzic_2 = populacja_posrednia[x-1] + print("Rodzic nr 2: " + str(rodzic_2)) + dziecko_1 = [] + dziecko_2 = [] + czy_krzyzowac = random.randint(1,100) #losowanie czy krzyzowac rodzicow, czy nie + if (czy_krzyzowac < 78) and (rodzic_1 != rodzic_2): #jesli krzyzowanie nastepuje + print("Nastąpiło krzyżowanie") + miejsce_krzyzowania = random.randint(1,(len(populacja_posrednia[x])-3)) #wybor miejsca krzyzowania + print(str(miejsce_krzyzowania)) + print(str(rodzic_1[miejsce_krzyzowania])) + l = 0 + k = miejsce_krzyzowania + while k >= 0: #dodawanie do dziecka pierwszej połowy z pierwszego rodzica + dziecko_1.append(rodzic_1[l]) + l = l + 1 + k = k - 1 + k = miejsce_krzyzowania + while k < (len(rodzic_1)-2): #dodawanie do dziecka drugiej połowy z drugiego rodzica + for i in rodzic_2: + if i not in dziecko_1: + dziecko_1.append(i) + k = k + 1 + l = 0 + k = miejsce_krzyzowania + while k >= 0: #dodawanie do dziecka pierwszej połowy z pierwszego rodzica + dziecko_2.append(rodzic_2[l]) + l = l + 1 + k = k - 1 + k = miejsce_krzyzowania + while k < (len(rodzic_1)-2): #dodawanie do dziecka drugiej połowy z drugiego rodzica + for i in rodzic_1: + if i not in dziecko_2: + dziecko_2.append(i) + k = k + 1 + dziecko_1.append(0) + dziecko_2.append(0) + else: #jesli krzyzowanie nie nastepuje, wowczas potencjalni rodzice staja sie dziecmi + print("Krzyżowanie nie nastąpiło") + dziecko_1 = rodzic_1 + dziecko_2 = rodzic_2 + print("Dziecko nr 1: " + str(dziecko_1)) + print("Dziecko nr 2: " + str(dziecko_2)) + x = x - 1 + rodzic_1 = populacja_posrednia[0] + print("Rodzic nr 1: " + str(rodzic_1)) + rodzic_2 = populacja_posrednia[(len(populacja_posrednia)-1)] + print("Rodzic nr 2: " + str(rodzic_2)) + dziecko_1 = [] + dziecko_2 = [] + czy_krzyzowac = random.randint(1,100) #losowanie czy krzyzowac rodzicow, czy nie + if (czy_krzyzowac < 78) and (rodzic_1 != rodzic_2): #jesli krzyzowanie nastepuje + print("Nastąpiło krzyżowanie") + miejsce_krzyzowania = random.randint(1,(len(populacja_posrednia[x])-3)) #wybor miejsca krzyzowania + print(str(miejsce_krzyzowania)) + print(str(rodzic_1[miejsce_krzyzowania])) + l = 0 + k = miejsce_krzyzowania + while k >= 0: #dodawanie do dziecka pierwszej połowy z pierwszego rodzica + dziecko_1.append(rodzic_1[l]) + l = l + 1 + k = k - 1 + k = miejsce_krzyzowania + while k < (len(rodzic_1)-2): #dodawanie do dziecka drugiej połowy z drugiego rodzica + for i in rodzic_2: + if i not in dziecko_1: + dziecko_1.append(i) + k = k + 1 + l = 0 + k = miejsce_krzyzowania + while k >= 0: #dodawanie do dziecka pierwszej połowy z pierwszego rodzica + dziecko_2.append(rodzic_2[l]) + l = l + 1 + k = k - 1 + k = miejsce_krzyzowania + while k < (len(rodzic_1)-2): #dodawanie do dziecka drugiej połowy z drugiego rodzica + for i in rodzic_1: + if i not in dziecko_2: + dziecko_2.append(i) + k = k + 1 + dziecko_1.append(0) + dziecko_2.append(0) + else: #jesli krzyzowanie nie nastepuje, wowczas potencjalni rodzice staja sie dziecmi + print("Krzyżowanie nie nastąpiło") + dziecko_1 = rodzic_1 + dziecko_2 = rodzic_2 + print("Dziecko nr 1: " + str(dziecko_1)) + print("Dziecko nr 2: " + str(dziecko_2)) + + def main(self): + self.zliczanie_wystapien() + self.pola_buraczane = self.wspolrzedne() + self.koszt_trasy = self.trasa_buraczana(self.pola_buraczane) + self.pierwsze_pokolenie = self.tworzenie_pokolenia(self.pola_buraczane,10) + self.przystosowanie = self.ocena_przystosowania(self.pierwsze_pokolenie) + self.populacja_posrednia = self.wybor_populacji_posredniej(self.pierwsze_pokolenie, self.przystosowanie) + self.krzyzowanie(self.populacja_posrednia) \ No newline at end of file