def test_graph_condition_jump(): no_condition = graph.Edge() assert(no_condition.can_jump()) assert(no_condition.can_jump('a')) match_a = graph.Edge(lambda x: x == 'a') assert(match_a.can_jump('a')) assert( not match_a.can_jump('b'))
def build_graph(dfs_codes): g = graph.Graph() numnodes = max([x[0] for x in dfs_codes] + [x[1] for x in dfs_codes]) + 1 for i in range(numnodes): n = graph.Node() g.nodes.append(n) for idx, c in enumerate(dfs_codes): g.nodes[c.fromn].id = c.fromn g.nodes[c.fromn].label = c.from_label g.nodes[c.to].id = c.to g.nodes[c.to].label = c.to_label e = graph.Edge() e.id = g.nedges e.fromn = c.fromn e.to = c.to e.label = c.edge_label g.nodes[c.fromn].edges.append(e) e2 = graph.Edge() e2.id = e.id e2.label = e.label e2.fromn = c.to e2.to = c.fromn g.nodes[c.to].edges.append(e2) g.nedges += 1 return g
def unreverse_edges(g): if g.root.label == 'multi-sentence': roots = [edge.tails[0] for edge in g.root.outedges] else: roots = [g.root] for node in g.dfs(): edges = [] for edge in node.outedges: reverse = False m = re.match(r"(.*)-of$", edge.label) if m: reverse = True newlabel = m.group(1) """elif edge.label in ["purpose"] and not re.match(r".*-\d+^", node.label): reverse = True newlabel = edge.label + '-of'""" if reverse: (root, ) = edge.tails root.outedges.append(graph.Edge(newlabel, [node])) roots.append(root) else: edges.append(edge) node.outedges = edges dummy = graph.Graph( graph.Node('dummy', [graph.Edge('dummy', [root]) for root in roots])) components = dummy.scc() cindex = {} for ci, component in enumerate(components): for node in component: cindex[node] = ci reachable = set() for node in dummy.dfs(): if node is dummy: reachable.add(cindex[node]) continue for edge in node.outedges: for tail in edge.tails: if cindex[node] != cindex[tail]: reachable.add(cindex[tail]) roots = [ component.pop() for ci, component in enumerate(components) if ci not in reachable ] if len(roots) > 1: edges = [] for ri, root in enumerate(roots): edges.append(graph.Edge('snt{0}'.format(ri + 1), [root])) g.root = graph.Node('multi-sentence', edges) else: g.root = roots[0] g.update()
def t2(): g = G.Graph.empty_graph() e1 = G.Edge("n1", 100, "n2") e2 = G.Edge("n3", 100, "n2") e3 = G.Edge("n1", 200, "n3") g.add_edge_list([e1, e2, e3]) simulation = Simulation(g, 1) simulation.simulate(30)
def testIgnoresUnknownEdges(self): nodes = [_IndexedNode(i) for i in xrange(7)] edges = [graph.Edge(nodes[from_index], nodes[to_index]) for (from_index, to_index) in [ (0, 1), (0, 2), (1, 3), (3, 4), (5, 6)]] edges.append(graph.Edge(nodes[4], _IndexedNode(42))) edges.append(graph.Edge(_IndexedNode(42), nodes[5])) g = graph.DirectedGraph(nodes, edges) self.assertListEqual(range(7), sorted(self._NodesIndices(g))) self.assertEqual(5, len(g.Edges()))
def test_find_length_shortest_route(self): my_edge_list = ['AB5', 'BC4', 'CD8', 'DC8', 'DE6', 'AD5', 'CE2', 'EB3', 'AE7'] my_graph = graph.Graph(my_edge_list) AE7 = graph.Edge("A", "E", 7) EB3 = graph.Edge("E", "B", 3) AB5 = graph.Edge("A", "B", 5) DE6 = graph.Edge("D", "E", 6) BC4 = graph.Edge("B", "C", 4) CD8 = graph.Edge("C", "D", 8) DC8 = graph.Edge("D", "C", 8) CE2 = graph.Edge("C", "E", 2) AD5 = graph.Edge("A", "D", 5) self.assertEqual(my_graph.find_length_shortest_route("A", "A"), "NO SUCH ROUTE") self.assertEqual(my_graph.find_length_shortest_route("A", "B"), 5) self.assertEqual(my_graph.find_length_shortest_route("A", "C"), 9) self.assertEqual(my_graph.find_length_shortest_route("A", "D"), 5) self.assertEqual(my_graph.find_length_shortest_route("A", "E"), 7) self.assertEqual(my_graph.find_length_shortest_route("C", "D"), 8) self.assertEqual(my_graph.find_length_shortest_route("D", "C"), 8) self.assertEqual(my_graph.find_length_shortest_route("E", "B"), 3) self.assertEqual(my_graph.find_length_shortest_route("A", "6"), "NO SUCH ROUTE") self.assertEqual(my_graph.find_length_shortest_route("0", "C"), "NO SUCH ROUTE") self.assertEqual(my_graph.find_length_shortest_route("foo", "bar"), "NO SUCH ROUTE") self.assertEqual(my_graph.find_length_shortest_route(7, "z"), "NO SUCH ROUTE") with self.assertRaises(Exception): self.assertEqual(my_graph.find_length_shortest_route([], "C"), "NO SUCH ROUTE")
def _build(self, pattern=[], fragments_stack=[]): if not pattern: return for c in pattern: fragment = Fragment() if c == expression.REGEX_NOTATION.CONCATENATION: fragment_latter = fragments_stack.pop() fragment_former = fragments_stack.pop() for edge in fragment_former.out_edges: edge.set_end(fragment_latter.start_node) fragment.start_node = fragment_former.start_node fragment.out_edges = fragment_latter.out_edges elif c == expression.REGEX_NOTATION.OR: fragment_branch_1 = fragments_stack.pop() fragment_branch_2 = fragments_stack.pop() node = graph.Node() graph.Edge().set_start(node).set_end( fragment_branch_1.start_node) graph.Edge().set_start(node).set_end( fragment_branch_2.start_node) fragment.start_node = node fragment.out_edges = fragment_branch_1.out_edges + fragment_branch_2.out_edges elif c == expression.REGEX_NOTATION.REPEAT_MORE_THAN_ONE: fragment_last = fragments_stack.pop() node = graph.Node() for edge in fragment_last.out_edges: edge.set_end(node) graph.Edge().set_start(node).set_end(fragment_last.start_node) edge = graph.Edge() edge.set_start(node) fragment.start_node = fragment_last.start_node fragment.out_edges.append(edge) elif c == expression.REGEX_NOTATION.REPEAT_OR_ZERO: fragment_last = fragments_stack.pop() node = graph.Node() for edge in fragment_last.out_edges: edge.set_end(node) graph.Edge().set_start(node).set_end(fragment_last.start_node) edge = graph.Edge() edge.set_start(node) fragment.start_node = node fragment.out_edges.append(edge) elif c == expression.REGEX_NOTATION.ZERO_OR_ONE: fragment_last = fragments_stack.pop() node = graph.Node() graph.Edge().set_start(node).set_end(fragment_last.start_node) edge = graph.Edge() edge.set_start(node) fragment.start_node = node fragment.out_edges = fragment_last.out_edges fragment.out_edges.append(edge) else: node = graph.Node() edge = graph.Edge(expression.MatchFunction(c)) edge.set_start(node) fragment.start_node = node fragment.out_edges.append(edge) fragments_stack.append(fragment)
def add_edges(self, graph_nodes): edges = [] for i in range(len(graph_nodes) - 1): current_node_id = graph_nodes[i].id edge = graph.Edge(graph_nodes[i], graph_nodes[i + 1], 'Right') edges.append(edge) return edges
def read_input_graph(self): nums = self.read_numbers('Cannot parse the number of edges.', 1) num_edges = nums[0] if num_edges > config.MAX_NUM_EDGES: raise self.exception('Number of edges cannot ' + 'exceed {0}.'.format(config.MAX_NUM_EDGES)) edge_set = set() for i in range(num_edges): nums = self.read_numbers('Cannot parse the next edge.', 2) e = graph.Edge(nums[0], nums[1]) try: e.check() except graph.EdgeException as ex: raise self.exception(str(ex)) if e in edge_set: raise self.exception(('Edge {0} (or its reverse) ' + 'is duplicated.').format(e)) edge_set.add(e) return edge_set
def create_edges(nodes_a_id, nodes_b_id, all_nodes): edges = [] for node_a_id, node_b_id in zip(nodes_a_id, nodes_b_id): node_a = nodes_dict[node_a_id] node_b = nodes_dict[node_b_id] edges.append(graph.Edge(node_a, node_b)) return edges
def testNewGraph(self): #self.assertRaises(Exception, Graph) g = graph.Graph("graph1") n = graph.Node("node1") e = graph.Edge(1, 2) g.addnode("node2") self.assertTrue(len(g.nodes) == 1)
def star_graph(n): """generate star graph n""" g = graph.Graph() ni = graph.Node() for i in xrange(n): n = graph.Node() e = graph.Edge(ni, n) g.add_edge(e) return g
def pushed(self, item: CDGRegionNode, label: t.Optional[str] = None) -> t.Iterator[CDGRegionNode]: if len(self) == 0: assert item.type == CDGRegionNodeType.enter else: self.graph.add_edge(graph.Edge(self[-1], item, label)) self.append(item) yield item self.pop()
def test_get_route_distance(self): my_edge_list = ['AB5', 'BC4', 'CD8', 'DC8', 'DE6', 'AD5', 'CE2', 'EB3', 'AE7'] my_graph = graph.Graph(my_edge_list) AE7 = graph.Edge("A", "E", 7) EB3 = graph.Edge("E", "B", 3) AB5 = graph.Edge("A", "B", 5) DE6 = graph.Edge("D", "E", 6) BC4 = graph.Edge("B", "C", 4) CD8 = graph.Edge("C", "D", 8) DC8 = graph.Edge("D", "C", 8) CE2 = graph.Edge("C", "E", 2) AD5 = graph.Edge("A", "D", 5) self.assertEqual(my_graph.get_route_distance([AD5, DE6, EB3]), 14) self.assertEqual(my_graph.get_route_distance([AD5, DC8, CD8, DE6, EB3]), 30) self.assertEqual(my_graph.get_route_distance([]), 0) self.assertEqual(my_graph.get_route_distance([AD5]), 5)
def t4(): g = G.Graph.empty_graph() edge_list = [ G.Edge("n1", 1, "n2"), G.Edge("n1", 1, "n3"), G.Edge("n1", 1, "n4"), G.Edge("n2", 1, "n3"), G.Edge("n2", 1, "n4"), G.Edge("n3", 1, "n4"), G.Edge("n5", 1, "n6"), G.Edge("n5", 1, "n7"), G.Edge("n6", 1, "n7"), G.Edge("n4", 1, "n6") ] g.add_edge_list(edge_list) simulation = Simulation(g, 1, 10) simulation.simulate(100) simulation.to_csv("output-t4.csv")
def add_tail(self, tail: CFGNode, label: t.Optional[str] = None) -> CFGEdge: if label: label = '{} - {}'.format(self.label, label) if self.label else label else: label = self.label edge = graph.Edge(self.head, tail, label) self.graph.add_edge(edge) return edge
def test_graph_build(): n1 = graph.Node() n2 = graph.Node() e = graph.Edge() e.set_start(n1) e.set_end(n2) assert(e.start_node == n1) assert(e.end_node == n2) assert(e in n1.out_edges) assert(e not in n1.in_edges) assert(e in n2.in_edges) assert(e not in n2.out_edges)
def add_edges(graph_nodes): edges = [] for i in range(len(graph_nodes) - 1): current_node_id = graph_nodes[i].id edge = graph.Edge(graph_nodes[i], graph_nodes[i + 1], 'Right') edges.append(edge) for edge in edges: print('----Edge----') print(edge) print(edge.node1.gt + ' - ' + edge.rel + ' - ' + edge.node2.gt) return edges
def create_dense_graph(n, density): g = G.Graph.empty_graph() nodes = [] for i in range(n): nodes.append(g.generate_new_node_name()) pairs = [(n1, n2) for n1 in nodes for n2 in nodes] edges = [G.Edge(n1, 1, n2) for (n1, n2) in pairs if n1 != n2] random.shuffle(edges) if(density != 1): edges = edges[ : int(-((1 - density) * len(edges)))] for e in edges: g.add_edge(e) return g
def MakeGraph(cls, count, edge_tuples): """Makes a graph from a list of edges. Args: count: Number of nodes. edge_tuples: (from_index, to_index). Both indices must be in [0, count), and uniquely identify a node. """ nodes = [_IndexedNode(i) for i in xrange(count)] edges = [ graph.Edge(nodes[from_index], nodes[to_index]) for (from_index, to_index) in edge_tuples ] return (nodes, edges, graph.DirectedGraph(nodes, edges))
def t4(dim, r, a, f, degree): g = G.Graph.empty_graph() edge_list = [ G.Edge("n1", 1, "n2"), G.Edge("n1", 1, "n3"), G.Edge("n1", 1, "n4"), G.Edge("n2", 1, "n3"), G.Edge("n2", 1, "n4"), G.Edge("n3", 1, "n4"), G.Edge("n5", 1, "n6"), G.Edge("n5", 1, "n7"), G.Edge("n6", 1, "n7"), G.Edge("n4", 1, "n6") ] g.add_edge_list(edge_list) simulation = Simulation(g, dim, 10, r, a, f, degree) simulation.simulate(200) file1 = "simulate-csv/degree-" + str(degree) + "/dim-" + str( dim) + "/output-t4_" + str(r) + "_" + str(a) + "_" + str(f) + ".csv" simulation.to_csv(file1) print(file1)
def test_find_all_routes(self): my_edge_list = ['AB5', 'BC4', 'CD8', 'DC8', 'DE6', 'AD5', 'CE2', 'EB3', 'AE7'] my_graph = graph.Graph(my_edge_list) AE7 = graph.Edge("A", "E", 7) EB3 = graph.Edge("E", "B", 3) AB5 = graph.Edge("A", "B", 5) DE6 = graph.Edge("D", "E", 6) BC4 = graph.Edge("B", "C", 4) CD8 = graph.Edge("C", "D", 8) DC8 = graph.Edge("D", "C", 8) CE2 = graph.Edge("C", "E", 2) AD5 = graph.Edge("A", "D", 5) self.assertItemsEqual(my_graph.find_all_routes("A", "A"), []) self.assertItemsEqual(my_graph.find_all_routes("A", "B"), [ [AE7, EB3], [AB5], [AD5, DE6, EB3], [AD5, DC8, CE2, EB3], [AD5, DC8, CD8, DE6, EB3] ]) self.assertItemsEqual(my_graph.find_all_routes("A", "6"), []) self.assertItemsEqual(my_graph.find_all_routes("0", "C"), []) self.assertItemsEqual(my_graph.find_all_routes("foo", "bar"), []) self.assertItemsEqual(my_graph.find_all_routes(7, "z"), []) with self.assertRaises(Exception): self.assertItemsEqual(my_graph.find_all_routes([], "C"), [])
def __getEdge(self): line = self.fobj.readline() self.linecount+=1 pipe_info = line.split() start = pipe_info[param.EDGE_INPUT['SRC']] ##print 'start-e',start dst = pipe_info[param.EDGE_INPUT['DST']] ##print 'dst-e',dst wt = int(pipe_info[param.EDGE_INPUT['WT']]) off_period = int(pipe_info[param.EDGE_INPUT['NOFF']]) j = param.EDGE_INPUT['NOFF']+1 off_list = [] for i in range(off_period): off_list.append(pipe_info[j+i]) return graph.Edge(self.nodes[start], self.nodes[dst], wt, off_period, off_list)
def get_neighbors(self): # for each grounded action for ac in groundedActions: # if the action is modeled in the state if expressions.models(self.state, expressions.make_expression( ac.precondition)): ## apply the effect to the world newstate = expressions.apply( self.state, expressions.make_expression(ac.effect)) ## add state to the neighbours list as an edge nt = PlanNode(ac.name, newstate, self.objs) ne = graph.Edge(nt, 1, ac.name) self.neighbours.append(ne) return self.neighbours
def test_get_number_routes_with_exactly_stops(self): my_edge_list = ['AB5', 'BC4', 'CD8', 'DC8', 'DE6', 'AD5', 'CE2', 'EB3', 'AE7'] my_graph = graph.Graph(my_edge_list) AE7 = graph.Edge("A", "E", 7) EB3 = graph.Edge("E", "B", 3) AB5 = graph.Edge("A", "B", 5) DE6 = graph.Edge("D", "E", 6) BC4 = graph.Edge("B", "C", 4) CD8 = graph.Edge("C", "D", 8) DC8 = graph.Edge("D", "C", 8) CE2 = graph.Edge("C", "E", 2) AD5 = graph.Edge("A", "D", 5) self.assertEqual(my_graph.get_number_routes_with_exactly_stops("A", "A", stops=5), 0) self.assertEqual(my_graph.get_number_routes_with_exactly_stops("A", "B", stops=5), 3) self.assertEqual(my_graph.get_number_routes_with_exactly_stops("A", "6", stops=5), 0) self.assertEqual(my_graph.get_number_routes_with_exactly_stops("0", "C", stops=5), 0) self.assertEqual(my_graph.get_number_routes_with_exactly_stops("foo", "bar", stops=5), 0) self.assertEqual(my_graph.get_number_routes_with_exactly_stops(7, "z", stops=5), 0) with self.assertRaises(Exception): result = my_graph.get_number_routes_with_exactly_stops([], "C", stops=5) self.assertEqual(result, 0)
def test_find_routes_with_distance(self): my_edge_list = ['AB5', 'BC4', 'CD8', 'DC8', 'DE6', 'AD5', 'CE2', 'EB3', 'AE7'] my_graph = graph.Graph(my_edge_list) AE7 = graph.Edge("A", "E", 7) EB3 = graph.Edge("E", "B", 3) AB5 = graph.Edge("A", "B", 5) DE6 = graph.Edge("D", "E", 6) BC4 = graph.Edge("B", "C", 4) CD8 = graph.Edge("C", "D", 8) DC8 = graph.Edge("D", "C", 8) CE2 = graph.Edge("C", "E", 2) AD5 = graph.Edge("A", "D", 5) self.assertItemsEqual(my_graph.find_routes_with_distance("A", "A", distance=5), []) self.assertItemsEqual(my_graph.find_routes_with_distance("A", "B", distance=11), [ [AE7, EB3], [AB5]]) self.assertItemsEqual(my_graph.find_routes_with_distance("A", "6", distance=5), []) self.assertItemsEqual(my_graph.find_routes_with_distance("0", "C", distance=5), []) self.assertItemsEqual(my_graph.find_routes_with_distance("foo", "bar", distance=5), []) self.assertItemsEqual(my_graph.find_routes_with_distance(7, "z", distance=5), []) with self.assertRaises(Exception): result = my_graph.find_routes_with_distance([], "C", distance=5) self.assertItemsEqual(result, [])
def read_output_graph(self, in_edge_set): nums = self.read_numbers('Cannot parse the number of edges.', 1) Gin = graph.make_graph(in_edge_set) Gin.search() if nums[0] != Gin.num_nodes - 1: raise self.exception( ('Input graph has {0} non-isolated ' + 'nodes, output graph should have {1} edges, ' + 'got {2} instead.').format(Gin.num_nodes, Gin.num_nodes - 1, nums[0])) out_edge_set = set() num_edges = nums[0] for i in range(num_edges): nums = self.read_numbers('Cannot parse the next edge.', 2) e = graph.Edge(nums[0], nums[1]) if e not in in_edge_set: raise self.exception(('Edge {0} in the output graph is ' + 'absent in the input graph.').format(e)) if e in out_edge_set: raise self.exception(('Edge {0} (or its reverse) is ' + 'duplicated.').format(e)) out_edge_set.add(e) Gout = graph.make_graph(out_edge_set) Gout.search() if Gout.num_nodes != Gin.num_nodes: raise self.exception( ('After reading the last edge, the number ' + 'of non-isolated nodes in the output graph ({0}) ' + 'should equal that of the input graph ({1}) to be ' + 'a spanning tree.').format(Gout.num_nodes, Gin.num_nodes)) if not Gout.edges_in_one_component: raise self.exception( 'Disconnected graph: after reading the last edge, the output graph should be connected to be a spanning tree.' ) if Gout.has_cycle: raise self.exception( 'Cycle detected: after reading the last edge, the output graph should not have cycles to be a spanning tree.' ) return Gout.num_leaves
def create_cdg_loop( loop: t.Union[ast.While, ast.For, ast.AsyncFor], stack: CDGStack, exit_node: CDGRegionNode, res_graph: CDG, ) -> CDGNode: if isinstance(loop, ast.While): label = 'T' name = 'While {}'.format(astor.to_source(loop.test).strip()) else: label = 'Cont' name = 'For {} in {}'.format( astor.to_source(loop.target).strip(), astor.to_source(loop.iter).strip()) lineno = -1 end_lineno = -1 if hasattr(loop, 'lineno'): lineno = loop.lineno # if hasattr(loop, 'end_lineno'): # end_lineno = loop.end_lineno loop_block = CDGRegionNode(loop, CDGRegionNodeType.loop_block, name, lineno=lineno, end_lineno=end_lineno) with stack.pushed(loop_block): loop_body = CDGRegionNode(ast.Pass(), CDGRegionNodeType.loop_body, lineno=lineno, end_lineno=end_lineno) res_graph.add_edge(graph.Edge(loop_body, loop_block, None)) with stack.pushed(loop_body, label): process_block(loop.body, stack, exit_node, res_graph) if loop.orelse: with stack.pushed( CDGRegionNode(ast.Pass(), CDGRegionNodeType.else_block, lineno=loop.lineno)): process_block(loop.orelse, stack, exit_node, res_graph) for breaked in loop_block.breaks: stack.connect_to_next.append(breaked) loop_block.breaks = [] return loop_block
def buildGraph(self): ''' 练习22.2-1 练习22.2-2 ''' g = _g.Graph() g.veterxs = [_g.Vertex('1'), _g.Vertex('2'), _g.Vertex('3'), _g.Vertex('4'), _g.Vertex('5'), _g.Vertex('6')] g.edges.clear() g.edges.append(_g.Edge(_g.Vertex('1'), _g.Vertex('2'), 1, _g.DIRECTION_TO)) g.edges.append(_g.Edge(_g.Vertex('4'), _g.Vertex('2'), 1, _g.DIRECTION_TO)) g.edges.append(_g.Edge(_g.Vertex('1'), _g.Vertex('4'), 1, _g.DIRECTION_TO)) g.edges.append(_g.Edge(_g.Vertex('2'), _g.Vertex('5'), 1, _g.DIRECTION_TO)) g.edges.append(_g.Edge(_g.Vertex('3'), _g.Vertex('6'), 1, _g.DIRECTION_TO)) g.edges.append(_g.Edge(_g.Vertex('3'), _g.Vertex('5'), 1, _g.DIRECTION_TO)) g.edges.append(_g.Edge(_g.Vertex('5'), _g.Vertex('4'), 1, _g.DIRECTION_TO)) g.edges.append(_g.Edge(_g.Vertex('6'), _g.Vertex('6'), 1, _g.DIRECTION_TO)) _g.bfs(g, g.veterxs[2]) _g.print_path(g, g.veterxs[2], g.veterxs[4]) print('') del g g = _g.Graph() g.veterxs.clear() g.edges.clear() v = ['r', 's', 't', 'u', 'v', 'w', 'x', 'y'] g.addvertex(v) g.addedge('v', 'r') g.addedge('r', 's') g.addedge('s', 'w') g.addedge('w', 'x') g.addedge('w', 't') g.addedge('x', 't') g.addedge('x', 'u') g.addedge('x', 'y') g.addedge('y', 'u') g.addedge('u', 't') _g.bfs(g, 'u') _g.print_path(g, 'u', 'v') print('') del g
def MakeGraph(cls, count, edge_tuples, serialize=False): """Makes a graph from a list of edges. Args: count: Number of nodes. edge_tuples: (from_index, to_index). Both indices must be in [0, count), and uniquely identify a node. Must be sorted lexicographically by node indices. """ nodes = [_IndexedNode(i) for i in xrange(count)] edges = [graph.Edge(nodes[from_index], nodes[to_index]) for (from_index, to_index) in edge_tuples] g = graph.DirectedGraph(nodes, edges) if serialize: g = graph.DirectedGraph.FromJsonDict( g.ToJsonDict(), _IndexedNode, graph.Edge) nodes = sorted(g.Nodes(), key=operator.attrgetter('index')) edges = sorted(g.Edges(), key=operator.attrgetter( 'from_node.index', 'to_node.index')) return (nodes, edges, g)