def test_reachable_nodes(self): self.assertEqual(1, len(self.g.reachable_nodes(Node("A")))) self.g.add_not_oriented_connections([["A", "B"], ["B", "C"], ["D", "E"]]) self.assertEqual(3, len(self.g.reachable_nodes(Node("A")))) self.assertEqual(2, len(self.g.reachable_nodes(Node("D")))) self.assertEqual(1, len(self.g.reachable_nodes(Node("F"))))
def test_get_degree(self): self.g.add_oriented_connections([["A", "B"], ["B", "C"], ["D", "E"]]) self.assertEqual(1, self.g.get_degree(Node("A"))) self.assertEqual(2, self.g.get_degree(Node("B"))) self.assertEqual(1, self.g.get_degree(Node("C"))) self.assertEqual(1, self.g.get_degree(Node("D"))) self.assertEqual(0, self.g.get_degree(Node("F")))
def build_graph_from_source(self): # Recieve all the string data from the file file_list = str(self.graph_file).split("\n") # Iterate over all parts of the file except for the last since that will be blank for line in file_list[0:-1]: # continue if there is a comment character in this line ignore it if "#" in line: continue # split the line into from and to nodes pair = line.split("\t") to_node = int(pair[0]) from_node = int(pair[1]) # make the nodes if they do not exist if to_node not in self.graph: self.graph[to_node] = Node() self.node_count += 1 if from_node not in self.graph: self.graph[from_node] = Node() self.node_count += 1 # add this edge self.graph[to_node].add(from_node) self.graph[from_node].add(to_node) self.edge_count += 1
def test_add_not_oriented_connection(self): self.g.add_not_oriented_connection(Node("A"), Node("B")) self.assertTrue(self.g.is_connection("A", "B")) self.assertTrue(self.g.is_connection("B", "A")) self.assertFalse(self.g.is_connection("A", "C")) with self.assertRaises(ValueError): self.g.add_not_oriented_connection(Node("A"), Node("Z"))
def hamiltonian_cycle_cheapest_insertion(points): first_node = Node(points[0], None) second_node = Node(points[1], None) first_node.next = second_node second_node.next = first_node points.remove(first_node.value) points.remove(second_node.value) last_added = second_node left_neighbour = first_node right_neighbour = first_node incert_infos = {} for point in points: incert_infos[point] = {"point": point, "price": float("inf"), "place": (first_node, second_node)} while len(incert_infos) > 0: incertion_price_recount(incert_infos, last_added, left_neighbour, right_neighbour) cheapest = get_cheapest_price(incert_infos) left_neighbour, right_neighbour = cheapest["place"] last_added = incert(left_neighbour, right_neighbour, cheapest["point"]) incert_infos.pop(cheapest["point"]) return linked_list_to_list(last_added)
class TestVectorMethods(unittest.TestCase): n1 = Node(0) n2 = Node(1) def test_constructor(self): vector = Vector((self.n1, self.n2), 0) self.assertEqual(vector.endpoints_nodes, (self.n1, self.n2), "failed constructor node set") self.assertEqual(vector.weight, 0, "failed constructor weight") def test_equal(self): v1 = Vector((self.n1, self.n2), 0) v2 = Vector((self.n1, self.n2), 0) self.assertEqual(v1, v2, "failed equality") def test_not_equal_weight(self): v1 = Vector((self.n1, self.n2), 0) v2 = Vector((self.n1, self.n2), 4) self.assertNotEqual(v1, v2, "failed weight not equal") def test_not_equal_direction(self): v1 = Vector((self.n1, self.n2), 0) v2 = Vector((self.n2, self.n1), 0) self.assertNotEqual(v1, v2, "failed direction not equal") def test_make_vector(self): v1 = Vector.make_vector(self.n1, self.n2, 0) v2 = Vector((self.n1, self.n2), 0) self.assertEqual(v1, v2)
def assert_nodes_parsed_correctly(): node0 = Node('0') node0.in_degree = 0 node0.out_degree = 2 node1 = Node('1') node1.in_degree = 1 node1.out_degree = 0 node2 = Node('2') node2.in_degree = 1 node2.out_degree = 0 expected_nodes = [node0, node1, node2] edges = [{'source': '0', 'target': '2'}, {'source': '0', 'target': '1'}] actual_nodes = extract_nodes(edges) actual_nodes.sort(key=lambda node: node.id) should_be_true = True for i in range(len(actual_nodes)): actual_node = actual_nodes[i] expected_node = expected_nodes[i] should_be_true = should_be_true \ and (expected_node.id == actual_node.id) \ and (expected_node.in_degree == actual_node.in_degree) \ and (expected_node.out_degree == actual_node.out_degree) return should_be_true
def test_get_node_with_highest_degree(self): self.g.add_oriented_connections([["A", "B"], ["B", "C"], ["F", "E"]]) self.assertEqual(Node("B"), self.g.get_node_with_highest_degree()) self.g.add_oriented_connections([["B", "A"], ["D", "E"]]) self.assertEqual(Node("B"), self.g.get_node_with_highest_degree()) self.g.add_oriented_connections([["D", "A"], ["A", "E"]]) self.assertEqual(Node("A"), self.g.get_node_with_highest_degree())
def testPrint(self): n1 = Node(1) n2 = Node(2) n3 = Node(3) n2.setStart(n1.getId(), 12) n2.setEnd(n3.getId(), 23) self.assertEqual(n2.__repr__(), "2: |edges out| 1 |edges in| 1")
def testGetId(self): n1 = Node(0) n2 = Node(0) self.assertEqual(n1.getId(), n2.getId()) self.assertEqual(n1.getId(), 0) n2 = Node(1) self.assertNotEqual(n1.getId(), n2.getId())
def testJson(self): n1 = Node(1) n2 = Node(2) n3 = Node(3) n2.setStart(n1.getId(), 12) n2.setEnd(n3.getId(), 23) self.assertEqual(n2.toJson(), {'id': 2})
def testConnections(self): n1 = Node(0) n2 = Node(1) self.assertEqual(n1.getStart(), n2.getStart()) n1.setEnd(n2, 1) n2.setStart(n1, 1) self.assertNotEqual(n1.getStart(), n2.getStart()) self.assertNotEqual(n1.getEnd(), n2.getEnd())
def full_expression(self, depth, terminals): if depth < self.max_depth: operator = randint(0, len(self.functions) - 1) return Node(self.functions[operator], self.full_expression(depth + 1, terminals), self.full_expression(depth + 1, terminals)) else: value = terminals.pop(randint(0, len(terminals) - 1)) self.node_values.append(value) return Node(value)
def testPos(self): n1 = Node(0) n2 = Node(0) self.assertEqual(n1.getPos(), n2.getPos()) n1.setPos((0, 0, 1)) self.assertNotEqual(n1.getPos(), n2.getPos()) n2.setPos((0, 0, 1)) self.assertEqual(n1.getPos(), n2.getPos()) n1.incPos(5) self.assertEqual(n1.getPos(), (0, 0, 50))
def test_get_node_with_lowest_value(self): a = Node("A", "B", 3) nodes = {a} self.assertEqual(a, self.g.get_node_with_lowest_value(nodes)) b = Node("B", "C", 2) nodes.add(b) self.assertEqual(b, self.g.get_node_with_lowest_value(nodes)) c = Node("C", None, 0) d = Node("D", None, None) nodes.add(c) nodes.add(d) self.assertEqual(c, self.g.get_node_with_lowest_value(nodes))
class TestVectorSetMethods(unittest.TestCase): # define useful testing nodes parent_node = Node(0) n1 = Node(1) n2 = Node(2) # define useful testing vectors vP1 = Vector((parent_node, n1)) vP2 = Vector((parent_node, n2)) v12 = Vector((n1, n2)) def test_len_0(self): vs = VectorSet(self.parent_node) self.assertEqual(len(vs), 0) def test_add(self): vs = VectorSet(self.parent_node) try: vs.add(self.vP1) except ValueError as ve: self.fail(ve.args) def test_add_repeat_vector(self): vs = VectorSet(self.parent_node) vs.add(self.vP1) self.assertEqual(vs.add(self.vP1), False) def test_len_same_after_failed_add(self): vs = VectorSet(self.parent_node) vs.add(self.vP1) length = len(vs) vs.add(self.vP1) self.assertEqual(len(vs), length) def test_remove_succeed(self): vs = VectorSet(self.parent_node) vs.add(self.vP1) self.assertEqual(vs.remove(self.vP1), True) def test_remove_failure(self): vs = VectorSet(self.parent_node) self.assertEqual(vs.remove(self.vP1), False) def test_in_true(self): vs = VectorSet(self.parent_node) vs.add(self.vP1) self.assertEqual(self.vP1 in vs, True) def test_in_false(self): vs = VectorSet(self.parent_node) self.assertEqual(self.vP1 in vs, False)
def start_search(self): if self.maze.create_maze( ): # Verifica se conseguiu ler o arquivo e criar a matriz do labirinto self.player = Player(self.maze.get_start( )) # Posiciona o jogador no inicio do labirinto self.root_node = Node(self.player.get_position(), None, 0, 0) # Cria o no raiz da árvore self.calculate_cost(self.root_node) self.opened_list.append( self.root_node) # Adiciona o nó raiz na lista de abertos success = False while len(self.opened_list) != 0: self.print_fluxograma() current_node = self.opened_list.pop( 0) # Pega o primeiro nó da lista de abertos self.player.set_position(current_node.get_position()) if not self.is_success( current_node): # Se não for sucesso, explora esse nó self.explore_node(current_node) else: success = True print("------------- Final ---------------") self.create_success_way(current_node) print("\n O custo real eh: {}".format( current_node.get_real_cost())) print("\n A arvore gerada eh: ") self.pprint_tree(self.root_node, "", True) print("\n O caminho no labirinto sera: \n") self.maze_solution() break if not success: print('Não encontrou solução') else: print('Não foi possível criar o labirinto')
def assert_dummy_vertices_get_correct_positions(): nodes = [Node('0'), Node('1')] nodes[0].layer = 1 nodes[0].pos_in_layer = 1 nodes[1].layer = 2 nodes[1].pos_in_layer = 2 dummy_vertices = [Node('2'), Node('3'), Node('4')] dummy_vertices[0].layer = 1 dummy_vertices[1].layer = 2 dummy_vertices[2].layer = 2 assign_positions_for_dummy_vertices(nodes, dummy_vertices) return dummy_vertices[0].pos_in_layer == 2 \ and dummy_vertices[1].pos_in_layer == 3\ and dummy_vertices[2].pos_in_layer == 4
def add_node(self, node_id: int, pos: tuple = None) -> bool: if node_id not in self.__graph.get('node') and node_id >= 0: self.__graph.get('node').update({node_id: Node(node_id, pos)}) self.__mc = self.__mc + 1 return True else: return False
def test_get_pos(self): id = 10 pos = (1, 2, 0) node = Node(id) node.setPos(pos) x, y, z = node.getPos() self.assertTrue(x == 1) self.assertTrue(y == 2)
def __init__(self, screen): self.screen = screen self.running = True self.tile = maptile() self.node = Node(10, 10, 15, 30) self.clock = pygame.time.Clock() self.main_loop() self.map_init()
def test_get_neighbors(self): self.g.add_not_oriented_connections([["A", "B"], ["B", "C"], ["D", "E"]]) self.assertEqual({Node("B")}, self.g.get_neighbors(Node("A"))) self.assertEqual({Node("A"), Node("C")}, self.g.get_neighbors(Node("B"))) self.assertEqual({Node("D")}, self.g.get_neighbors(Node("E")))
def test_remove_node(self): self.g.add_not_oriented_connections([[Node("A"), Node("B")], [Node("B"), Node("C")], [Node("D"), Node("E")]]) self.g.remove_node(Node("B")) self.assertEqual(5, len(self.g.nodes)) self.assertEqual(1, len(self.g.connections))
def add_node(self, node_id: int, pos: tuple = None) -> bool: if node_id not in self.nodedict: if pos is None: pos = (random.random() * 40, random.random() * 40, 0.0) n = Node(node_id, pos) self.nodedict[node_id] = n self.mc += 1 return True return False
def test_get_hamilton_path_nodes(self): self.g = Graph(["A", "B", "C", "D"]) connections = [["A", "B", 10], ["A", "C", 3], ["A", "D", 2], ["B", "C", 1], ["B", "D", 5], ["C", "D", 7]] self.g.add_not_oriented_valued_connections(connections) self.assertEqual(4, len(self.g.get_hamilton_path_nodes())) self.assertIn(self.g.get_hamilton_path_nodes(), [[Node("B"), Node("C"), Node("A"), Node("D")], [Node("A"), Node("D"), Node("C"), Node("B")]])
def test_get_leaving_edges_size(self): self.g.add_not_oriented_connections([["A", "B"], ["B", "C"], ["D", "E"]]) self.assertEqual(1, self.g.get_leaving_edges_size(Node("A"))) self.assertEqual(2, self.g.get_leaving_edges_size(Node("B"))) self.assertEqual(1, self.g.get_leaving_edges_size(Node("C"))) self.assertEqual(0, self.g.get_leaving_edges_size(Node("F"))) self.g.add_oriented_connections([["C", "A"]]) self.assertEqual(1, self.g.get_leaving_edges_size(Node("A"))) self.assertEqual(2, self.g.get_leaving_edges_size(Node("B"))) self.assertEqual(2, self.g.get_leaving_edges_size(Node("C"))) self.assertEqual(0, self.g.get_leaving_edges_size(Node("F")))
def _fill_nodes(self): nodes = {} pos = 1 dx = self.GlobalData.W / (self.GlobalData.nW - 1) dy = self.GlobalData.H / (self.GlobalData.nH - 1) for i in range(0, self.GlobalData.nW): for j in range(0, self.GlobalData.nH): nodes[pos] = Node(i * dx, j * dy, self.GlobalData.t0) pos += 1 return nodes
def test_get_num_of_unique_neigbors(self): self.g.add_not_oriented_connections([["A", "B"], ["B", "C"], ["D", "E"]]) self.assertEqual(1, self.g.get_num_of_unique_neigbors({Node("A")})) self.assertEqual(0, self.g.get_num_of_unique_neigbors({Node("F")})) self.assertEqual(2, self.g.get_num_of_unique_neigbors({Node("B")})) self.assertEqual( 2, self.g.get_num_of_unique_neigbors({Node("A"), Node("D")})) self.assertEqual( 2, self.g.get_num_of_unique_neigbors( {Node("A"), Node("B"), Node("D")}))
def _set_nodes(self, nodes: int): self._tmp = [[0 for _ in range(self._map.size[0])] for _ in range(self._map.size[1])] while len(self._map.nodes) != nodes: new_coordinate = Coordinate.random_coordinate( (SECURITY_ZONE, MAP_SIZE[0] - SECURITY_ZONE - 1), (SECURITY_ZONE, MAP_SIZE[1] - SECURITY_ZONE - 1)) if self._check_node_place(new_coordinate): self._map.nodes.append( Node(len(self._map.nodes), new_coordinate)) self._tmp[new_coordinate.y][new_coordinate.x] = 1
def __convert_to_graph(self, data, dimension, points=[]): nodes = [Node(i) for i in range(dimension)] for i, costs in enumerate(data): neighborhood = [] for j, cost in enumerate(costs): neighborhood.append(Neighbor(node=nodes[j], cost=cost)) nodes[i].neighborhood = neighborhood return nodes