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 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"))))
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 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 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 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 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 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 extract_nodes(edges): node_ids = set() for edge in edges: node_ids.add(edge['source']) node_ids.add(edge['target']) nodes = [] for node_id in node_ids: node = Node(node_id) node.in_degree = count_in_degree(edges, node_id) node.out_degree = count_out_degree(edges, node_id) nodes.append(node) return nodes
def add_node(self, node_id: int, pos: tuple = None): if self.__Nodes.get(node_id) is None: node = Node(node_id) node.setPos(pos) self.__Nodes.update({node_id: node}) self.__Edges.update({node_id: {}}) self.__allInEdges.update({node_id: {}}) self.__nodeSize += 1 self.__mc += 1 if node_id + 1 > self.__maxKey: self.__maxKey = node_id + 1 return True return False
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 bfs(self, node: Node, out: bool) -> list: """ BFS algorithm Helper algorithm for the SCC algorithm. :param node: - a node to start BFS searching from. :param out: - determines how to search: out - search all out edges of node, in - search al in edges of node. :return: - a list representing all visited nodes. """ for n in self.g.get_all_v().values(): # Set all nodes as unvisited. n.temp_color = "WHITE" visited = [] queue = [] node.temp_color = "GRAY" visited.append(node.key) queue.append(node.key) if out: while queue: v = queue.pop(0) for neighbor in self.g.all_out_edges_of_node(v).keys(): if self.g.get_all_v()[neighbor].temp_color == "WHITE": self.g.get_all_v()[neighbor].temp_color = "GRAY" visited.append(neighbor) queue.append(neighbor) else: while queue: v = queue.pop(0) for neighbor in self.g.all_in_edges_of_node(v).keys(): if self.g.get_all_v()[neighbor].temp_color == "WHITE": self.g.get_all_v()[neighbor].temp_color = "GRAY" visited.append(neighbor) queue.append(neighbor) return visited
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 split_edge(edge, node_to_layer_map, counter): source = edge['source'] target = edge['target'] nodes = [] node_ids = [source] for i in range(node_to_layer_map[source] + 1, node_to_layer_map[target]): counter += 1 node = Node(str(counter)) node.layer = i nodes.append(node) node_ids.append(node.id) node_ids.append(target) edges = make_edges(node_ids) return nodes, edges, counter
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_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 hasNext(self, node: Node) -> bool: edges = self.graph.all_out_edges_of_node(node.getId()) s = [] for i in edges: if (not self.graph.get_node(i).getStatus()): s.append(i) if (len(s) != 0): 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 _next_line_todo(self, n_from: Node) -> Line: tmp = [] attractiveness: float = 0 for line in n_from.lines: if self._touched[line.get_next_id(n_from.position)] == 0: attractiveness += line.attractiveness tmp.append(line) if len(tmp) == 0: return n_from.find_by_id(self._map.start.ident) tmp.sort()
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_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 _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 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 __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