From 1e0cd0b210d09490adb36c5504b331f186f2746e Mon Sep 17 00:00:00 2001 From: Reza Date: Fri, 2 Apr 2021 02:50:29 +0430 Subject: [PATCH 1/7] Update SimulatedAnealing.py --- SimulatedAnealing.py | 92 +++++++++++++++++++++++++++++++++++--------- 1 file changed, 74 insertions(+), 18 deletions(-) diff --git a/SimulatedAnealing.py b/SimulatedAnealing.py index 9c4d8a6..41804df 100644 --- a/SimulatedAnealing.py +++ b/SimulatedAnealing.py @@ -49,6 +49,10 @@ def __init__(self,orderList:list,demand:int): self.orderList = orderList self.demand = demand +class Solution: + def __init__(self,orderList:list,minimumExtraCapacity:int): + self.orderList = orderList + self.minimumExtraCapacity = minimumExtraCapacity def readFilesAndCreateObjects(): secondFile = open("second.txt", 'rt') @@ -75,8 +79,8 @@ def calcIntervalExtraCapacity(orderList:[],intervalIndex:int): return sum - intervalsArray[intervalIndex].intervalDemand -def acceptanceProbability(currentDemand,neighbourDemand,temp): - if neighbourDemand < currentDemand : +def acceptanceProbability(currentMinimumExtraCapacity,neighbourMinimumExtraCapacity,temp): + if neighbourMinimumExtraCapacity > currentMinimumExtraCapacity : return 1.0 # print(((neighbourDemand - currentDemand)/temp)) # return ((neighbourDemand - currentDemand)/temp) @@ -95,37 +99,89 @@ def calcDemandsInOrders(orderList): for index in range(len(intervalsArray)): extraCapacity = calcIntervalExtraCapacity(orderList,index) if extraCapacity < 0 : - demand = demand + abs(extraCapacity) + demand = demand + extraCapacity print(str(index) + " extra capacity is " + str((calcIntervalExtraCapacity(orderList,index)))) - print(demand) return demand +def findMinimumIntervalCapacityInOrders(orderList): + minimum = calcIntervalExtraCapacity(orderList,0) + minimumInterval:int + minimumIntervalsList = [] + for index in range(len(intervalsArray)): + extraCapacity = calcIntervalExtraCapacity(orderList,index) + if extraCapacity < minimum : + minimum = extraCapacity + minimumInterval = index + minimumIntervalsList = [] + elif extraCapacity == minimum : + minimumIntervalsList.append(index) + if len(minimumIntervalsList)!=0: + minimumIntervalsList.append(minimumInterval) + minimumInterval = secrets.choice(minimumIntervalsList) + return minimumInterval + +def findNeighbourOrderList(orderList): + newOrder = orderList.copy() + minimumInterval = findMinimumIntervalCapacityInOrders(orderList); + print(minimumInterval) + disabledUnits= [] + for unitIndex in range(len(orderList)): + if orderList[unitIndex][minimumInterval] == 1: + disabledUnits.append(unitIndex) + print(disabledUnits) + if len(disabledUnits)!=0: + selectedUnit = secrets.choice(disabledUnits) + selectableUnitPools=[] + print(selectedUnit) + + for unitPool in unitArray[selectedUnit].unitPools: + if unitPool[minimumInterval] == 0: + selectableUnitPools.append(unitPool) + if len(selectableUnitPools)!=0: + selectedUnitPool = secrets.choice(selectableUnitPools) + print(selectedUnitPool) + newOrder[selectedUnit] = selectedUnitPool + minimumInterval = findMinimumIntervalCapacityInOrders(newOrder); + minimumValue = calcIntervalExtraCapacity(newOrder,minimumInterval) + + solution = Solution(newOrder,minimumValue) + return solution + def main() : readFilesAndCreateObjects() - - global demand orderList = fillOrders() - demand = calcDemandsInOrders(orderList) - global currentSolution - currentSolution = solution(orderList,demand) - + minimumInterval = findMinimumIntervalCapacityInOrders(orderList); + minimumValue = calcIntervalExtraCapacity(orderList, minimumInterval) + currentSolution = Solution(orderList,minimumValue) + print(currentSolution.orderList) + print(calcDemandsInOrders(currentSolution.orderList)) + print() temp = 1000 - colingRate = 1 + colingRate = 200 while(temp > 1 ): - orderList = fillOrders() - demand = calcDemandsInOrders(orderList) - newSolution = solution(orderList,demand) - if acceptanceProbability(currentSolution.demand,newSolution.demand,temp) > random(): + # orderList = fillOrders() + # demand = calcDemandsInOrders(orderList) + # newSolution = solution(orderList,demand) + # if acceptanceProbability(currentSolution.demand,newSolution.demand,temp) > random(): + # print('true') + # currentSolution = newSolution + + newSolution = findNeighbourOrderList(currentSolution.orderList) + print(newSolution.orderList) + print(calcDemandsInOrders(newSolution.orderList)) + if acceptanceProbability(currentSolution.minimumExtraCapacity,newSolution.minimumExtraCapacity,temp) > random(): print('true') currentSolution = newSolution - + print() temp = temp - colingRate # soooo this is solution print() print("answer is") print(currentSolution.orderList) - print(calcDemandsInOrders(currentSolution.orderList)) - print("deamnd is " + str(currentSolution.demand)) + print(calcDemandsInOrders(orderList)) + print("Minimum Extra is " + str(currentSolution.minimumExtraCapacity)) + # print(findMinimumIntervalCapacityInOrders(currentSolution.orderList)) + # findNeighbourOrderList(currentSolution.orderList) main() \ No newline at end of file From 766c9bc652f41704f739c83630f363dc717fca64 Mon Sep 17 00:00:00 2001 From: Reza Date: Fri, 2 Apr 2021 20:00:08 +0430 Subject: [PATCH 2/7] finished --- SimulatedAnealing.py | 127 +++++++++++++++++++------------------------ first.txt | 11 ++-- 2 files changed, 63 insertions(+), 75 deletions(-) diff --git a/SimulatedAnealing.py b/SimulatedAnealing.py index 41804df..8515eb1 100644 --- a/SimulatedAnealing.py +++ b/SimulatedAnealing.py @@ -12,9 +12,6 @@ global intervalsArray intervalsArray = [] -global orderList -orderList = [] - class Unit: def __init__(self, id, capacity, repairCount,intervalsCount): self.unitID = int(id) @@ -44,11 +41,6 @@ def __init__(self, id, demand): self.intervalID = int(id) self.intervalDemand = int(demand) -class solution: - def __init__(self,orderList:list,demand:int): - self.orderList = orderList - self.demand = demand - class Solution: def __init__(self,orderList:list,minimumExtraCapacity:int): self.orderList = orderList @@ -71,117 +63,112 @@ def readFilesAndCreateObjects(): unitArray.append(Unit(res[0], res[1], res[2], intervalCounts)) firstFile.close() -def calcIntervalExtraCapacity(orderList:[],intervalIndex:int): +def calcIntervalNeededCapacity(orderList:[], intervalIndex:int): sum = 0 - for index in range(len(unitArray)): - if orderList[index][intervalIndex] == 0 : - sum = sum + unitArray[index].unitCapacity + for unitIndex in range(len(unitArray)): + if orderList[unitIndex][intervalIndex] == 0 : + sum = sum + unitArray[unitIndex].unitCapacity return sum - intervalsArray[intervalIndex].intervalDemand def acceptanceProbability(currentMinimumExtraCapacity,neighbourMinimumExtraCapacity,temp): - if neighbourMinimumExtraCapacity > currentMinimumExtraCapacity : + if currentMinimumExtraCapacity < neighbourMinimumExtraCapacity : return 1.0 - # print(((neighbourDemand - currentDemand)/temp)) - # return ((neighbourDemand - currentDemand)/temp) - return 0 + return (math.exp(neighbourMinimumExtraCapacity - currentMinimumExtraCapacity)/temp) def fillOrders(): orderList = [] for unit in unitArray: orderList.append(secrets.choice(unit.unitPools)) - print(orderList) return orderList -def calcDemandsInOrders(orderList): - demand = 0 +def calcAllNeededInOrders(orderList): + neededCapcacity = 0 for index in range(len(intervalsArray)): - extraCapacity = calcIntervalExtraCapacity(orderList,index) + extraCapacity = calcIntervalNeededCapacity(orderList, index) if extraCapacity < 0 : - demand = demand + extraCapacity - print(str(index) + " extra capacity is " + str((calcIntervalExtraCapacity(orderList,index)))) - return demand + neededCapcacity = neededCapcacity + extraCapacity + print(str(index) + " extra capacity is " + str((calcIntervalNeededCapacity(orderList, index)))) + return neededCapcacity def findMinimumIntervalCapacityInOrders(orderList): - minimum = calcIntervalExtraCapacity(orderList,0) + minimum = calcIntervalNeededCapacity(orderList, 0) minimumInterval:int minimumIntervalsList = [] - for index in range(len(intervalsArray)): - extraCapacity = calcIntervalExtraCapacity(orderList,index) + for intervalIndex in range(len(intervalsArray)): + extraCapacity = calcIntervalNeededCapacity(orderList, intervalIndex) if extraCapacity < minimum : minimum = extraCapacity - minimumInterval = index + minimumInterval = intervalIndex minimumIntervalsList = [] elif extraCapacity == minimum : - minimumIntervalsList.append(index) + minimumIntervalsList.append(intervalIndex) if len(minimumIntervalsList)!=0: minimumIntervalsList.append(minimumInterval) minimumInterval = secrets.choice(minimumIntervalsList) + minimumIntervalsList = [] return minimumInterval -def findNeighbourOrderList(orderList): - newOrder = orderList.copy() - minimumInterval = findMinimumIntervalCapacityInOrders(orderList); - print(minimumInterval) +def findNeighbourOrderList(orderList,minimumInterval): + newOrderList = orderList.copy() disabledUnits= [] - for unitIndex in range(len(orderList)): - if orderList[unitIndex][minimumInterval] == 1: + for unitIndex in range(len(newOrderList)): + if newOrderList[unitIndex][minimumInterval] == 1: disabledUnits.append(unitIndex) - print(disabledUnits) - if len(disabledUnits)!=0: - selectedUnit = secrets.choice(disabledUnits) - selectableUnitPools=[] - print(selectedUnit) - - for unitPool in unitArray[selectedUnit].unitPools: - if unitPool[minimumInterval] == 0: - selectableUnitPools.append(unitPool) - if len(selectableUnitPools)!=0: - selectedUnitPool = secrets.choice(selectableUnitPools) - print(selectedUnitPool) - newOrder[selectedUnit] = selectedUnitPool - minimumInterval = findMinimumIntervalCapacityInOrders(newOrder); - minimumValue = calcIntervalExtraCapacity(newOrder,minimumInterval) - - solution = Solution(newOrder,minimumValue) + selectableUnitPools=[] + selectedUnit = secrets.choice(disabledUnits) + + if selectedUnit: + for unitPool in unitArray[selectedUnit].unitPools: + if unitPool[minimumInterval] == 0: + selectableUnitPools.append(unitPool) + if len(selectableUnitPools)!=0: + selectedUnitPool = secrets.choice(selectableUnitPools) + newOrderList[selectedUnit] = selectedUnitPool + newMinimumInterval = findMinimumIntervalCapacityInOrders(newOrderList); + minimumValue = calcIntervalNeededCapacity(newOrderList, newMinimumInterval) + + solution = Solution(newOrderList,minimumValue) return solution def main() : readFilesAndCreateObjects() orderList = fillOrders() - minimumInterval = findMinimumIntervalCapacityInOrders(orderList); - minimumValue = calcIntervalExtraCapacity(orderList, minimumInterval) + minimumInterval = findMinimumIntervalCapacityInOrders(orderList) + minimumValue = calcIntervalNeededCapacity(orderList, minimumInterval) + global currentSolution + global bestSolution currentSolution = Solution(orderList,minimumValue) + bestSolution = currentSolution print(currentSolution.orderList) - print(calcDemandsInOrders(currentSolution.orderList)) + print("all needed " + str(calcAllNeededInOrders(currentSolution.orderList))) print() + temp = 1000 - colingRate = 200 + colingRate = 1 while(temp > 1 ): - # orderList = fillOrders() - # demand = calcDemandsInOrders(orderList) - # newSolution = solution(orderList,demand) - # if acceptanceProbability(currentSolution.demand,newSolution.demand,temp) > random(): - # print('true') - # currentSolution = newSolution - - newSolution = findNeighbourOrderList(currentSolution.orderList) + minimumInterval = findMinimumIntervalCapacityInOrders(currentSolution.orderList); + newSolution = findNeighbourOrderList(currentSolution.orderList,minimumInterval) print(newSolution.orderList) - print(calcDemandsInOrders(newSolution.orderList)) + print("all needed " + str(calcAllNeededInOrders(newSolution.orderList))) + print("Minimum Extra is " + str(newSolution.minimumExtraCapacity)) if acceptanceProbability(currentSolution.minimumExtraCapacity,newSolution.minimumExtraCapacity,temp) > random(): print('true') currentSolution = newSolution + + if bestSolution.minimumExtraCapacity < newSolution.minimumExtraCapacity: + bestSolution = newSolution + print() temp = temp - colingRate - # soooo this is solution + # so this is answer solution print() print("answer is") - print(currentSolution.orderList) - print(calcDemandsInOrders(orderList)) - print("Minimum Extra is " + str(currentSolution.minimumExtraCapacity)) - # print(findMinimumIntervalCapacityInOrders(currentSolution.orderList)) - # findNeighbourOrderList(currentSolution.orderList) + print(bestSolution.orderList) + print("all needed " + str(calcAllNeededInOrders(bestSolution.orderList))) + print("Minimum Extra is " + str(bestSolution.minimumExtraCapacity)) + main() \ No newline at end of file diff --git a/first.txt b/first.txt index e84c0be..98224dd 100644 --- a/first.txt +++ b/first.txt @@ -1,6 +1,7 @@ -5 -1,50,1 -2,150,4 +6 +1,50,2 +2,150,3 3,90,4 -4,90,3 -4,100,5 \ No newline at end of file +4,90,5 +5,100,5 +6,100,1 \ No newline at end of file From 5975b79f16c675eea658685a1d430d6ee9445ad8 Mon Sep 17 00:00:00 2001 From: Reza Date: Sat, 3 Apr 2021 00:04:00 +0430 Subject: [PATCH 3/7] updt --- SimulatedAnealing.py | 16 ++++++++++++---- first.txt | 11 ++++++----- second.txt | 12 ++++++------ 3 files changed, 24 insertions(+), 15 deletions(-) diff --git a/SimulatedAnealing.py b/SimulatedAnealing.py index 8515eb1..c9de030 100644 --- a/SimulatedAnealing.py +++ b/SimulatedAnealing.py @@ -71,6 +71,13 @@ def calcIntervalNeededCapacity(orderList:[], intervalIndex:int): return sum - intervalsArray[intervalIndex].intervalDemand +def calcIntervalExactCapacity(orderList:[], intervalIndex:int): + sum = 0 + for unitIndex in range(len(unitArray)): + if orderList[unitIndex][intervalIndex] == 0 : + sum = sum + unitArray[unitIndex].unitCapacity + return sum + def acceptanceProbability(currentMinimumExtraCapacity,neighbourMinimumExtraCapacity,temp): if currentMinimumExtraCapacity < neighbourMinimumExtraCapacity : return 1.0 @@ -89,12 +96,12 @@ def calcAllNeededInOrders(orderList): extraCapacity = calcIntervalNeededCapacity(orderList, index) if extraCapacity < 0 : neededCapcacity = neededCapcacity + extraCapacity - print(str(index) + " extra capacity is " + str((calcIntervalNeededCapacity(orderList, index)))) + print(str(index) +" Exact Capacity is "+ str(calcIntervalExactCapacity(orderList, index)) + " & Extra Capacity is " + str((calcIntervalNeededCapacity(orderList, index)))) return neededCapcacity def findMinimumIntervalCapacityInOrders(orderList): + minimumInterval=-1 minimum = calcIntervalNeededCapacity(orderList, 0) - minimumInterval:int minimumIntervalsList = [] for intervalIndex in range(len(intervalsArray)): extraCapacity = calcIntervalNeededCapacity(orderList, intervalIndex) @@ -105,7 +112,8 @@ def findMinimumIntervalCapacityInOrders(orderList): elif extraCapacity == minimum : minimumIntervalsList.append(intervalIndex) if len(minimumIntervalsList)!=0: - minimumIntervalsList.append(minimumInterval) + if minimumInterval > -1 : + minimumIntervalsList.append(minimumInterval) minimumInterval = secrets.choice(minimumIntervalsList) minimumIntervalsList = [] return minimumInterval @@ -146,7 +154,7 @@ def main() : print() temp = 1000 - colingRate = 1 + colingRate = 10 while(temp > 1 ): minimumInterval = findMinimumIntervalCapacityInOrders(currentSolution.orderList); diff --git a/first.txt b/first.txt index 98224dd..12d34ab 100644 --- a/first.txt +++ b/first.txt @@ -1,7 +1,8 @@ -6 +7 1,50,2 2,150,3 -3,90,4 -4,90,5 -5,100,5 -6,100,1 \ No newline at end of file +3,120,4 +4,96,5 +5,158,2 +6,150,3 +7,172,4 \ No newline at end of file diff --git a/second.txt b/second.txt index 2942eef..f6c5e03 100644 --- a/second.txt +++ b/second.txt @@ -1,9 +1,9 @@ 8 -1,50 -2,60 +1,540 +2,450 3,250 -4,100 -5,200 +4,400 +5,410 6,200 -7,150 -8,250 \ No newline at end of file +7,300 +8,300 \ No newline at end of file From 7fdb2d7e3dfbd2bf7e8f2edaadcc574542bac078 Mon Sep 17 00:00:00 2001 From: Reza Date: Sat, 3 Apr 2021 13:09:49 +0430 Subject: [PATCH 4/7] Update SimulatedAnealing.py --- SimulatedAnealing.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/SimulatedAnealing.py b/SimulatedAnealing.py index c9de030..b6da4c6 100644 --- a/SimulatedAnealing.py +++ b/SimulatedAnealing.py @@ -81,7 +81,8 @@ def calcIntervalExactCapacity(orderList:[], intervalIndex:int): def acceptanceProbability(currentMinimumExtraCapacity,neighbourMinimumExtraCapacity,temp): if currentMinimumExtraCapacity < neighbourMinimumExtraCapacity : return 1.0 - return (math.exp(neighbourMinimumExtraCapacity - currentMinimumExtraCapacity)/temp) + print(math.exp((neighbourMinimumExtraCapacity - currentMinimumExtraCapacity)/temp)) + return math.exp((neighbourMinimumExtraCapacity - currentMinimumExtraCapacity)/temp) def fillOrders(): orderList = [] From 20d1a2270902a62d9755fc0d801f6d9429e22435 Mon Sep 17 00:00:00 2001 From: Reza Date: Thu, 8 Apr 2021 01:46:19 +0430 Subject: [PATCH 5/7] wip --- Genetic Algorithm.py | 241 ++++++++++++++++++++++++++++++++++++++++++ Genetic Algorithm2.py | 68 ++++++++++++ 2 files changed, 309 insertions(+) create mode 100644 Genetic Algorithm.py create mode 100644 Genetic Algorithm2.py diff --git a/Genetic Algorithm.py b/Genetic Algorithm.py new file mode 100644 index 0000000..ee132af --- /dev/null +++ b/Genetic Algorithm.py @@ -0,0 +1,241 @@ +import random +from itertools import combinations +import matplotlib.pyplot as plt +import numpy as np + + +class Genetic: + + units_data_dic = {} + units_raw_data = {} + intervals_raw_data = {} + generations = {} + fittness_list = [] + input_1_data = [] + input_2_data = [] + random_list = [] + numberOfChromosomes = 20 + Pc = 0.7 + Pm = 0.001 + generations_number = 100 + fitness_data_dic = {} + + def _init_(self, input_1, input_2): + self.input_1 = input_1 + self.input_2 = input_2 + self.input_1_data = self.input_1.readlines() + self.input_2_data = self.input_2.readlines() + self.init_fitness_array() + self.units_data_mapping() + self.intervals_data_mapping() + self.create_chromosome(self.numberOfChromosomes) + self.check_min() + self.iterate_generation() + self.replace_with_min() + self.plot_chart() + + def init_fitness_array(self): + for i in range(int(self.input_2_data[0])): + self.fitness_data_dic[i] = [] + + def iterate_generation(self): + for i in range(self.generations_number): + self.calculate_fittness() + self.roulette_wheel_selection() + self.crossover() + self.mutation() + self.overwrite_generation() + + def binary_permutations(self, binary_list): + for comb in combinations(range(len(binary_list)), binary_list.count(1)): + result = [0] * len(binary_list) + for i in comb: + result[i] = 1 + if binary_list.count(1) > 1: + count = 0 + max_ones = 0 + for i in range(0, len(result)): + if (result[i] == 0): + count = 0 + else: + count += 1 + max_ones = max(max_ones, count) + if max_ones == binary_list.count(1): + yield result + else: + yield result + + def calculate_permutation(self, resting_count, year_range): + temp_array = [] + for i in range(int(year_range)): + if resting_count != 0: + temp_array.append(1) + resting_count -= 1 + else: + temp_array.append(0) + + return self.binary_permutations(temp_array) + + def units_data_mapping(self): + counter = 0 + temp_array = [] + + for line in self.input_1_data[1:]: + temp_array.append(int(line)) + counter += 1 + if counter % 3 == 0: + self.units_raw_data[int(counter / 3 - 1)] = temp_array + temp_array = [] + + for i in range(int(self.input_1_data[0])): + self.units_data_dic[i + 1] = list(self.calculate_permutation( + self.units_raw_data[i][2], self.input_2_data[0])) + + def intervals_data_mapping(self): + counter = 0 + temp_array = [] + + for line in self.input_2_data[1:]: + temp_array.append(int(line)) + counter += 1 + if counter % 2 == 0: + self.intervals_raw_data[int(counter / 2 - 1)] = temp_array + temp_array = [] + + def create_chromosome(self, chromosome_count): + for j in range(chromosome_count): + temp_array = [] + for i in range(len(self.units_data_dic)): + temp_array.append(self.units_data_dic[i+1][random.randint( + 0, len(self.units_data_dic[i+1]) - 1)]) + + self.generations[len(self.generations)] = temp_array + temp_array = [] + + def check_min(self): + + # choose a chromosome + for j in range(len(self.generations)): + # print(self.generations[j]) + finished = False + while not finished: # continue until the chromosome is OK + # choose an interval to calculate the sumOfEnergies in that period + for i in range(int(self.input_2_data[0])): + sumOfEnergies = 0 + # choose the interval from each unit for e.g calculate sumOfEnergies in first interval + for k in range(len(self.generations[j])): + if self.generations[j][k][i] == 0: + sumOfEnergies += self.units_raw_data[k][1] + # print("period " , i , " is " , self.intervals_raw_data[i][1] , " and sumOfEnergies is ", sumOfEnergies , "\n") + # check if sumOfEnergies is not at least Min + if sumOfEnergies < self.intervals_raw_data[i][1]: + temp_array = [] + # make a new chromosome and replace it + for i in range(len(self.units_data_dic)): + temp_array.append(self.units_data_dic[i+1][random.randint( + 0, len(self.units_data_dic[i+1]) - 1)]) + self.generations[j] = temp_array + temp_array = [] + # print("chromosome changed to" , self.generations[j] , "\n") + break + if i == int(self.input_2_data[0]) - 1: + finished = True + + def replace_with_min(self): + temp = [] + for i in range(len(self.fitness_data_dic)): + arr = np.array_split( + self.fitness_data_dic[i], self.generations_number) + for j in range(len(arr)): + temp.append(min(arr[j])) + self.fitness_data_dic[i] = temp + temp = [] + + def calculate_fittness(self): + self.fittness_list = [] + for j in range(len(self.generations)): + minInInterval = float('inf') + for i in range(int(self.input_2_data[0])): + sumOfEnergies = 0 + for k in range(len(self.generations[j])): + if self.generations[j][k][i] == 0: + sumOfEnergies += self.units_raw_data[k][1] + self.fitness_data_dic[i].append( + sumOfEnergies - self.intervals_raw_data[i][1]) + if sumOfEnergies < minInInterval: + minInInterval = sumOfEnergies + self.fittness_list.append(minInInterval) + + def roulette_wheel_selection(self): + self.random_list = random.choices(self.generations, weights=self.fittness_list, + k=self.numberOfChromosomes) + # for i in range(len(self.random_list)): + # for j in range(len(self.generations)): + # if self.random_list[i] == self.generations[j]: + # print(j) + + def crossover(self): + temp_rand_index = [] + k = self.numberOfChromosomes * self.Pc + temp_rand_index = random.sample( + range(0, self.numberOfChromosomes), int(k)) + temp_length = len(temp_rand_index) + if temp_length % 2 != 0: + temp_length -= 1 + + for i in range(0, temp_length-1, 2): + crossover_point = random.randint(1, len(self.units_data_dic)-1) + # print("BEFORE \n") + # print(self.random_list[temp_rand_index[i]]) + # print(self.random_list[temp_rand_index[i+1]]) + temp_part = self.random_list[temp_rand_index[i] + ][crossover_point:len(self.units_data_dic)] + self.random_list[temp_rand_index[i]][crossover_point:len( + self.units_data_dic)] = self.random_list[temp_rand_index[i+1]][crossover_point:len(self.units_data_dic)] + self.random_list[temp_rand_index[i+1]][crossover_point:len( + self.units_data_dic)] = temp_part + # print("POINT : ", crossover_point) + # print("AFTER \n") + # print(self.random_list[temp_rand_index[i]]) + # print(self.random_list[temp_rand_index[i+1]]) + # print("------------------") + + def mutation(self): + + k = self.numberOfChromosomes * len(self.units_data_dic) * self.Pm + temp_rand_index = random.sample( + range(0, self.numberOfChromosomes * len(self.units_data_dic)), int(k)) + + # print(self.random_list, "\n") + # print(self.units_data_dic, "\n") + # print(temp_rand_index, "\n") + for i in range(len(temp_rand_index)): + counter = 0 + for j in range(len(self.random_list)): + for k in range(len(self.random_list[j])): + if counter == temp_rand_index[i]: + random_unit_index = random.randint( + 0, len(self.units_data_dic[counter % len(self.units_data_dic)+1])-1) + self.random_list[j][k] = self.units_data_dic[counter % len( + self.units_data_dic)+1][random_unit_index] + # print(counter % len(self.units_data_dic)+1) + # print(self.units_data_dic[counter % len(self.units_data_dic)+1][random_unit_index] , "\n") + + # print(counter, "\n", + # self.random_list[j][k], "\n --------------") + counter += 1 + + def overwrite_generation(self): + for i in range(len(self.generations)): + self.generations[i] = self.random_list[i] + + def plot_chart(self): + y_axis = [] + for i in range(self.generations_number): + y_axis.append(i+1) + for i in range(len(self.fitness_data_dic)): + plt.plot(y_axis, self.fitness_data_dic[i]) + plt.xlabel('x - axis') + plt.ylabel('y - axis') + plt.title('Season Number {}'.format(i+1)) + plt.show() \ No newline at end of file diff --git a/Genetic Algorithm2.py b/Genetic Algorithm2.py new file mode 100644 index 0000000..b486cd2 --- /dev/null +++ b/Genetic Algorithm2.py @@ -0,0 +1,68 @@ +from collections import deque +import secrets +from random import random +import math + +global unitCounts +global intervalCounts + +global unitArray +unitArray = [] + +global intervalsArray +intervalsArray = [] + + +class Unit: + def __init__(self, id, capacity, repairCount,intervalsCount): + self.unitID = int(id) + self.unitCapacity = int(capacity) + self.unitRepairCount = int(repairCount) + self.unitPools = self.genreatePools(self.unitRepairCount,intervalsCount) + + def genreatePools(self,reapirCount,intervals): + pools = [] + tempArray = [] + for x in range(reapirCount): + tempArray.append(1) + for x in range(intervals-reapirCount): + tempArray.append(0) + + pools.append(tempArray) + items = deque(tempArray) + for x in range(intervals-reapirCount): + items.rotate(1) + pools.append(list(items)) + # print(pools) + return pools + + +class Interval: + def __init__(self, id, demand): + self.intervalID = int(id) + self.intervalDemand = int(demand) + +def readFilesAndCreateObjects(): + secondFile = open("second.txt", 'rt') + lines = secondFile.read().split('\n') + intervalCounts = int(lines.pop(0)) + for line in lines: + res = line.split(',') + intervalsArray.append(Interval(res[0], res[1])) + secondFile.close() + + firstFile = open("first.txt", "rt") + lines = firstFile.read().split('\n') + unitCounts = int(lines.pop(0)) + for line in lines: + res = line.split(',') + unitArray.append(Unit(res[0], res[1], res[2], intervalCounts)) + firstFile.close() + + + +def main() : + readFilesAndCreateObjects() + + +main() From 0dbae9daa4d6c346ab3860207f6dfdb42b4f9d18 Mon Sep 17 00:00:00 2001 From: Reza Date: Fri, 9 Apr 2021 14:17:21 +0430 Subject: [PATCH 6/7] genetic finished --- Genetic Algorithm2.py | 224 ++++++++++++++++++++++++++++++++++++++---- SimulatedAnealing.py | 14 +-- 2 files changed, 212 insertions(+), 26 deletions(-) diff --git a/Genetic Algorithm2.py b/Genetic Algorithm2.py index b486cd2..59f8b20 100644 --- a/Genetic Algorithm2.py +++ b/Genetic Algorithm2.py @@ -1,6 +1,8 @@ from collections import deque import secrets +from random import randrange from random import random + import math global unitCounts @@ -12,6 +14,23 @@ global intervalsArray intervalsArray = [] +def readFilesAndCreateObjects(): + secondFile = open("second.txt", 'rt') + lines = secondFile.read().split('\n') + intervalCounts = int(lines.pop(0)) + for line in lines: + res = line.split(',') + intervalsArray.append(Interval(res[0], res[1])) + secondFile.close() + + firstFile = open("first.txt", "rt") + lines = firstFile.read().split('\n') + unitCounts = int(lines.pop(0)) + for line in lines: + res = line.split(',') + unitArray.append(Unit(res[0], res[1], res[2], intervalCounts)) + firstFile.close() + class Unit: def __init__(self, id, capacity, repairCount,intervalsCount): @@ -42,27 +61,194 @@ def __init__(self, id, demand): self.intervalID = int(id) self.intervalDemand = int(demand) -def readFilesAndCreateObjects(): - secondFile = open("second.txt", 'rt') - lines = secondFile.read().split('\n') - intervalCounts = int(lines.pop(0)) - for line in lines: - res = line.split(',') - intervalsArray.append(Interval(res[0], res[1])) - secondFile.close() - - firstFile = open("first.txt", "rt") - lines = firstFile.read().split('\n') - unitCounts = int(lines.pop(0)) - for line in lines: - res = line.split(',') - unitArray.append(Unit(res[0], res[1], res[2], intervalCounts)) - firstFile.close() - - +class Population: + def __init__(self,size,initialize): + self.size = size + self.individulas = [None] * size + if initialize=='true': + for i in range(size): + indiv = generateIndividual() + self.individulas[i] = indiv + self.saveIndividual(i,indiv) + + def saveIndividual(self,index,indiv): + self.individulas[index] = indiv + + def getIndividual(self,i): + return self.individulas[i] + + # tested + def getFittestInPop(self): + fittest = self.individulas[0] + for i in range(len(self.individulas)): + if self.findMinimumIntervalCapacityInOrders(fittest) <= self.findMinimumIntervalCapacityInOrders(self.individulas[i]): + fittest = self.individulas[i] + return fittest + + def getFittestFitnessRate(self): + fit = self.getFittestInPop() + return self.findMinimumIntervalCapacityInOrders(fit) + + # tested + def findMinimumIntervalCapacityInOrders(self,orderList): + minimumInterval = -1 + minimum = self.calcIntervalExtraCapacity(orderList, 0) + minimumIntervalsList = [] + for intervalIndex in range(len(intervalsArray)): + extraCapacity = self.calcIntervalExtraCapacity(orderList, intervalIndex) + if extraCapacity < minimum: + minimum = extraCapacity + minimumInterval = intervalIndex + minimumIntervalsList = [] + elif extraCapacity == minimum: + minimumIntervalsList.append(intervalIndex) + if len(minimumIntervalsList) != 0: + if minimumInterval > -1: + minimumIntervalsList.append(minimumInterval) + minimumInterval = secrets.choice(minimumIntervalsList) + minimumIntervalsList = [] + # return minimumInterval + return self.calcIntervalExtraCapacity(orderList, minimumInterval) + + # tested + def calcIntervalExtraCapacity(self,orderList: [], intervalIndex: int): + sum = 0 + for unitIndex in range(len(unitArray)): + if orderList[unitIndex][intervalIndex] == 0: + sum = sum + unitArray[unitIndex].unitCapacity + return sum - intervalsArray[intervalIndex].intervalDemand + + # for test + def calcAllNeededInOrders(self,orderList): + neededCapcacity = 0 + for index in range(len(intervalsArray)): + extraCapacity = self.calcIntervalExtraCapacity(orderList, index) + if extraCapacity < 0: + neededCapcacity = neededCapcacity + extraCapacity + print(str(index) + " & Extra Capacity is " + str( + (self.calcIntervalExtraCapacity(orderList, index)))) + return neededCapcacity ## # + + + +class Algorithm: + def __init__(self,uniformRate,mutationRate,tournamentSize,elitism): + self.uniformRate = uniformRate + self.mutationRate = mutationRate + self.tournamentSize = tournamentSize + self.elitism = elitism + + def evelopePopulation(self,pop:Population): + newPopulation = Population(pop.size,'false') + + # keep the best + if self.elitism=='true': + newPopulation.saveIndividual(0,pop.getFittestInPop()) + + # crossover Population + if self.elitism=='true': + self.elitismOffset = 1 + else : + self.elitismOffset = 0; + + #crossover + + for i in range(self.elitismOffset,pop.size,1): + indiv1 = self.tournamentSelection(pop) + indiv2 = self.tournamentSelection(pop) + newIndiv = self.crossover(indiv1,indiv2) + newPopulation.saveIndividual(i,newIndiv) + # print(str(i) + " is") + # printIndividuals(newIndiv) + # print('changed') + # printIndividuals(newPopulation.individulas) + + for i in range(self.elitismOffset,pop.size,1): + mutatedIndiv = self.mutate(newPopulation.getIndividual(i)) + newPopulation.saveIndividual(i,mutatedIndiv) + + return newPopulation + + # tested + def crossover(self,indiv1,indiv2): + newIndiv = [None] * len(indiv1) + for i in range(len(indiv1)): + if random() <= self.uniformRate: + newIndiv[i] = indiv1[i] + else: + newIndiv[i] = indiv2[i] + return newIndiv + + def mutate(self,indiv): + for i in range(len(indiv)): + if random() <= self.mutationRate: + randomGenePoll = secrets.choice(unitArray[i].unitPools) + indiv[i] = randomGenePoll + return indiv + + def tournamentSelection(self,pop:Population): + tournomentPop = Population(self.tournamentSize,'false') + for i in range(self.tournamentSize): + randomID = randrange(pop.size) + tournomentPop.saveIndividual(i,pop.getIndividual(randomID)) + + fittest = tournomentPop.getFittestInPop() + # print(tournomentPop.individulas[0]) + # print(tournomentPop.individulas[1]) + # print(self.crossover(tournomentPop.individulas[0],tournomentPop.individulas[1])) + + # for test + # print(tournomentPop.calcAllNeededInOrders(fittest)) + return fittest + + + +def generateIndividual(): + individual = [] + for unit in unitArray: + individual.append(secrets.choice(unit.unitPools)) + return individual + +def printIndividuals(indivLists:list): + for i in indivLists: + print(i) + + +def printPop(pop:Population,number): + print('pop test' + str(number)) + for i in range(len(pop.individulas)): + print('indiv' + str(i)) + print(pop.calcAllNeededInOrders(pop.individulas[i])) + print() def main() : readFilesAndCreateObjects() - + pop = Population(10,'true') + # printIndividuals(pop.individulas) + + # printPop(pop,1) + + # print(pop.getFittestInPop()) + # print(pop.getFittestFitnessRate()) + algorithm = Algorithm(0.5,0.015,5,'true') + newPop = algorithm.evelopePopulation(pop) + # print(algorithm.mutate(pop.individulas[9])) + # algorithm.tournamentSelection(pop) + # print(pop.getFittestInPop()) + # print(pop.calcAllNeededInOrders(pop.getFittestInPop())) + + generationCount = 100 + for generationIndex in range(generationCount): + if pop.getFittestFitnessRate() <= newPop.getFittestFitnessRate(): + print("generation: "+ str(generationIndex) + " fittest: " + str(newPop.getFittestFitnessRate())) + pop = newPop + newPop = algorithm.evelopePopulation(pop) + + print() + print('answer is') + fittest = pop.getFittestInPop() + print(fittest) + print(pop.calcAllNeededInOrders(fittest)) + print("fittest fitness is: " + str(pop.getFittestFitnessRate())) main() diff --git a/SimulatedAnealing.py b/SimulatedAnealing.py index b6da4c6..cd5a68d 100644 --- a/SimulatedAnealing.py +++ b/SimulatedAnealing.py @@ -63,7 +63,7 @@ def readFilesAndCreateObjects(): unitArray.append(Unit(res[0], res[1], res[2], intervalCounts)) firstFile.close() -def calcIntervalNeededCapacity(orderList:[], intervalIndex:int): +def calcIntervalExtraCapacity(orderList:[], intervalIndex:int): sum = 0 for unitIndex in range(len(unitArray)): if orderList[unitIndex][intervalIndex] == 0 : @@ -94,18 +94,18 @@ def fillOrders(): def calcAllNeededInOrders(orderList): neededCapcacity = 0 for index in range(len(intervalsArray)): - extraCapacity = calcIntervalNeededCapacity(orderList, index) + extraCapacity = calcIntervalExtraCapacity(orderList, index) if extraCapacity < 0 : neededCapcacity = neededCapcacity + extraCapacity - print(str(index) +" Exact Capacity is "+ str(calcIntervalExactCapacity(orderList, index)) + " & Extra Capacity is " + str((calcIntervalNeededCapacity(orderList, index)))) + print(str(index) +" Exact Capacity is "+ str(calcIntervalExactCapacity(orderList, index)) + " & Extra Capacity is " + str((calcIntervalExtraCapacity(orderList, index)))) return neededCapcacity def findMinimumIntervalCapacityInOrders(orderList): minimumInterval=-1 - minimum = calcIntervalNeededCapacity(orderList, 0) + minimum = calcIntervalExtraCapacity(orderList, 0) minimumIntervalsList = [] for intervalIndex in range(len(intervalsArray)): - extraCapacity = calcIntervalNeededCapacity(orderList, intervalIndex) + extraCapacity = calcIntervalExtraCapacity(orderList, intervalIndex) if extraCapacity < minimum : minimum = extraCapacity minimumInterval = intervalIndex @@ -136,7 +136,7 @@ def findNeighbourOrderList(orderList,minimumInterval): selectedUnitPool = secrets.choice(selectableUnitPools) newOrderList[selectedUnit] = selectedUnitPool newMinimumInterval = findMinimumIntervalCapacityInOrders(newOrderList); - minimumValue = calcIntervalNeededCapacity(newOrderList, newMinimumInterval) + minimumValue = calcIntervalExtraCapacity(newOrderList, newMinimumInterval) solution = Solution(newOrderList,minimumValue) return solution @@ -145,7 +145,7 @@ def main() : readFilesAndCreateObjects() orderList = fillOrders() minimumInterval = findMinimumIntervalCapacityInOrders(orderList) - minimumValue = calcIntervalNeededCapacity(orderList, minimumInterval) + minimumValue = calcIntervalExtraCapacity(orderList, minimumInterval) global currentSolution global bestSolution currentSolution = Solution(orderList,minimumValue) From ba01b98e380a591ff0993075ccb39af3cb43664e Mon Sep 17 00:00:00 2001 From: Reza Date: Fri, 9 Apr 2021 14:25:59 +0430 Subject: [PATCH 7/7] logs removed --- Genetic Algorithm.py | 241 ------------------------------------------ Genetic Algorithm2.py | 32 ++---- 2 files changed, 7 insertions(+), 266 deletions(-) delete mode 100644 Genetic Algorithm.py diff --git a/Genetic Algorithm.py b/Genetic Algorithm.py deleted file mode 100644 index ee132af..0000000 --- a/Genetic Algorithm.py +++ /dev/null @@ -1,241 +0,0 @@ -import random -from itertools import combinations -import matplotlib.pyplot as plt -import numpy as np - - -class Genetic: - - units_data_dic = {} - units_raw_data = {} - intervals_raw_data = {} - generations = {} - fittness_list = [] - input_1_data = [] - input_2_data = [] - random_list = [] - numberOfChromosomes = 20 - Pc = 0.7 - Pm = 0.001 - generations_number = 100 - fitness_data_dic = {} - - def _init_(self, input_1, input_2): - self.input_1 = input_1 - self.input_2 = input_2 - self.input_1_data = self.input_1.readlines() - self.input_2_data = self.input_2.readlines() - self.init_fitness_array() - self.units_data_mapping() - self.intervals_data_mapping() - self.create_chromosome(self.numberOfChromosomes) - self.check_min() - self.iterate_generation() - self.replace_with_min() - self.plot_chart() - - def init_fitness_array(self): - for i in range(int(self.input_2_data[0])): - self.fitness_data_dic[i] = [] - - def iterate_generation(self): - for i in range(self.generations_number): - self.calculate_fittness() - self.roulette_wheel_selection() - self.crossover() - self.mutation() - self.overwrite_generation() - - def binary_permutations(self, binary_list): - for comb in combinations(range(len(binary_list)), binary_list.count(1)): - result = [0] * len(binary_list) - for i in comb: - result[i] = 1 - if binary_list.count(1) > 1: - count = 0 - max_ones = 0 - for i in range(0, len(result)): - if (result[i] == 0): - count = 0 - else: - count += 1 - max_ones = max(max_ones, count) - if max_ones == binary_list.count(1): - yield result - else: - yield result - - def calculate_permutation(self, resting_count, year_range): - temp_array = [] - for i in range(int(year_range)): - if resting_count != 0: - temp_array.append(1) - resting_count -= 1 - else: - temp_array.append(0) - - return self.binary_permutations(temp_array) - - def units_data_mapping(self): - counter = 0 - temp_array = [] - - for line in self.input_1_data[1:]: - temp_array.append(int(line)) - counter += 1 - if counter % 3 == 0: - self.units_raw_data[int(counter / 3 - 1)] = temp_array - temp_array = [] - - for i in range(int(self.input_1_data[0])): - self.units_data_dic[i + 1] = list(self.calculate_permutation( - self.units_raw_data[i][2], self.input_2_data[0])) - - def intervals_data_mapping(self): - counter = 0 - temp_array = [] - - for line in self.input_2_data[1:]: - temp_array.append(int(line)) - counter += 1 - if counter % 2 == 0: - self.intervals_raw_data[int(counter / 2 - 1)] = temp_array - temp_array = [] - - def create_chromosome(self, chromosome_count): - for j in range(chromosome_count): - temp_array = [] - for i in range(len(self.units_data_dic)): - temp_array.append(self.units_data_dic[i+1][random.randint( - 0, len(self.units_data_dic[i+1]) - 1)]) - - self.generations[len(self.generations)] = temp_array - temp_array = [] - - def check_min(self): - - # choose a chromosome - for j in range(len(self.generations)): - # print(self.generations[j]) - finished = False - while not finished: # continue until the chromosome is OK - # choose an interval to calculate the sumOfEnergies in that period - for i in range(int(self.input_2_data[0])): - sumOfEnergies = 0 - # choose the interval from each unit for e.g calculate sumOfEnergies in first interval - for k in range(len(self.generations[j])): - if self.generations[j][k][i] == 0: - sumOfEnergies += self.units_raw_data[k][1] - # print("period " , i , " is " , self.intervals_raw_data[i][1] , " and sumOfEnergies is ", sumOfEnergies , "\n") - # check if sumOfEnergies is not at least Min - if sumOfEnergies < self.intervals_raw_data[i][1]: - temp_array = [] - # make a new chromosome and replace it - for i in range(len(self.units_data_dic)): - temp_array.append(self.units_data_dic[i+1][random.randint( - 0, len(self.units_data_dic[i+1]) - 1)]) - self.generations[j] = temp_array - temp_array = [] - # print("chromosome changed to" , self.generations[j] , "\n") - break - if i == int(self.input_2_data[0]) - 1: - finished = True - - def replace_with_min(self): - temp = [] - for i in range(len(self.fitness_data_dic)): - arr = np.array_split( - self.fitness_data_dic[i], self.generations_number) - for j in range(len(arr)): - temp.append(min(arr[j])) - self.fitness_data_dic[i] = temp - temp = [] - - def calculate_fittness(self): - self.fittness_list = [] - for j in range(len(self.generations)): - minInInterval = float('inf') - for i in range(int(self.input_2_data[0])): - sumOfEnergies = 0 - for k in range(len(self.generations[j])): - if self.generations[j][k][i] == 0: - sumOfEnergies += self.units_raw_data[k][1] - self.fitness_data_dic[i].append( - sumOfEnergies - self.intervals_raw_data[i][1]) - if sumOfEnergies < minInInterval: - minInInterval = sumOfEnergies - self.fittness_list.append(minInInterval) - - def roulette_wheel_selection(self): - self.random_list = random.choices(self.generations, weights=self.fittness_list, - k=self.numberOfChromosomes) - # for i in range(len(self.random_list)): - # for j in range(len(self.generations)): - # if self.random_list[i] == self.generations[j]: - # print(j) - - def crossover(self): - temp_rand_index = [] - k = self.numberOfChromosomes * self.Pc - temp_rand_index = random.sample( - range(0, self.numberOfChromosomes), int(k)) - temp_length = len(temp_rand_index) - if temp_length % 2 != 0: - temp_length -= 1 - - for i in range(0, temp_length-1, 2): - crossover_point = random.randint(1, len(self.units_data_dic)-1) - # print("BEFORE \n") - # print(self.random_list[temp_rand_index[i]]) - # print(self.random_list[temp_rand_index[i+1]]) - temp_part = self.random_list[temp_rand_index[i] - ][crossover_point:len(self.units_data_dic)] - self.random_list[temp_rand_index[i]][crossover_point:len( - self.units_data_dic)] = self.random_list[temp_rand_index[i+1]][crossover_point:len(self.units_data_dic)] - self.random_list[temp_rand_index[i+1]][crossover_point:len( - self.units_data_dic)] = temp_part - # print("POINT : ", crossover_point) - # print("AFTER \n") - # print(self.random_list[temp_rand_index[i]]) - # print(self.random_list[temp_rand_index[i+1]]) - # print("------------------") - - def mutation(self): - - k = self.numberOfChromosomes * len(self.units_data_dic) * self.Pm - temp_rand_index = random.sample( - range(0, self.numberOfChromosomes * len(self.units_data_dic)), int(k)) - - # print(self.random_list, "\n") - # print(self.units_data_dic, "\n") - # print(temp_rand_index, "\n") - for i in range(len(temp_rand_index)): - counter = 0 - for j in range(len(self.random_list)): - for k in range(len(self.random_list[j])): - if counter == temp_rand_index[i]: - random_unit_index = random.randint( - 0, len(self.units_data_dic[counter % len(self.units_data_dic)+1])-1) - self.random_list[j][k] = self.units_data_dic[counter % len( - self.units_data_dic)+1][random_unit_index] - # print(counter % len(self.units_data_dic)+1) - # print(self.units_data_dic[counter % len(self.units_data_dic)+1][random_unit_index] , "\n") - - # print(counter, "\n", - # self.random_list[j][k], "\n --------------") - counter += 1 - - def overwrite_generation(self): - for i in range(len(self.generations)): - self.generations[i] = self.random_list[i] - - def plot_chart(self): - y_axis = [] - for i in range(self.generations_number): - y_axis.append(i+1) - for i in range(len(self.fitness_data_dic)): - plt.plot(y_axis, self.fitness_data_dic[i]) - plt.xlabel('x - axis') - plt.ylabel('y - axis') - plt.title('Season Number {}'.format(i+1)) - plt.show() \ No newline at end of file diff --git a/Genetic Algorithm2.py b/Genetic Algorithm2.py index 59f8b20..713ba01 100644 --- a/Genetic Algorithm2.py +++ b/Genetic Algorithm2.py @@ -142,7 +142,7 @@ def evelopePopulation(self,pop:Population): newPopulation = Population(pop.size,'false') # keep the best - if self.elitism=='true': + if self.elitism == 'true': newPopulation.saveIndividual(0,pop.getFittestInPop()) # crossover Population @@ -151,18 +151,16 @@ def evelopePopulation(self,pop:Population): else : self.elitismOffset = 0; - #crossover - + # crossover + # tested for i in range(self.elitismOffset,pop.size,1): indiv1 = self.tournamentSelection(pop) indiv2 = self.tournamentSelection(pop) newIndiv = self.crossover(indiv1,indiv2) newPopulation.saveIndividual(i,newIndiv) - # print(str(i) + " is") - # printIndividuals(newIndiv) - # print('changed') - # printIndividuals(newPopulation.individulas) + # mutate + # tested for i in range(self.elitismOffset,pop.size,1): mutatedIndiv = self.mutate(newPopulation.getIndividual(i)) newPopulation.saveIndividual(i,mutatedIndiv) @@ -179,6 +177,7 @@ def crossover(self,indiv1,indiv2): newIndiv[i] = indiv2[i] return newIndiv + # tested def mutate(self,indiv): for i in range(len(indiv)): if random() <= self.mutationRate: @@ -193,12 +192,6 @@ def tournamentSelection(self,pop:Population): tournomentPop.saveIndividual(i,pop.getIndividual(randomID)) fittest = tournomentPop.getFittestInPop() - # print(tournomentPop.individulas[0]) - # print(tournomentPop.individulas[1]) - # print(self.crossover(tournomentPop.individulas[0],tournomentPop.individulas[1])) - - # for test - # print(tournomentPop.calcAllNeededInOrders(fittest)) return fittest @@ -224,19 +217,8 @@ def printPop(pop:Population,number): def main() : readFilesAndCreateObjects() pop = Population(10,'true') - # printIndividuals(pop.individulas) - - # printPop(pop,1) - - # print(pop.getFittestInPop()) - # print(pop.getFittestFitnessRate()) - algorithm = Algorithm(0.5,0.015,5,'true') + algorithm = Algorithm(0.7,0.5,4,'true') newPop = algorithm.evelopePopulation(pop) - # print(algorithm.mutate(pop.individulas[9])) - # algorithm.tournamentSelection(pop) - # print(pop.getFittestInPop()) - # print(pop.calcAllNeededInOrders(pop.getFittestInPop())) - generationCount = 100 for generationIndex in range(generationCount): if pop.getFittestFitnessRate() <= newPop.getFittestFitnessRate():