def test_snk_mirror_solver(): circle = create_circle_n_k(9, 3) solver = SnkMirrorSolver() sol = solver.solve(circle) circle = create_circle_n_k(12, 3) sol1 = solver.solve(circle) circle = create_circle_n_k(14, 4) sol2 = solver.solve(circle) circle = create_circle_n_k(20, 5) sol3 = solver.solve(circle) print("\\o/")
def vis_full_circle_solutions(): from instance_generation import create_circle_n_k graphs = [create_circle_n_k(n, n) for n in range(4, 9)] from solver.cp import ConstraintDependencySolver, ConstraintDependencyLocalMinSumSolver from solver.mip import AngularDependencySolver, AngularDependencyLocalMinSumSolver sols_MSSC = [] sols_MLSSC = [] import pickle try: with open("Circle_sols.pk", "rb") as f: sols_MSSC, sols_MLSSC = pickle.load(f) except (EOFError, FileNotFoundError): solver_MSSC = AngularDependencySolver() solver_MLSSC = AngularDependencyLocalMinSumSolver() for g in tqdm.tqdm(graphs): sols_MSSC.append(solver_MSSC.solve(g)) sols_MLSSC.append(solver_MLSSC.solve(g)) with open("Circle_sols.pk", "wb") as f: pickle.dump((sols_MSSC, sols_MLSSC), f) from utils import visualize_min_sum_sol_2d print("Min Sum Sols:") for s in sols_MSSC: visualize_min_sum_sol_2d(s) return
def test_dependency_graph(): circle = create_circle_n_k(6, 2) solver = GraphN2Solver() sweep_types = [0, -1, 0, 0, 0, 1] directions = [-1, -1, 1, -1, 1, 1] orientations = [ PointSweep(direction, sweep_type, index) for direction, sweep_type, index in zip(directions, sweep_types, range(len(directions))) ] dep_graph = solver._calculate_dependecy_graph(circle, orientations) orig_dep_dict = { (0, 1): [(0, 2), (1, 5)], (0, 2): [(0, 4), (2, 4)], (1, 2): [(0, 2), (1, 3)], (1, 3): [(2, 3), (0, 1)], (2, 3): [], (2, 4): [(2, 3), (0, 4)], (3, 4): [(3, 5), (2, 4)], (3, 5): [(1, 3), (4, 5)], (4, 5): [(1, 5)], (0, 4): [(4, 5), (0, 5)], (0, 5): [], (1, 5): [(0, 5)] } orig_dep_graph = {edge: DependencyNode(edge) for edge in orig_dep_dict} for edge in orig_dep_dict: for dependency in orig_dep_dict[edge]: orig_dep_graph[edge].add_dependency(orig_dep_graph[dependency]) assert orig_dep_graph == dep_graph
def test_get_tripel_edges(): graph = create_circle_n_k(15, 5) tripel_control, abs_graph = convert_graph_to_angular_abstract_graph( graph, simple_graph=False, return_tripel_edges=True) tripel_edges = get_tripeledges_from_abs_graph(abs_graph) assert len(tripel_edges) == len(tripel_control) for edge in tripel_edges: assert tripel_control[edge] == tripel_edges[edge]
def test_calc_times_old_new(): graph = create_circle_n_k(15, 10) order = [(i, j) for i in range(graph.vert_amount) for j in range(i + 1, graph.vert_amount)] old_times = _calculate_times_old(order, graph) new_times = calculate_times(order, graph) for old, new in zip(old_times, new_times): assert old == new assert math.isclose(old_times[old], new_times[new])
def create_graph(): d1 = get_distance(9, 3) d2 = get_distance(9, 2) d = d1 + np.random.default_rng().random() * (d2 - d1) body = CelestialBody((0, 0), d, None) g = create_circle_n_k(9, 4) graph = CelestialGraph([body], g.vertices, g.edges) visualize_graph_2d(graph) for i in range(10): rand_g = create_random_celest_graph(9, celest_bounds=(0.4, 0.6)) visualize_graph_2d(rand_g)
def test_generate_possible_sweeps(): circle = create_circle_n_k(6, 2) solver = GraphN2Solver() possibilities = solver._generate_possible_start_ends(circle, 2) sweep = solver._calculate_orientations(circle, possibilities[0]) sweep_types = [-1, -1, 0, 0, 0, 0] directions = [1, 1, -1, 1, -1, 1] for sweep_point, sweep_type, direction in zip(sweep, sweep_types, directions): assert sweep_point.direction == direction assert sweep_point.type == sweep_type
def test_get_order_from_times(): graph = create_circle_n_k(15, 10) order = [(i, j) for i in range(graph.vert_amount) for j in range(i + 1, graph.vert_amount)] times = calculate_times(order, graph) new_order = calculate_order_from_times(times, graph) # As both orders could actually differ without changing a thing, # we instead test if we get the same times again new_times = calculate_times(new_order, graph) for key in new_times: assert math.isclose(times[key], new_times[key])
def test_order(): circle = create_circle_n_k(6, 2) solver = GraphN2Solver() sweep_types = [0, -1, 0, 0, 0, 1] directions = [-1, -1, 1, -1, 1, 1] orientations = [ PointSweep(direction, sweep_type, index) for direction, sweep_type, index in zip(directions, sweep_types, range(len(directions))) ] dep_graph = solver._calculate_dependecy_graph(circle, orientations) order = solver._calculate_order(dep_graph)
def create_graph(): d1 = get_distance(9,3) d2 = get_distance(9,2) d = d1 + np.random.default_rng().random() * (d2-d1) body = CelestialBody((0,0), d, None) g = create_circle_n_k(9,4) graph = CelestialGraph([body], g.vertices, g.edges) visualize_graph_2d(graph) for i in range(10): for j in range(3): rand_c = create_random_celest_graph(9+i,celest_bounds=(0.4,0.6)) rand_g = create_random_instance(9+i, edge_chance=random.uniform(0.3, 1)) visualize_graph_2d(rand_g, savePath=f"instance_vis/rand_e{9+i}_{j}.pdf") visualize_graph_2d(rand_c, savePath=f"instance_vis/cel_e{9+i}_{j}.pdf")
def solution_example_intro(): solver1 = ALL_SOLVER["ConstraintAbsSolver"]() solver2 = ALL_SOLVER["ConstraintDependencySolver"]() solver3 = ALL_SOLVER["ConstraintDependencyLocalMinSumSolver"]() s52 = create_circle_n_k(5, 2) visualize_graph_2d(s52) sol1 = solver1.solve(s52) sol2 = solver2.solve(s52) sol3 = solver3.solve(s52) visualize_solution_2d(sol1) visualize_min_sum_sol_2d(sol1) print("makespan", sol1.makespan) visualize_solution_2d(sol2) visualize_min_sum_sol_2d(sol2) print("MinSum", sol2.min_sum) visualize_solution_2d(sol3) visualize_min_sum_sol_2d(sol3) print("LocalMinSum", sol2.local_min_sum) return
def _test_dep_mip_with_subtours(): from solver.mip import AngularDependencySolver from instance_generation import create_circle_n_k solver_w = AngularDependencySolver(with_vertex_subtour_constr=True) solver_o = AngularDependencySolver() for n in range(5, 10): g = create_circle_n_k(n, 3) print("#########################################################") print("################ SOLVER WITH SUBTOURS ###################") print("#########################################################") s_w = solver_w.solve(g) print("#########################################################") print("################ SOLVER WITHOUT SUBTOURS ################") print("#########################################################") s_o = solver_o.solve(g) print("#########################################################") print("################ RUNTIME WITH:",s_w.runtime,"WITHOUT:", s_o.runtime,"###################") print("#########################################################") if s_w.is_optimal and s_o.is_optimal: assert math.isclose(s_w.min_sum, s_o.min_sum)
def test_solver(): circles = [create_circle_n_k(n, 2) for n in range(7, 35)] solver = GraphN2Solver() sols = [solver.solve(circle) for circle in circles] for sol in sols: assert sol, "Did not find a solution for a graph"