def setUp(self): dag = DirectedGraph() dag.add_node(0) dag.add_node(1) dag.add_node(2) dag.add_node(3) dag.add_node(4) dag.add_node(5) dag.connect(0, 1) dag.connect(0, 2) dag.connect(0, 3) dag.connect(3, 4) dag.connect(4, 5) self.dag = dag cyclic = DirectedGraph() cyclic.add_node(0) cyclic.add_node(1) cyclic.add_node(2) cyclic.add_node(3) cyclic.add_node(4) cyclic.connect(0, 1) cyclic.connect(1, 2) cyclic.connect(1, 3) cyclic.connect(2, 3) cyclic.connect(2, 4) cyclic.connect(4, 0) self.cyclic = cyclic
def test_topological_sort(self): dg = DirectedGraph() dg.extend_vertexes("A", "B", "C", "D") dg.add_new_edge("A", "B") dg.add_new_edge("B", "C") dg.add_new_edge("C", "D") assert dg.topological_sort() == [vt("A"), vt("B"), vt("C"), vt("D")] dg = DirectedGraph("A", "B", "C") dg.add_new_edge("A", "B") dg.add_new_edge("B", "C") dg.add_new_edge("C", "A") with pytest.raises(RuntimeError, match="存在环"): dg.topological_sort() dg = DirectedGraph("A", "B", "C", "D") dg.add_new_edge("A", "B") dg.add_new_edge("A", "D") dg.add_new_edge("B", "C") dg.add_new_edge("D", "C") result = dg.topological_sort() assert result == [ vt("A"), vt("B"), vt("D"), vt("C") ] or result == [vt("A"), vt("D"), vt("B"), vt("C")]
def load_linqs_data(content_file, cites_file): ''' Create a DirectedGraph object and add Nodes and Edges This is specific to the data files provided at http://linqs.cs.umd.edu/projects/projects/lbc/index.html Return two items 1. graph object, 2. the list of domain labels (e.g., ['AI', 'IR']) ''' linqs_graph = DirectedGraph() domain_labels = [] id_obj_map = {} with open(content_file, 'r') as node_file: for line in node_file: line_info = line.split('\n')[0].split('\t') n = Node(line_info[0], map(float, line_info[1:-1]), line_info[-1]) # id, feature vector, label linqs_graph.add_node(n) if line_info[-1] not in domain_labels: domain_labels.append(line_info[-1]) id_obj_map[line_info[0]] = n with open(cites_file, 'r') as edge_file: for line in edge_file: line_info = line.split('\n')[0].split('\t') if line_info[0] in id_obj_map.keys( ) and line_info[1] in id_obj_map.keys(): from_node = id_obj_map[line_info[1]] to_node = id_obj_map[line_info[0]] linqs_graph.add_edge(Edge(from_node, to_node)) print "domain labels" print domain_labels return linqs_graph, domain_labels
def test_ford_fulkerson_multiple_sources_two_sources(): graph = DirectedGraph() graph.add_node('s') graph.add_node('s2') graph.add_node('a') graph.add_node('b') graph.add_node('c') graph.add_node('d') graph.add_node('t') graph.add_edge('s', 'a', 10) graph.add_edge('s', 'c', 10) graph.add_edge('a', 'b', 4) graph.add_edge('a', 'c', 2) graph.add_edge('a', 'd', 8) graph.add_edge('b', 't', 10) graph.add_edge('c', 'd', 9) graph.add_edge('d', 'b', 6) graph.add_edge('d', 't', 10) graph.add_edge('s2', 'b', 5) flux = ford_fulkerson_multiple_sources(graph, ['s', 's2'], 't') assert flux == 20, 'Flux expected was 19, found: {}'.format(flux)
def test_ford_fulkerson_multiple_sources_two_sources_with_limit(): graph = DirectedGraph() graph.add_node('s') graph.add_node('s2') graph.add_node('a') graph.add_node('b') graph.add_node('c') graph.add_node('d') graph.add_node('t') graph.add_edge('s', 'a', 10) graph.add_edge('s', 'c', 10) graph.add_edge('a', 'b', 4) graph.add_edge('a', 'c', 2) graph.add_edge('a', 'd', 8) graph.add_edge('b', 't', 10) graph.add_edge('c', 'd', 9) graph.add_edge('d', 'b', 6) graph.add_edge('d', 't', 10) graph.add_edge('s2', 'b', 5) sources_limit = {'s': 14, 's2': 1} flux = ford_fulkerson_multiple_sources_and_limits(graph, ['s', 's2'], 't', sources_limit) assert flux == 15, 'Flux expected was 15, found: {}'.format(flux)
def readFile(file): try: f = open(file, 'r') lines = f.readlines() mode = 'missing' vertices = [] arestas = [] arcos = [] for l in lines: if ('*vertices' in l): mode = 'vertices' elif ('*arcs' in l): mode = 'arcs' elif ('*edges' in l): mode = 'edges' else: if (mode == 'vertices'): vertices.append(l.replace('\n', '')) elif (mode == 'arcs'): arcos.append(l.replace('\n', '')) elif (mode == 'edges'): arestas.append(l.replace('\n', '')) if (mode == 'arcs'): return DirectedGraph(vertices, arcos) elif (mode == 'edges'): return NonDirectedGraph(vertices, arestas) finally: f.close()
def invert_graph(G): _G = DirectedGraph() for u in G.all_vertexes(): connections = [(u.data, v) for u, v in G.get_vertex(u).items()] for v, w in connections: _G.add_edge(v, u, w) return _G
def johnson(g, w): vertexes_g = g.get_v() edges_g = g.get_e() s = NameVertex('s') vertexes_g1 = [s] + vertexes_g edges_g1 = edges_g.copy() for vertex in vertexes_g: edges_g1.append(Edge(s, vertex, 0)) graph2 = DirectedGraph(vertexes_g1, edges_g1) if bellman_ford(graph2, w, s) == False: print("the in put graph contains a negative_weight cycle") else: h = dict() for vertex in vertexes_g1: h[vertex] = vertex.d def weight1(edge): return w(edge) + h[edge.u] - h[edge.v] n = len(vertexes_g) d = dict() for u in vertexes_g: dijkstra(g, weight1, u) d[u] = dict() for v in vertexes_g: d[u][v] = v.d + h[v] - h[u] return d
def test_initialization(self): """Test public methods on an empty union.""" # Create []. an_empty_graph = DirectedGraph() self.assertEqual(an_empty_graph.n_vertices(), 0) self.assertEqual(an_empty_graph.connected(0, 0), False) self.assertEqual(an_empty_graph.connected(0, 1), False) self.assertEqual(an_empty_graph.neighbors(0), set())
def test_empty_graph(self): """Test public methods on an empty graph.""" # Build an empty graph. a_graph = DirectedGraph() checker = Reachability(a_graph) # Non-existing vertex is always NOT reachable. self.assertFalse(checker.has_path(0, 0)) self.assertFalse(checker.has_path(0, 1))
def test_adjacency_matrix(self): dg = DirectedGraph("A", "B", "C", "D") dg.add_new_edge("A", "B") dg.add_new_edge("B", "C") dg.add_new_edge("C", "D") assert dg.adjacency_matrix == [[0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], [0, 0, 0, 0]]
class OpArgMngr(object): """Operator argument manager for storing operator workloads.""" graph = DirectedGraph() ops = {} @staticmethod def add_workload(funcname, *args, **kwargs): key = funcname + "." + str(int(time.time())) OpArgMngr.ops[key] = {'args': args, 'kwargs': kwargs, 'funcname': funcname} def add_assignment(variable, assigned_value):
def test_non_consecutive_adding(self): """Test adding vertices non-consecutively.""" # Create []. a_graph = DirectedGraph() # Add 1 to [], which becomes [set(), set()]. # Here 0 is added implicitly. a_graph.add(1) self.assertEqual(a_graph.n_vertices(), 2) self.assertEqual(a_graph.connected(0, 0), True) self.assertEqual(a_graph.connected(0, 1), False) self.assertEqual(a_graph.connected(1, 1), True)
def load_board(cities_filename, routes_filename): board = DirectedGraph() cities: dict[str, City] = _resolve_cities(cities_filename) for city in cities: board.add_node(cities[city].get_name()) _resolve_routes(board, routes_filename) return board, cities
def main(): G = DirectedGraph() G.add_vertex('A') G.add_vertex('B') G.add_vertex('C') G.add_vertex('D') G.add_vertex('E') G.add_edge('A', 'B') G.add_edge('B', 'C') G.add_edge('B', 'D') G.add_edge('A', 'E') print(strongly_connected(G))
def generate_directed_subgraph(original_graph, nodes_subset) -> DirectedGraph: new_graph = DirectedGraph() for node in original_graph.get_nodes(): if node in nodes_subset: new_graph.add_node(node) for edge in original_graph.get_edges(): if edge[0] in nodes_subset and edge[1] in nodes_subset: new_graph.add_edge(edge[0], edge[1], edge[2]) return new_graph
def __init__(self, dict_graph): self.graph = DirectedGraph(dict_graph) self.index = 0 self.stack = [] # Runs Tarjan # Set all node index to None for v in self.graph.nodes: v.index = None self.sccs = [] for v in self.graph.nodes: if v.index == None: self.strongconnect(v, self.sccs)
def test_neighbors(self): """Test root().""" # Create [{1, 2}, {2}, set()]. a_graph = DirectedGraph() a_graph.connect(0, 1) a_graph.connect(0, 2) a_graph.connect(1, 2) # Check neighbors on existing vertices. self.assertEqual(a_graph.neighbors(0), {1, 2}) self.assertEqual(a_graph.neighbors(1), {2}) self.assertEqual(a_graph.neighbors(2), set()) # Check neighbors on non-existing vertices. self.assertEqual(a_graph.neighbors(3), set()) self.assertEqual(a_graph.neighbors(4), set())
def test_linked_list(self): """Test public methods on a linked list.""" # Build a linked list: # 0 -> 1 -> 2 a_graph = DirectedGraph() a_graph.connect(0, 1) a_graph.connect(1, 2) # Sort. a_sorter = TopologicalSort(a_graph) sorted_vertices = a_sorter.sort() # Only one correct sequence. self.assertEqual(sorted_vertices, (2, 1, 0)) # Check the result using a graph.Reachability object. a_checker = Reachability(a_graph) self.assertTrue(self._sorted(sorted_vertices, a_checker))
def generate_rand_dawg(nchars, nwords, wordlenpdf=None): """ Generate a random DAWG whose word lengths are distributed by function wordlenpdf, using gnerate_rand_lexicon above. input: nchars: number of characters in lexicon nwords: number of words in lexicon wordlenpdf: a function """ rand_lex = generate_rand_lexicon(nchars, nwords, wordlenpdf) G = DirectedGraph() G.parselex(rand_lex) trie_to_dawg(G) return G
def test_binary_tree(self): """Test public methods on a binary tree.""" # Build a binary tree: # 0 # / \ # 1 2 a_graph = DirectedGraph() a_graph.connect(0, 1) a_graph.connect(0, 2) # Sort. a_sorter = TopologicalSort(a_graph) sorted_vertices = a_sorter.sort() # Either of the two sequences is correct. self.assertTrue(sorted_vertices in {(2, 1, 0), (1, 2, 0)}) # Check the result using a graph.Reachability object. a_checker = Reachability(a_graph) self.assertTrue(self._sorted(sorted_vertices, a_checker))
def test_traverse(self): vertexes_names = [] def traverse_visit_callback(vertex): vertexes_names.append(vertex.name) dg = DirectedGraph("A", "B", "C", "D") dg.add_new_edge("A", "B") dg.add_new_edge("B", "C") dg.add_new_edge("C", "D") # bfs dg.bfs_traverse("A", traverse_visit_callback) assert vertexes_names == ["A", "B", "C", "D"] vertexes_names = [] # dfs dg.dfs_traverse("A", traverse_visit_callback) assert vertexes_names == ["A", "B", "C", "D"]
def test_binary_tree(self): """Test public methods on a binary tree.""" # Build a binary tree: # 0 # / \ # 1 2 a_graph = DirectedGraph() a_graph.connect(0, 1) a_graph.connect(0, 2) checker = Reachability(a_graph) # All the vertices are reachable from the root. self.assertTrue(checker.has_path(0, 1)) self.assertTrue(checker.has_path(0, 2)) # Vertices in another subtree are NOT reachable. self.assertFalse(checker.has_path(1, 2)) self.assertFalse(checker.has_path(2, 1)) # Parent is NOT reachable. self.assertFalse(checker.has_path(1, 0)) self.assertFalse(checker.has_path(2, 0))
def test_create(self): dg = DirectedGraph() dg.extend_vertexes("A", "B", "C", "D") dg.add_new_edge("A", "B") dg.add_new_edge("B", "C") dg.add_new_edge("C", "D") assert [v.name for v in dg.vertexes] == ["A", "B", "C", "D"] assert dg.adjacency_dict == { vt("A"): [vt("B")], vt("B"): [vt("C")], vt("C"): [vt("D")], vt("D"): [], } with pytest.raises(exceptions.VertexNotExistError): dg.get_vertex_by_name("E") with pytest.raises(exceptions.VertexNotExistError): dg.add_new_edge("E", "B")
def test_implicit_adding_by_connecting(self): """Test connect(), which implicitly calls add().""" # Create []. a_graph = DirectedGraph() # Implicitly add 0, 1, 2 to [], then connect 1 with 2, # which makes [set(), {2}, set()]. a_graph.connect(1, 2) self.assertEqual(a_graph.n_vertices(), 3) # Trivially connected vertices. self.assertEqual(a_graph.connected(0, 0), True) self.assertEqual(a_graph.connected(1, 1), True) self.assertEqual(a_graph.connected(2, 2), True) # Uni-directional connection created by connect(). self.assertEqual(a_graph.connected(1, 2), True) self.assertEqual(a_graph.connected(2, 1), False) # Disconnected vertices. self.assertEqual(a_graph.connected(0, 1), False) self.assertEqual(a_graph.connected(1, 0), False) self.assertEqual(a_graph.connected(0, 2), False) self.assertEqual(a_graph.connected(2, 0), False)
def test_linked_list(self): """Test public methods on a linked list.""" # Build a linked list: # 0 -> 1 -> 2 a_graph = DirectedGraph() a_graph.connect(0, 1) a_graph.connect(1, 2) checker = Reachability(a_graph) # A vertex is always reachable from/to itself. self.assertTrue(checker.has_path(0, 0)) self.assertTrue(checker.has_path(1, 1)) self.assertTrue(checker.has_path(2, 2)) # A downstream vertex is reachable from an upstream vertex. self.assertTrue(checker.has_path(0, 1)) self.assertTrue(checker.has_path(1, 2)) self.assertTrue(checker.has_path(0, 2)) # A upstream vertex is NOT reachable from an downstream vertex. self.assertFalse(checker.has_path(1, 0)) self.assertFalse(checker.has_path(2, 0)) self.assertFalse(checker.has_path(2, 1))
def make_graph(cls, root, strategy): """Compute the graph implied by some GameState.""" graph = DirectedGraph() queue = deque() visited = set() # Add root to queue visited.add(root) queue.append(root) while queue: node = queue.popleft() if not node.is_over: for next in strategy.get_next_states(node): graph.add_arc(node, next) if next not in visited: # Add `next` to queue. visited.add(next) queue.append(next) return graph
def test_consecutive_adding(self): """Test adding vertices consecutively.""" # Create []. a_graph = DirectedGraph() # Add 0 to [], which becomes [set()]. a_graph.add(0) self.assertEqual(a_graph.n_vertices(), 1) self.assertEqual(a_graph.connected(0, 0), True) self.assertEqual(a_graph.connected(0, 1), False) self.assertEqual(a_graph.connected(1, 1), False) # Add 0 to [set()], nothing changes. a_graph.add(0) self.assertEqual(a_graph.n_vertices(), 1) self.assertEqual(a_graph.connected(0, 0), True) self.assertEqual(a_graph.connected(0, 1), False) self.assertEqual(a_graph.connected(1, 1), False) # Add 1 to [set()], which becomes [set(), set()]. a_graph.add(1) self.assertEqual(a_graph.n_vertices(), 2) self.assertEqual(a_graph.connected(0, 0), True) self.assertEqual(a_graph.connected(0, 1), False) self.assertEqual(a_graph.connected(1, 1), True)
def main(): g = DirectedGraph() for i in range(9): g.add_vertex(i) g.add_edge(0, 1, 4) g.add_edge(0, 7, 8) g.add_edge(1, 2, 8) g.add_edge(1, 7, 11) g.add_edge(2, 3, 7) g.add_edge(2, 8, 2) g.add_edge(2, 5, 4) g.add_edge(3, 4, 9) g.add_edge(3, 5, 14) g.add_edge(4, 5, 10) g.add_edge(5, 6, 2) g.add_edge(6, 7, 1) g.add_edge(6, 8, 6) g.add_edge(7, 8, 7) print(g) prim(g)
def test_ford_fulkerson(): graph = DirectedGraph() graph.add_node('s') graph.add_node('a') graph.add_node('b') graph.add_node('c') graph.add_node('d') graph.add_node('t') graph.add_edge('s', 'a', 10) graph.add_edge('s', 'c', 10) graph.add_edge('a', 'b', 4) graph.add_edge('a', 'c', 2) graph.add_edge('a', 'd', 8) graph.add_edge('b', 't', 10) graph.add_edge('c', 'd', 9) graph.add_edge('d', 'b', 6) graph.add_edge('d', 't', 10) flux = ford_fulkerson(graph, 's', 't') assert flux == 19, 'Flux expected was 19, found: {}'.format(flux)