def test_get_vertices_for_directed_graph(self): g = Graph(True) g.add_edge((1, 2)) actual = g.get_vertices() expected = [1, 2] self.assertEqual(actual, expected, 'should return all vertices')
def read_graph_from_file(file_name: str): try: with open(file_name) as graph_file: graph_temp = Graph() for line in graph_file.readlines(): lst = line.split() if len(lst) == 2: if graph_temp.is_vertex(lst[0]): graph_temp.start = lst[0] if graph_temp.is_vertex(lst[1]): graph_temp.end = lst[1] elif len(lst) == 3: vertex_1 = lst[0] vertex_2 = lst[1] edge_weight = int(lst[2]) if edge_weight > 0: graph_temp.add_edge(vertex_1.strip(), vertex_2.strip(), edge_weight) else: print("ERROR: Wrong file format.") return Graph() if graph_temp.start is None: graph_temp.start = graph_temp.vertices[list( graph_temp.vertices.keys())[0]] if graph_temp.end is None: graph_temp.end = graph_temp.vertices[list( graph_temp.vertices.keys())[-1]] return graph_temp except FileNotFoundError: print("ERROR: File ", file_name, " not found.") print("Current folder: " + str(Path.cwd())) return None
def test_set_edge_value_if_edge_exists(self): g = Graph(True) g.add_edge((1,2,10)) g.set_edge_value((1,2), 20) self.assertEqual(g.table[1][2], 20, 'should have updated the edge value')
def read_from_file(filename): """Read from a file located at `filename` and return the corresponding graph object.""" file = open(filename, "r") lines = file.readlines() file.close() # Check if it is a graph or digraph graph_or_digraph_str = lines[0].strip() if len(lines) > 0 else None if graph_or_digraph_str != "G" and graph_or_digraph_str != "D": raise Exception("File must start with G or D.") is_directed = graph_or_digraph_str == "D" g = Graph(is_directed) # Add all vertices for vertex_key in lines[1].strip("() \n").split(","): g.add_vertex(vertex_key) # Add all edges for line in lines[2:]: # Split components of edge new_edge = line.strip("() \n").split(",") if len(new_edge) < 2 or len(new_edge) > 3: raise Exception("Lines adding edges must include 2 or 3 values") # Get vertices vertex1, vertex2 = new_edge[:2] # Get weight if it exists weight = int(new_edge[2]) if len(new_edge) == 3 else None # Add edge(s) g.add_edge(vertex1, vertex2, weight) return g
def update_MST_4(G: Graph, T: Graph, e: Tuple[str, str], weight: int): """ Sig: Graph G(V, E), Graph T(V, E), edge e, int -> Pre: Post: Ex: TestCase 4 below """ (u, v) = e assert (e in G and e in T and weight > G.weight(u, v)) G.set_weight(u, v, weight) T.remove_edge(u, v) a_nodes = set() dfs(T, u, a_nodes) all_edges = G.edges min_edge = e for (l, m) in all_edges: # Variant: len(all_edges) - all_edges.index((l, m)) if (l in a_nodes and m not in a_nodes) or (m in a_nodes and l not in a_nodes): (u, v) = min_edge if G.weight(l, m) < G.weight(u, v): min_edge = (l, m) (u, v) = min_edge T.add_edge(u, v, G.weight(u, v))
def test_adjacent_in_directed_graphs(self): g = Graph(True) g.add_edge((1, 2)) self.assertTrue(g.adjacent(1, 2), 'should find them adjacent') self.assertFalse(g.adjacent(2, 1), 'the edge is pointing the other way')
class ReverseDelete(object): name = 'reversedelete' def __init__(self, save_all_edges=False): self.queue = PriorityQueue() self.graph = Graph() self.logging = False self.save_all_edges = save_all_edges self.all_edges = [] def set_logging(self, level): if level == 'debug': self.logging = True def add_edge(self, node1, node2, weight, n, n_nodes, n_edges): self.queue.put((-weight, (node1, node2))) if self.save_all_edges: self.all_edges.append((node1, node2, weight)) def init_from_file(self, f): self.graph.import_data(f, self.add_edge) def solve(self): res = [] while not self.queue.empty(): (weight, edge) = self.queue.get() self.graph.remove_edge(edge[0], edge[1]) if not self.graph.is_connected(): self.graph.add_edge(edge[0], edge[1], -weight) res.append((edge[0], edge[1], -weight)) continue return (self.graph.n_nodes, len(res), res)
def getAllSocialPaths(self, userID): """ Takes a user's userID as an argument Returns a dictionary containing every user in that user's extended network with the shortest friendship path between them. The key is the friend's ID and the value is the path. """ visited = {} # Note that this is a dictionary, not a set # !!!! IMPLEMENT ME newGraph = Graph() for user in self.users: newGraph.add_vertex(user) for user in self.friendships: for friend in self.friendships[user]: newGraph.add_edge(user, friend) for friend in self.users: socialPath = newGraph.bfs(userID, friend) if socialPath is not False: visited[friend] = socialPath return visited
def test_set_edge_value_if_edge_exists(self): g = Graph(True) g.add_edge((1, 2, 10)) g.set_edge_value((1, 2), 20) self.assertEqual(g.table[1][2], 20, 'should have updated the edge value')
def test_add_edge_node_does_node_exist(): graph = Graph() graph.add_edge(1, 2) expected = {} output = graph.graph assert output == expected
def test_breadth_first_search_complex(capsys): graph = Graph() graph.graph['A'] = set() graph.graph['B'] = set() graph.graph['C'] = set() graph.graph['D'] = set() graph.graph['E'] = set() graph.graph['F'] = set() graph.graph['G'] = set() graph.graph['H'] = set() graph.add_edge('A', 'B') graph.add_edge('A', 'C') graph.add_edge('A', 'D') graph.add_edge('B', 'E') graph.add_edge('C', 'F') graph.add_edge('C', 'G') graph.add_edge('D', 'G') graph.add_edge('E', 'H') graph.add_edge('F', 'H') graph.add_edge('G', 'H') graph.breadth_first_search('A') expected = "A B C D E F G H " output = capsys.readouterr().out assert output == expected
def test_get_vertices_for_directed_graph(self): g = Graph(True) g.add_edge((1,2)) actual = g.get_vertices() expected = [1,2] self.assertEqual(actual, expected, 'should return all vertices')
def test_set_edge_value_works_for_undirected_graphs(self): g = Graph(False) g.add_edge((1, 2, 10)) g.set_edge_value((1, 2), 30) self.assertEqual(g.table[1][2], 30, 'has updated the edge') self.assertEqual(g.table[2][1], 30, 'reverse edge was updated too')
def test_returns_array_of_vertices_for_graph_as_list(self): g = Graph() g.add_edge(1, 2, 1) g.add_edge(2, 3, 1) has_cycle, vertices = topological_sort(g) self.assertEqual(False, has_cycle) self.assertEqual([3, 2, 1], vertices)
def test_set_edge_value_works_for_undirected_graphs(self): g = Graph(False) g.add_edge((1,2,10)) g.set_edge_value((1,2), 30) self.assertEqual(g.table[1][2], 30, 'has updated the edge') self.assertEqual(g.table[2][1], 30, 'reverse edge was updated too')
def test_get_edge_value_in_directed_graph(self): g = Graph(True) g.add_edge((1,2,3)) self.assertEqual(g.get_edge_value((1,2)), 3, 'should have stored value') self.assertIsNone(g.get_edge_value((2,1)), 'should have no value for reverse edge')
def test_set_edge_value_if_graph_is_directed_and_inverse_edge_exists(self): g = Graph(True) g.add_edge((1, 2, 10)) g.add_edge((2, 1, 20)) g.set_edge_value((1, 2), 30) self.assertEqual(g.table[1][2], 30, 'has updated the edge') self.assertEqual(g.table[2][1], 20, 'reverse edge remained the same')
def test_returns_array_of_vertices_for_graph_with_dependent_vertices(self): g = Graph() g.add_edge(1, 2, 1) g.add_edge(4, 1, 1) g.add_edge(3, 1, 1) has_cycle, vertices = topological_sort(g) self.assertEqual(False, has_cycle) self.assertEqual(any_of([2, 1, 4, 3], [2, 1, 3, 4]), vertices)
def test_get_edge_value_in_directed_graph(self): g = Graph(True) g.add_edge((1, 2, 3)) self.assertEqual(g.get_edge_value((1, 2)), 3, 'should have stored value') self.assertIsNone(g.get_edge_value((2, 1)), 'should have no value for reverse edge')
def test_incident_in_directed_graph(self): g = Graph(directed=True) g.add_edge((2, 1)) g.add_edge((3, 1)) actual = g.incident(1) expected = [2, 3] self.assertEqual(actual, expected, '1 has two incident vertexes')
def test_add_edge_node_to_itself(): graph = Graph() graph.graph["node_1"] = set() graph.add_edge("node_1", "node_1") expected = {"node_1": {"node_1"}} output = graph.graph assert output == expected
def test_set_edge_value_if_graph_is_directed_and_inverse_edge_exists(self): g = Graph(True) g.add_edge((1,2,10)) g.add_edge((2,1,20)) g.set_edge_value((1,2), 30) self.assertEqual(g.table[1][2], 30, 'has updated the edge') self.assertEqual(g.table[2][1], 20, 'reverse edge remained the same')
def dfs_residual(G: Graph, R: Graph, node: str, nodes: Set[str]): nodes.add(node) for neighbor in G.neighbors(node): capacity = G.capacity(node, neighbor) flow = G.flow(node, neighbor) R.add_edge(neighbor, node, capacity=flow, flow=0) if neighbor not in nodes: dfs_residual(G, R, neighbor, nodes)
def test_add_edge(self): graph = Graph() graph.add_vertex("A") graph.add_vertex("B") graph.add_edge("A", "B", 40) self.assertDictEqual(graph.vertices["A"].neighbours, {"B": {'weight': 40, 'pheromone': 1.0}}) self.assertDictEqual(graph.vertices["B"].neighbours, {"A": {'weight': 40, 'pheromone': 1.0}}) self.assertRaises(ValueError, graph.add_edge, "A", "B", -40)
def test_incident_in_directed_graph(self): g = Graph(directed = True) g.add_edge((2,1)) g.add_edge((3,1)) actual = g.incident(1) expected = [2, 3] self.assertEqual(actual, expected, '1 has two incident vertexes')
def test_egress(self): g = Graph(False) g.add_edge((1, 2, 10)) g.add_edge((1, 3, 11)) g.add_edge((2, 3, 12)) actual = g.egress(1) expected = [(1, 2, 10), (1, 3, 11)] self.assertEqual(actual, expected, 'should return ingress edges')
def test_add_edge_multiple_times_nothing_happens(self): g = Graph(True) g.add_edge((1, 2, 3)) g.add_edge((1, 2, 3)) g.add_edge((1, 2, 3)) g.add_edge((1, 2, 3)) self.assertIn(1, g.table, 'should have stored the tail in table') self.assertIn(2, g.table[1], 'should have stored the head in table')
def test_get_weight(self): """ Test getting the weight of an edge between two nodes. """ g = Graph() g.add_node("A") g.add_node("B") g.add_edge("A", "B", 123.45) self.assertEqual(g.get_weight("A", "B"), 123.45)
def test_returns_none_for_graph_with_cycle(self): g = Graph() g.add_edge(1, 2, 1) g.add_edge(4, 1, 1) g.add_edge(3, 1, 1) g.add_edge(2, 3, 1) has_cycle, vertices = topological_sort(g) self.assertEqual(True, has_cycle) self.assertIsNone(vertices)
def union(graph1: Graph, graph2: Graph): caminoUnionG1G2 = Graph(multi_graph=True) for i in graph1.get_edges(): caminoUnionG1G2.add_edge(i[0], i[1]) for e in graph2.get_edges(): caminoUnionG1G2.add_edge(e[0], e[1]) return caminoUnionG1G2
def test_add_edge_multiple_times_nothing_happens(self): g = Graph(True) g.add_edge((1,2,3)) g.add_edge((1,2,3)) g.add_edge((1,2,3)) g.add_edge((1,2,3)) self.assertIn(1, g.table, 'should have stored the tail in table') self.assertIn(2, g.table[1], 'should have stored the head in table')
def getAllSocialPaths(self, userID): """ Takes a user's userID as an argument Returns a dictionary containing every user in that user's extended network with the shortest friendship path between them. The key is the friend's ID and the value is the path. """ visited = {} # Note that this is a dictionary, not a set # !!!! IMPLEMENT ME # With the Graph class # runtime: 1.9708278179168701 seconds 100 users, 20 average # runtime: 24.768869876861572 seconds 200 users, 20 average # runtime: 24.120848417282104 seconds # runtime: 24.88981318473816 seconds g = Graph() for user in self.users: g.add_vertex(user) for user in self.friendships: for friend in self.friendships[user]: g.add_edge(user, friend) for friend in self.users: path = g.bfs(userID, friend) if path is not False: visited[friend] = path # Without the Graph class but have Queue # runtime: 1.8722269535064697 seconds # runtime: 27.13098406791687 seconds # runtime: 26.577613592147827 seconds # runtime: 26.608980178833008 seconds # for friend in self.users: # q = Queue() # visit = set() # path = [] # q.enqueue([userID]) # while len(q.storage) > 0: # node = q.dequeue() # path = node # vnode = node[-1] # if vnode == friend: # visited[friend] = path # pass # visit.add(vnode) # for child in self.friendships[vnode]: # if child not in visit: # dup_node = node[:] # dup_node.append(child) # q.enqueue(dup_node) return visited
def test_remove_edge_in_directed_graph(self): g = Graph(True) g.add_edge((1,2,10)) g.add_edge((2,3,11)) g.add_edge((3,1,12)) g.remove_edge((2,3)) self.assertEqual(g.table[1][2], 10, 'should have kept the edge') self.assertEqual(g.table[3][1], 12, 'should have kept the edge') self.assertEqual(g.table[2], {}, 'should have removed the edge')
def test_get_vertices_for_undirected_graph(self): g = Graph(False) g.add_edge((1, 2)) g.add_edge((2, 3)) g.add_edge((3, 1)) actual = g.get_edges() expected = [(1, 2, True), (1, 3, True), (2, 3, True)] self.assertEqual(actual, expected, 'should return only one way edges')
def test_add_edge_default(self): """ Test adding an edge to the graph. """ correct = "{'A': {'B': 0.0}, 'B': {}}" g = Graph() g.add_node("A") g.add_node("B") g.add_edge("A", "B") self.assertEqual(str(g), correct)
def test_add_edge_with_value(self): """ Test adding an edge to the graph. """ correct = "{'A': {'B': 22.22}, 'B': {}}" g = Graph() g.add_node("A") g.add_node("B") g.add_edge("A", "B", 22.22) self.assertEqual(str(g), correct)
def test_add_edge_invalid_end(self): """ Test adding an edge where the end node does not exist. """ g = Graph() g.add_node("A") g.add_node("B") with self.assertRaises(ValueError) as context: g.add_edge("A", "C") self.assertIn("end", str(context.exception))
def test_add_edge_for_directed_graph(self): g = Graph(True) g.add_edge((1,2,3)) self.assertIn(1, g.table, 'should have stored a key for tail vertex') self.assertIn(2, g.table[1], 'should have stored the edge') self.assertEqual(g.table[1][2], 3, 'should have stored the edge value') self.assertIn(2, g.table, 'should not have stored the node') self.assertNotIn(1, g.table[2], 'should not have stored the reverse edge')
def test_remove_edge_in_directed_graph(self): g = Graph(True) g.add_edge((1, 2, 10)) g.add_edge((2, 3, 11)) g.add_edge((3, 1, 12)) g.remove_edge((2, 3)) self.assertEqual(g.table[1][2], 10, 'should have kept the edge') self.assertEqual(g.table[3][1], 12, 'should have kept the edge') self.assertEqual(g.table[2], {}, 'should have removed the edge')
def constructor(M, sigma, kind='log'): g = Graph() for i in range(len(M)): for j in range(len(M[i])): for p in range(len(M)): for q in range(len(M[i])): if p != i or q != j: g.add_edge(get_name(i, j), get_name(p, q), weight(M, [i, j], [p, q], kind, sigma)) g.normalize() return g
def test_get_vertices_for_undirected_graph(self): g = Graph(False) g.add_edge((1,2)) g.add_edge((2,3)) g.add_edge((3,1)) actual = g.get_edges() expected = [(1,2,True), (1,3,True), (2,3,True)] self.assertEqual(actual, expected, 'should return only one way edges')
def union_graphs(graph1: Graph, graph2: Graph): multi_graph = Graph(multi_graph=True) for e in graph1.get_edges(): multi_graph.add_edge(e[0], e[1]) for e in graph2.get_edges(): multi_graph.add_edge(e[0], e[1]) return multi_graph
def test_add_edge_for_undirected_graph(self): g = Graph(False) g.add_edge((1,2,3)) self.assertIn(1, g.table, 'should have stored a key for tail vertex') self.assertIn(2, g.table[1], 'should have stored the edge') self.assertEqual(g.table[1][2], 3, 'should have stored the edge value') self.assertIn(2, g.table, 'should have stored a key for head vertex') self.assertIn(1, g.table[2], 'should have stored the reversed edge') self.assertEqual(g.table[2][1], 3, 'should have stored the edge value')
def test_remove_vertex(self): g = Graph(False) g.add_edge((1,2)) g.add_edge((2,3)) g.add_edge((3,1)) g.remove_vertex(3) self.assertTrue(g.table[1][2], 'should keep edges not involving 3') self.assertTrue(g.table[2][1], 'should keep edges not involving 3') self.assertNotIn(3, g.table, 'vertex 3 disappeared') self.assertNotIn(3, g.table[1], 'edge from 3 to 1 dissappeared')
def test_neighbours_in_directed_graph(self): g = Graph(True) g.add_edge((1,2)) g.add_edge((1,3)) expected = [2, 3] actual = g.neighbours(1) self.assertEqual(actual, expected, 'should find neighbours of 1') expected = [] actual = g.neighbours(2) self.assertEqual(actual, expected, '2 has no neighbours')
def test_remove_edge_in_undirected_graph(self): g = Graph(False) g.add_edge((1,2,10)) g.add_edge((2,3,11)) g.add_edge((3,1,12)) g.remove_edge((2,3)) self.assertEqual(g.table[1][2], 10, 'no removals') self.assertEqual(g.table[1][3], 12, 'no removals') self.assertEqual(g.table[2][1], 10, 'removed the edge from tail') self.assertEqual(g.table[3][1], 12, 'removed the edge from head')
def test_rename_vertex(self): g = Graph(True) g.add_edge((1,2)) g.add_edge((2,3)) g.add_edge((3,4)) g.add_edge((4,1)) g.rename_vertex(3,3.5) self.assertNotIn(3, g.table, 'removed vertex 3') self.assertNotIn(3, g.table[2], 'removed vertex (2,3)') self.assertIn(3.5, g.table, 'add vertex 3.5') self.assertIn(4, g.table[3.5], '3.5 tails to 4')
def test_incident_in_undirected_graph(self): g = Graph(directed = False) g.add_edge((2,1)) g.add_edge((3,1)) actual = g.incident(1) expected = [2, 3] self.assertEqual(actual, expected, '1 has two incident vertexes') incident = g.incident(1) neighbours = g.neighbours(1) self.assertEqual(incident, neighbours, 'should be the same for undirected graphs')
def test_clone(self): g1 = Graph(False) g1.add_edge((1,2,10)) g1.add_edge((2,3,20)) g1.add_edge((3,1,30)) g2 = g1.clone() g2.set_edge_value((1,2), 100) self.assertEqual(g1.get_edge_value((1,2)), 10, 'should not have modified the value of the edge in g1') g2.add_vertex((3,4,40)) self.assertFalse(g1.adjacent(3,4), 'g1 should not have vertex 4')
def test_rename_vertex_should_remove_self_edges(self): g = Graph(True) g.add_edge((1,2)) g.add_edge((2,3)) g.add_edge((3,4)) g.add_edge((4,1)) g.rename_vertex(2,1) self.assertTrue(g.table[1][3]) self.assertTrue(g.table[3][4]) self.assertTrue(g.table[4][1]) self.assertNotIn(2, g.table[1]) self.assertNotIn(2, g.table)
def test_incident_invariant_is_preserved_throughout_graph_operations(self): g = Graph(directed = True) g.add_vertex(1) self.assertEqual(g.incident(1), [], 'should have instantiated an empty set of ingress vertices') g.add_edge((2,1)) g.add_edge((2,1)) self.assertEqual(g.incident(1), [2], 'set of incident vertices is preserved') self.assertEqual(g.incident(2), [], 'no vertices incident in 2') g.remove_edge((2,1)) self.assertEqual(g.incident(1), [], '2 was removed from the list of incident vertices for 3')
def test_incident_vertices_are_correctly_maintained_after_remove_vertex(self): g = Graph(directed=True) g.add_edge((1,2)) g.add_edge((2,3)) g.add_edge((3,1)) # table: {1: {2: True}, 2: {3: True}, 3: {1: True}} # incident: {1: set([3]), 2: set([1]), 3: set([2])} g.remove_vertex(1) self.assertEqual(g.table, {2: {3: True}, 3: {}}) self.assertEqual(g.incident_vertices, {2: set(), 3: set([2])}) g = Graph(directed=False) g.add_edge((1,2)) g.add_edge((2,3)) g.add_edge((3,1)) # table: {1: {2: True, 3: True}, 2: {1: True, 3: True}, 3: {1: True, 2: True}} # incident: {1: set([2, 3]), 2: set([1, 3]), 3: set([1, 2])} g.remove_vertex(1) self.assertEqual(g.table, {2: {3: True}, 3: {2: True}}) self.assertEqual(g.incident_vertices, {2: set([3]), 3: set([2])})
def test_adjacent_in_directed_graphs(self): g = Graph(True) g.add_edge((1,2)) self.assertTrue(g.adjacent(1,2), 'should find them adjacent') self.assertFalse(g.adjacent(2,1), 'the edge is pointing the other way')
def test_adjacent_in_undirected_graphs(self): g = Graph(False) g.add_edge((1,2)) self.assertTrue(g.adjacent(1,2), 'should find them adjacent') self.assertTrue(g.adjacent(2,1), 'un-directed graph')
def test_add_edge_does_not_add_self_edges(self): g = Graph(True) g.add_edge((1,2)) g.add_edge((1,1)) self.assertNotIn(1, g.table[1], 'should not have added a self edge')