def test_get_current_time(self): solution = Solution(temp_test_case, 1, 100) solution.answer = list(temp_test_case) solution.alphas = [1, 1, 1] ans = Solution.get_current_time(solution, 'Kraków', solution.all_available_time) [current_time, currently_available_time] = ans self.assertEqual(0, current_time) self.assertEqual(73, currently_available_time ) # 100-[Warszawa(15)+trasa(2)+Lublin(10)] = 73 # --------------------------------------------------- solution = Solution(temp_test_case_2, 1, 100) solution.answer = list(temp_test_case) solution.alphas = [1, 1, 1] ans = Solution.get_current_time(solution, 'Warszawa', solution.all_available_time) [current_time, currently_available_time] = ans self.assertEqual(0, current_time) self.assertEqual(50, currently_available_time ) # 100-[Kraków(30)+trasa(2)+Lublin(20)] = 50
def test_solution_functions(self): rating1 = [3, 2, 1, 3] skill1 = [[1, 1, 2, 2], [2, 1, 1, 2], [1, 1, 2, 1]] sol1 = [2, 2, 0, 0] solution1 = Solution(employee_number=3, company_number=len(sol1), premade_list=sol1) self.assertEqual(solution1.f_target(rating1, skill1), 13) emp_time = [1.5, 2, 1] comp_time = [1, 1, 0.5, 0.5] parameters = Parameters(rating1, skill1, emp_time, comp_time) self.assertEqual(solution1.f_penalty(emp_time, comp_time), 4) self.assertEqual(solution1.adaptation(parameters), 9)
def load_populacja(params: Parameters) -> Population: temp_employee_number = 0 temp_company_number = 0 population_size = 0 solutions = [] f = open("populacja.txt", "r") f_lines = f.readlines() for i in range(len(f_lines)): if f_lines[i] == 'EMPLOYEE_NUMBER' + '\n': temp_employee_number = int(f_lines[i + 1]) if f_lines[i] == 'COMPANY_NUMBER' + '\n': temp_company_number = int(f_lines[i + 1]) if f_lines[i] == 'POPULATION_NUMBER' + '\n': population_size = int(f_lines[i + 1]) if f_lines[i] == 'POPULATION_MEMBERS' + '\n': for j in range(population_size): solutions.append(line2list(f_lines[i + 1 + j])) f.close() solution_list = [] for j in range(population_size): solution_list.append( Solution(temp_employee_number, temp_company_number, premade_list=solutions[j])) return Population(params, solution_list)
def test_init(self): solution = Solution(temp_test_case, 10, 100) self.assertEqual(len(temp_test_case), len(solution.answer)) self.assertEqual(len(temp_test_case), len(solution.alphas)) self.assertEqual(100, solution.all_available_time) self.assertEqual(len(temp_test_case), len(solution.t_displacement)) self.assertEqual(temp_test_case, solution.test_case)
def test_set_and_get_solution(self): board = Board() room = random.choice(list(board.rooms.items())) player_card = random.choice(list(board.player_cards.items())) weapon = random.choice(list(board.weapons.items())) room = {room[0]: room[1]} player_card = {player_card[0]: player_card[1]} weapon = {weapon[0]: weapon[1]} solution = Solution(room, player_card, weapon) r, p, w = solution.get_solution() self.assertEqual(r, room) self.assertEqual(p, player_card) self.assertEqual(w, weapon)
def test_check_solution(self): board = Board() room = random.choice(list(board.rooms.items())) player_card = random.choice(list(board.player_cards.items())) weapon = random.choice(list(board.weapons.items())) room = {room[0]: room[1]} player_card = {player_card[0]: player_card[1]} weapon = {weapon[0]: weapon[1]} solution = Solution(room, player_card, weapon) b = solution.check_solution(list(room.values())[0], list(player_card.values())[0], list(weapon.values())[0]) self.assertEqual(b, True) b = solution.check_solution('h', list(player_card.values())[0], list(weapon.values())[0]) self.assertEqual(b, False)
def test_it_instanciates_a_user(self): expectedLon = 3.879483 expectedLat = 43.608177 user = Solution(lines, StringToDecimal).user() assert isinstance(user, User) assert user.lat == expectedLat assert user.lon == expectedLon
def matrix_to_solution(self, matrix: List[List[bool]]) -> Solution: """ transforms a two-dimensional binary list into a chromosome """ cars: List[Car] = [ Car(self.dataset.bonus) for _ in range(self.dataset.ncars) ] solution: Solution = Solution(cars, self.dataset.rides.copy()) solution.matrix_allocation(matrix) return solution
def algorithm(test_case: dict, velocity: int, available_time: int, t_max: int, t_min: int, num_of_neig: int, len_of_sol: int) -> List[Solution]: solution = Solution(test_case, velocity, available_time) current_solution = deepcopy(solution) best_solutions = [] for temperature in range(t_max, t_min, -1): solution = deepcopy(current_solution) temp_list = [] for iterator in range(0, num_of_neig): if_not_exist = Solution.neighborhood_of_solution(solution) temp_list.append((deepcopy(solution), if_not_exist)) if if_not_exist: break temp_list.sort(key=lambda sol: sol[0].satisfaction_points, reverse=True) if_not_exist = temp_list[0][1] solution = temp_list[0][0] if if_not_exist: if_doesnt_work = Solution.neigh_if_few_test_cases(solution) if if_doesnt_work: best_solutions.append(current_solution) break next_solution = deepcopy(solution) difference_of_energy = next_solution.satisfaction_points - current_solution.satisfaction_points if difference_of_energy > 0: current_solution = next_solution best_solutions.append(next_solution) elif exp(difference_of_energy / temperature) > random(): current_solution = next_solution if len(best_solutions) > len_of_sol: best_solutions.sort(key=lambda sol: sol.satisfaction_points) del best_solutions[0] return best_solutions
def generate_public_cards_and_solution(self, player_cards, rooms, weapons, players): """Generates the card deck and the solution to the game, deals out the cards to the players Args: player_cards: the dict of player_cards rooms: the dict of rooms weapons: the dict of weapons players: the dict of players Returns: Arr: all the cards which can be taken by the players CardDeck: the empty card deck for some reason ( I should of removed this as a return ) Solution: the solution to the game """ public_cards = player_cards | rooms | weapons player_cards_chosen = random.choice(list(player_cards.items())) rooms_chosen = random.choice(list(rooms.items())) weapons_chosen = random.choice(list(weapons.items())) del public_cards[player_cards_chosen[0]] del public_cards[rooms_chosen[0]] del public_cards[weapons_chosen[0]] solution = Solution({rooms_chosen[0]: rooms_chosen[1]}, {player_cards_chosen[0]: player_cards_chosen[1]}, {weapons_chosen[0]: weapons_chosen[1]}) card_deck = CardDeck() card_deck.convert_dict_and_add_to_deck(public_cards) # The most simplistic method was a buggy mess for some reason so I just had to improvise with a not so efficient method instead cards = [] card_dicts = [] player_objs = list(players.values()) for c in range(len(card_deck)): cards.append(card_deck.pop_card()) cards_split = np.array_split(cards, len(players)) for i in range(len(players)): card_dicts.append( {k: v for d in cards_split[i] for k, v in d.items()}) for i in range(len(player_objs)): player_objs[i].hand.convert_dict_and_add_to_deck(card_dicts[i]) return public_cards, card_deck, solution
def solve(self): # housekeeping step_counter = 0 # loop through iterations approximating solution, storing values and # times used in this instance's meshes while self.current_time < self.end_time: # housekeeping variable step_counter += 1 # performs operations on instance variables self.forward_step(step_counter) self.solution = Solution(self.time_mesh, self.value_mesh, str(self))
def __init__(self, ivp, end_time): """ Initialising instance variables """ # simple setting of input values self.ivp = ivp self.current_time = self.ivp.initial_time self.end_time = end_time # produces empty time and value meshes self.time_mesh = self.build_time_mesh() self.value_mesh = self.build_value_mesh(self.ivp.get_dimension()) # creates empty solution object for print method self.solution = Solution(self.time_mesh, self.value_mesh, str(self))
def __init__(self, parameters: Parameters, test_list: List[Solution] = None): # Population posiada pola: lista główna osobników tj. rozwiązań, tu trafia lista po inicjalizacji i po danym # etapie algorytmu, lista tymczasowa, uzywana w operatorach do przechowania potomków przed zmergowaniem z listą # główną (elitaryzm?), parametry algorytmu. if not test_list: self.main_list = [Solution(employee_number=len(parameters.skills_matrix), company_number=len(parameters.skills_matrix[0])) for i in range(parameters.population_count)] elif len(test_list) != parameters.population_count: raise MeasuresError else: self.main_list = test_list self.temporary_list = None self.parameters = parameters
def test_count_satisfaction_points(self): solution = Solution(temp_test_case, 10, 100) solution.answer = list(temp_test_case) solution.alphas = [1, 1, 1] Solution.count_satisfaction_points(solution) self.assertEqual(10, solution.satisfaction_points)
def test_population_init(self): rating1 = [1, 2, 3.5, 4, 5] # 5 firm skill1 = [[2, 2, 1, 3, 2], [1, 1, 1, 2, 1], [2, 3, 2, 1, 1]] # 3 pracowników emp_time1 = [1.8, 2, 0.7] comp_time1 = [1, 2, 2.5, 1.5, 0.8] params = Parameters(rating=rating1, skills_matrix=skill1, employee_time=emp_time1, company_time=comp_time1) current_population = Population(parameters=params) self.assertEqual(len(current_population.main_list), 10) custom_list = [ Solution(employee_number=len(params.skills_matrix), company_number=len(params.skills_matrix[0])) for i in range(5) ] with self.assertRaises(MeasuresError): Population(parameters=params, test_list=custom_list)
def create_random_population(self): """ creates random population with size equal to max_population_size """ start = tm.time() progress = tqdm(total=self.max_population_size, desc='Creating first random population') while len(self.population) < self.max_population_size: cars: List[Car] = [ Car(self.dataset.bonus) for _ in range(self.dataset.ncars) ] random_solution: Solution = Solution(cars, self.dataset.rides.copy()) random_solution.randomize_allocation() self.population.append(random_solution) progress.update(1) progress.set_postfix_str( 'Generated Chromosomes = {}, Time Elapsed = {:.2f} seconds'. format(len(self.population), tm.time() - start)) progress.close() progress.clear()
def greedy_solve(self) -> Solution: def manhattan_distance(v1, v2): return abs(v1[0] - v2[0]) + abs(v1[1] - v2[1]) solution = Solution([Car(self.bonus) for _ in range(self.ncars)], self.rides.copy()) step = 0 progress = tqdm(total=self.steps, desc='Building initial solution') while step < self.steps: for car in solution.cars: if car.step > step: continue ride_priority = [ sys.maxsize for _ in solution.unallocated_rides ] rides_available: bool = False for ride_id, ride in enumerate(solution.unallocated_rides): distance_to_car = manhattan_distance( car.position, ride.orig) if step + distance_to_car > self.steps: continue if step + distance_to_car + ride.distance > ride.latest_finish: continue earliest_start = ride.earliest_start - step ride_priority[ride_id] = abs(distance_to_car - earliest_start) rides_available = True if not rides_available: continue ride_id = None priority = sys.maxsize for ri, rp in enumerate(ride_priority): if rp < priority: ride_id = ri priority = rp ride = solution.unallocated_rides[int(ride_id)] distance_to_car = manhattan_distance(car.position, ride.orig) ride_start = max([step + distance_to_car, ride.earliest_start]) car.step = ride_start + ride.distance car.allocate_ride(ride) car.position = ride.dest solution.unallocated_rides.remove(ride) step += 1 progress.update(1) progress.close() return solution
def empty_solution(self) -> Solution: return Solution([Car(self.bonus) for _ in range(self.ncars)], self.rides.copy())
def test0(self): s0 = Solution(open("test_data/0.in")) result = s0.solve() self.assertEqual(result[0], "Case #1: 2 1") self.assertEqual(result[1], "Case #2: IMPOSSIBLE") self.assertEqual(result[2], "Case #3: 1 1")
def test_it_returns_the_closest_defibrilator(self): assert Solution(lines, StringToDecimal).getClosest( Algorithm).name() == "Maison de la Prevention Sante"
def test_it_creates_an_array_of_defibrilators(self): defibrilators = Solution(lines, StringToDecimal).defibrilators() assert len(defibrilators) == 3 for defibrilator in defibrilators: assert isinstance(defibrilator, Defibrilator)
def test1(self): s0 = Solution(open("test_data/1.in")) result = s0.solve() self.assertEqual(result[0], "Case #1: 1 25") self.assertEqual(result[1], "Case #2: 2 1")
def test_cannot_be_instanciate_without_a_StringFormator(self): with self.assertRaises(ValueError): Solution(lines, None)
def test_cannot_be_instanciate_without_lines(self): with self.assertRaises(ValueError): Solution(None, StringToDecimal)
def test2(self): s0 = Solution(open("test_data/2.in")) result = s0.solve() self.assertEqual(result[0], "Case #1: 8 29") self.assertEqual(result[1], "Case #2: 2 9") self.assertEqual(result[2], "Case #3: 83 100")
import pytest from src.solution import Solution s = Solution() def test_case0(): assert s.removeElement([3, 2, 2, 3], 3) == 2
def test0(self): s0 = Solution(open("test_data/0.in")) result = s0.solve() self.assertEqual(result[0], "Case #1: None")
import random import copy from src.solution import Solution n_courses = 3 table_sizes = [8, 7, 7] pop_size = 2500 greedy = True random.seed(1234) solutions = [ Solution([ np.split(np.random.permutation(np.arange(sum(table_sizes))), np.cumsum(table_sizes)[:-1]) for x in range(n_courses) ], n_courses, table_sizes) for y in range(pop_size) ] for i, solution in enumerate(solutions): if i % 100 == 0: print(str(i) + '/' + str(pop_size)) local_optimum = (solution.get_score() == 0) while not local_optimum: new_solution = solution.improve_solution(greedy) if new_solution is None: local_optimum = True else: solution = new_solution if new_solution.get_score() == 0: local_optimum = True