def test_graph_cracov_easy_path_next(self): stops_common = [ "Czerwone Maki", "Chmieleniec", "Kampus UJ", "Ruczaj", "Norymberska", "Grota", "Lipinskiego" ] nodes = {} for name in stops_common: nodes[name] = Node(name) def conn_nod(a, b, len): connect_both(nodes[a], nodes[b], len) nodes_list = [node for node in nodes.values()] for i in range(0, len(stops_common) - 1): conn_nod(stops_common[i], stops_common[i + 1], 5) graph = Graph(nodes_list) for stop in stops_common[1:]: self.assert_path_next_move(graph, "Czerwone Maki", stop, "Chmieleniec") for stop in stops_common[2:]: self.assert_path_next_move(graph, "Chmieleniec", stop, "Kampus UJ") for stop in stops_common[3:]: self.assert_path_next_move(graph, "Kampus UJ", stop, "Ruczaj") for stop in stops_common[:2]: self.assert_path_next_move(graph, "Kampus UJ", stop, "Chmieleniec") for stop in stops_common[4:]: self.assert_path_next_move(graph, "Ruczaj", stop, "Norymberska")
def test_has_node(): _graph = Graph() _node1 = Node(4) _node2 = Node(5) _graph.add_node(_node1) assert _graph.had_node(_node1) == True assert _graph.had_node(_node2) == False
def __init__(self, truck_id, package_limit, speed, start_of_day, hub_location): """ Create Truck Object :param truck_id: id of the truck :int :param package_limit: maximum number of packages truck can hold :int :param speed: speed of truck in miles per hour :int :param start_of_day: time of start of day :str :param hub_location: location of hub :Location :return: Truck Object Worst Case Runtime Complexity: O(1) Best Case Runtime Complexity: O(1) """ self._id = truck_id self._package_limit = package_limit self._speed = (speed / 60) / 60 # truck speed in miles per second self._locations = Graph() self._packages = [] self._start_of_day = start_of_day self._locations.add_vertex(hub_location.name, hub_location) self._route = Queue() self._departure_time = None # departure time in seconds since start self._distance_traveled = 0.0 self._current_location = None self._next_location = None self._route_done = False
def generate_sample_graph(is_directed=False): ''' Will return a graph obj as such, either undirected or directed based on the optional arg: undirected [A] -> {'B', 'C'} [B] -> {'A', 'D', 'E'} [C] -> {'A', 'F'} [D] -> {'B'} [E] -> {'B', 'F'} [F] -> {'E', 'C'} directed [A] -> {'C', 'B'} [B] -> {'E', 'D'} [C] -> {'F'} [E] -> {'F'} ''' graph = Graph(is_directed) graph.add_edge('A', 'B') graph.add_edge('A', 'C') graph.add_edge('B', 'D') graph.add_edge('B', 'E') graph.add_edge('C', 'F') graph.add_edge('E', 'F') return graph
def test_add_node(self): """ Tests that add_node properly adds nodes to adjecency list """ graph = Graph() expected_graph = {'a': {'b'}} graph.add_node('a', ['b']) self.assertDictEqual(expected_graph, graph._adjecents) expected_graph['a'].add('c') graph.add_node('a', 'c') self.assertDictEqual(expected_graph, graph._adjecents) expected_graph['b'] = set({'a', 'd', 'e'}) graph.add_node('b', ['a', 'd', 'e']) self.assertDictEqual(expected_graph, graph._adjecents) expected_graph['c'] = set('f') graph.add_node('c', 'f') self.assertDictEqual(expected_graph, graph._adjecents) expected_graph['d'] = set('b') graph.add_node('d', 'b') self.assertDictEqual(expected_graph, graph._adjecents) expected_graph['e'] = set({'b', 'f'}) graph.add_node('e', 'b') graph.add_node('e', 'f') self.assertDictEqual(expected_graph, graph._adjecents) expected_graph['f'] = set({'c', 'e'}) graph.add_node('f', 'c') graph.add_node('f', 'e') self.assertDictEqual(expected_graph, graph._adjecents)
def setUp(self) -> None: node1 = GraphNode(data=1) node2 = GraphNode(data=2) node3 = GraphNode(data=3) node4 = GraphNode(data=4) node5 = GraphNode(data=5) node6 = GraphNode(data=6) node7 = GraphNode(data=7) node8 = GraphNode(data=8) node9 = GraphNode(data=9) node10 = GraphNode(data=10) node11 = GraphNode(data=11) node12 = GraphNode(data=12) node13 = GraphNode(data=13) node14 = GraphNode(data=14) node15 = GraphNode(data=15) node1.add_child(node5) node2.add_children([node5, node9, node10]) node3.add_children([node2, node13, node4]) node4.add_children([node5, node6, node8]) node5.add_children([node3]) node6.add_child(node7) node9.add_child(node10) node10.add_child(node11) node11.add_child(node12) node13.add_child(node14) node14.add_child(node15) my_graph = Graph() my_graph.add_nodes([ node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, node13, node14, node15 ]) self.my_graph = my_graph
def test_get_edges(self): """ A - 1 - B - 2 - C - 1 - D | | 1 5 | | E - 1 - F """ nodes = {} for letter in "ABCDEF": nodes[letter] = Node(letter) def conn_nod(a, b, len): connect_both(nodes[a], nodes[b], len) conn_nod("A", "B", 1) conn_nod("A", "E", 1) conn_nod("E", "F", 1) conn_nod("F", "B", 5) conn_nod("B", "C", 2) conn_nod("D", "C", 1) graph = Graph([nodes[key] for key in nodes]) self.assertEqual(graph["A", "B"], 1) self.assertEqual(graph["A", "E"], 1) self.assertEqual(graph["E", "F"], 1) self.assertEqual(graph["F", "B"], 5) self.assertEqual(graph["B", "C"], 2) self.assertEqual(graph["D", "C"], 1)
def test_graph_cracov_easy_path_len(self): stops_common = [ "Czerwone Maki", "Chmieleniec", "Kampus UJ", "Ruczaj", "Norymberska", "Grota", "Lipinskiego" ] nodes = {} for name in stops_common: nodes[name] = Node(name) def conn_nod(a, b, len): connect_both(nodes[a], nodes[b], len) def ass_path_len(a, b, i): self.assert_path_len( graph, a, b, i, "between {0} and {1} should be {2}".format(a, b, i)) nodes_list = [node for node in nodes.values()] conn_nod(stops_common[0], stops_common[1], 5) conn_nod(stops_common[1], stops_common[2], 5) conn_nod(stops_common[2], stops_common[3], 5) conn_nod(stops_common[3], stops_common[4], 5) conn_nod(stops_common[4], stops_common[5], 5) conn_nod(stops_common[5], stops_common[6], 5) graph = Graph(nodes_list) q = 0 for i in range(0, len(stops_common)): for q in range(0, len(stops_common)): self.assert_path_len(graph, stops_common[i], stops_common[q], abs(i - q) * 5)
def graph(): letters = Graph() a = letters.add_node("a") b = letters.add_node("b") c = letters.add_node("c") d = letters.add_node("d") e = letters.add_node("e") f = letters.add_node("f") g = letters.add_node("g") h = letters.add_node("h") letters.add_edge(a, b) letters.add_edge(b, c) letters.add_edge(c, g) letters.add_edge(a, d) letters.add_edge(d, e) letters.add_edge(d, h) letters.add_edge(d, f) letters.add_edge(h, f) return letters
def graph(): realms = Graph() pandora = realms.add_node("Pandora") arendelle = realms.add_node("Arendelle") metroville = realms.add_node("Metroville") monstropolis = realms.add_node("Monstropolis") narnia = realms.add_node("Narnia") naboo = realms.add_node("Naboo") realms.add_edge(pandora, arendelle) realms.add_edge(arendelle, pandora) realms.add_edge(arendelle, metroville) realms.add_edge(arendelle, monstropolis) realms.add_edge(metroville, arendelle) realms.add_edge(metroville, monstropolis) realms.add_edge(metroville, narnia) realms.add_edge(monstropolis, arendelle) realms.add_edge(monstropolis, metroville) realms.add_edge(monstropolis, naboo) realms.add_edge(narnia, metroville) realms.add_edge(narnia, naboo) realms.add_edge(naboo, metroville) realms.add_edge(naboo, monstropolis) realms.add_edge(naboo, narnia) return realms
def test_add_undirected_edge(self): print('Test: test_add_undirected_edge') g = Graph() n, n1 = g.add_node(), g.add_node() g.add_undirected_edge(n, n1, 5) self.assertIn([n1, 5], n.neighbors) self.assertIn([n, 5], n1.neighbors) print('Success: test_add_undirected_edge')
def test_bouquet(): g = Graph() apple = g.add_node("apple") g.add_edge(apple, apple, 10) neighbors = g.get_neighbors(apple) assert len(neighbors) == 1 assert neighbors[0].vertex.value == "apple" assert neighbors[0].weight == 10
def test_size_empty(): graph = Graph() expected = 0 actual = graph.size() assert actual == expected
def test_add_edge(): g = Graph() apple = g.add_node("apple") banana = g.add_node("banana") g.add_edge(apple, banana, 5) neighbors = g.get_neighbors(apple) assert len(neighbors) == 1 assert neighbors[0].vertex.value == "banana" assert neighbors[0].weight == 5
def test_add_node(): graph = Graph() expected = "spam" # a vertex's value that comes back actual = graph.add_node("spam").value assert actual == expected
def generate_graph(voro, width, height): line_list = sort_lines(voro, width, height) g = Graph.Graph() for line in line_list: g.add_vertex(line[0]) g.add_vertex(line[1]) g.add_edge(line[0], line[1], line_tools.calc_length(line)) return g
def generate_sample_friend_network(): graph = Graph() graph.add_edge('Alex', 'Bob') graph.add_edge('Bob', 'Dan') graph.add_edge('Bob', 'Charlie') graph.add_edge('Charlie', 'Elsa') graph.add_edge('Elsa', 'Genna') return graph
def knight_graph(board_size): kt_graph = Graph() for row in range(board_size): for col in range(board_size): node_id = pos_to_node_id(row, col, board_size) new_positions = gen_legal_moves(row, col, board_size) for e in new_positions: n_id = pos_to_node_id(e[0], e[1], board_size) kt_graph.add_edge(node_id, n_id) return kt_graph
def test_add_edge_interloper_end(): graph = Graph() end = Vertex("end") start = graph.add_node("start") with pytest.raises(KeyError): graph.add_edge(start, end)
def test_size(): graph = Graph() graph.add_node("spam") expected = 1 actual = graph.size() assert actual == expected
def test_add_node(self): print('Test: test_add_node') print('Test: keys are numbers') g = Graph() g.add_node() self.assertEqual(len(g._nodes), 1) self.assertEqual(g._counter, 1) print('Test: keys are chars') g = Graph(letters=True) g.add_node() self.assertEqual(len(g._nodes), 1) self.assertEqual(g._counter, 98) print('Test: keys are chars (not enough keys)') for i in range(98, 123): g.add_node() self.assertRaises(NotEnoughKeys, g.add_node) print('Success: test_add_node')
def shortest_reach(n, edges, s): graph = Graph(False) for vertex in range(1, n + 1): graph.add_vertex(vertex) for begin, end, weight in edges: graph.add_edge(begin, end, weight) shortest_paths = graph.dijkstra_shortest_path(s) return [ value.distance if value.distance != inf else -1 for key, value in sorted(shortest_paths.items()) if key != s ]
def steiner_tree(graph): leaf_nodes = graph.find_non_terminal_leaves() # Get a copy of the graph edges # we are going to delete edges from this dictionary (by setting their value to an empty list) new_edges = graph.edges.copy() # Same with the nodes new_nodes = graph.nodes.copy() # For all non-terminal leaves in the MST for leaf in leaf_nodes: node_num = leaf[0] edge_num = list(leaf[1].values())[0] leaf_edge = graph.edges[edge_num] # Second node connected to the edge second_node = leaf_edge[0] if leaf_edge[ 1] == node_num else leaf_edge[1] # Setting the value of the chosen edge and node to [] (as if we have deleted it) new_edges[edge_num] = [] new_nodes[node_num] = [] # Update the second node's degree and edges dictionary graph.nodes[second_node][0] -= 1 graph.nodes[second_node][1].pop(node_num) # Checking if the remaining node is a leaf and not a terminal while graph.nodes[second_node][2] == 0 and graph.nodes[ second_node][0] == 1: node_num = second_node node_edges = graph.nodes[second_node][1] edge_num = list(node_edges.values())[0] leaf_edge = graph.edges[edge_num] second_node = leaf_edge[0] if leaf_edge[ 1] == node_num else leaf_edge[1] new_edges[edge_num] = [] new_nodes[node_num] = [] graph.nodes[second_node][0] -= 1 graph.nodes[second_node][1].pop(node_num) # Making new dictionaries of the updated nodes and edges to make a graph from them new_graph_nodes = {k: v[2] for k, v in new_nodes.items() if v != []} edge_number = 1 new_graph_edges = {} for k, v in new_edges.items(): if v: new_graph_edges[edge_number] = v edge_number += 1 steiner_tree = Graph(len(new_graph_nodes), len(new_graph_edges), new_graph_nodes, new_graph_edges) return steiner_tree, steiner_tree.graph_weight()
def test_remove_node(self): print('Test: test_remove_node') g = Graph() print('Test: remove a non-existent node') self.assertRaises(ValueError, g.remove_node, 0) print('Test: general case') n = g.add_node() self.assertEqual(len(g._nodes), 1) g.remove_node(n.key) self.assertEqual(len(g._nodes), 0) print('Success: test_remove_node')
def generate_graph(screen_width, screen_height, num_of_vertices): points = generate_points.generate_points(screen_width, screen_height, num_of_vertices) g = Graph.Graph() for x in points: for y in points: if x != y: g.add_vertex(x) g.add_vertex(y) g.add_edge(x, y, line_tools.calc_length((x, y))) return g
def make_graph(make_nodes): nodes = make_nodes g = Graph(nodes) g.add_edges(nodes[0], nodes[1], 1) g.add_edges(nodes[0], nodes[6], 1) g.add_edges(nodes[0], nodes[7], 1) g.add_edges(nodes[1], nodes[2], 1) g.add_edges(nodes[1], nodes[5], 1) g.add_edges(nodes[2], nodes[3], 1) g.add_edges(nodes[2], nodes[4], 1) g.add_edges(nodes[7], nodes[8], 1) g.add_edges(nodes[8], nodes[9], 1) return g
def test_neighbours(): _graph = Graph() _node1 = Node(4) _node2 = Node(5) _node3 = Node(6) _node4 = Node(7) _graph.add_edges(_node1, _node2, 1) _graph.add_edges(_node3, _node4, 1) _graph.add_edges(_node2, _node4, 1) _graph.add_edges(_node1, _node2, 2) _graph.add_edges(_node3, _node4, 2) _graph.add_edges(_node2, _node4, 2) assert _graph.neighbours(_node2) == ['n0', 'n3']
def make_weighted_graph(make_nodes): nodes = make_nodes[:6] g = Graph(nodes) g.add_edges(nodes[0], nodes[1], 7) g.add_edges(nodes[0], nodes[2], 9) g.add_edges(nodes[0], nodes[5], 14) g.add_edges(nodes[1], nodes[2], 10) g.add_edges(nodes[1], nodes[3], 15) g.add_edges(nodes[2], nodes[3], 11) g.add_edges(nodes[2], nodes[5], 2) g.add_edges(nodes[3], nodes[4], 6) g.add_edges(nodes[4], nodes[5], 9) return g
def test_adjacent(): _graph = Graph() _node1 = Node(4) _node2 = Node(5) _node3 = Node(6) _node4 = Node(7) _graph.add_edges(_node1, _node2, 1) _graph.add_edges(_node3, _node4, 1) _graph.add_edges(_node2, _node4, 1) assert _graph.adjacent(_node1, _node2) == True assert _graph.adjacent(_node3, _node4) == True assert _graph.adjacent(_node2, _node4) == True assert _graph.adjacent(_node1, _node4) == False
def test_steiner_tree_algorithm_on_stp_file(path): comment, graph, terminals = FileHandler.read_stp_file(path) graph_nodes = {k: 0 for k in range(1, graph['Nodes'] + 1)} terminal_nodes = [ terminals[k] for k in range(1, terminals['Terminals'] + 1) ] for terminal in terminal_nodes: graph_nodes[terminal] = 1 graph = Graph(graph['Nodes'], graph['Edges'], graph_nodes, {k: graph[k] for k in range(1, graph['Edges'] + 1)}) mst = Kruskal.kruskal_algorithm(graph) steiner_tree = SteinerTreeBasedOnKruskal.steiner_tree(mst[0]) return steiner_tree[0], steiner_tree[1]