def test_random_directed_1(self): CC = nx.from_numpy_matrix(self.C, create_using=nx.DiGraph) lenC = len(max(nx.kosaraju_strongly_connected_components(CC), key=len)) DD = nx.from_numpy_matrix(self.D, create_using=nx.DiGraph) lenD = len(max(nx.kosaraju_strongly_connected_components(DD), key=len)) self.assertEqual(lenC, (self.C).shape[0]) self.assertEqual(lenD, (self.D).shape[0])
def DONEnolongerneeded(): """extracting a part of the metabolic network dataset from Stanford University output: a connected graph (contains loops, I verifyed) of 932 nodes, saved into json file. The BASE. """ f_ll = open("PP-Pathways_ppi.csv", "rt").readlines() allEdges = set() for line in f_ll: tup = tuple(int(i) for i in line.replace("\n", "").split(",")) if tup[0] > 2500 or tup[1] > 2500: continue else: allEdges.add(tup) ALLMETAB = nx.DiGraph() ALLMETAB.add_edges_from(list(allEdges)) print(len(list((ALLMETAB.edges())))) print(len(list((ALLMETAB.nodes())))) #extract the nodes making part of the largest connected component: ho_l = max(nx.kosaraju_strongly_connected_components(ALLMETAB), key=len) print(type(ho_l)) SG = ALLMETAB.subgraph(ho_l) print(len(SG.nodes())) print(len(SG.edges())) print(nx.is_connected(SG.to_undirected())) #True, ok print(nx.is_directed(SG)) # , True ok EDGEStxt = ", ".join(list(str(list(tu)) for tu in SG.edges())) textjson = '{"nodes": ' + str(len( SG.nodes())) + ', "edges": [' + EDGEStxt + ']}' with open("METABO.jsonlike", "w") as p: p.write(textjson) p.close() return "done"
def test_null_graph(self): G = nx.DiGraph() assert_equal(list(nx.strongly_connected_components(G)), []) assert_equal(list(nx.kosaraju_strongly_connected_components(G)), []) assert_equal(list(nx.strongly_connected_components_recursive(G)), []) assert_equal(len(nx.condensation(G)), 0) assert_raises(nx.NetworkXPointlessConcept, nx.is_strongly_connected, nx.DiGraph())
def test_null_graph(self): G = nx.DiGraph() assert list(nx.strongly_connected_components(G)) == [] assert list(nx.kosaraju_strongly_connected_components(G)) == [] assert list(nx.strongly_connected_components_recursive(G)) == [] assert len(nx.condensation(G)) == 0 pytest.raises(nx.NetworkXPointlessConcept, nx.is_strongly_connected, nx.DiGraph())
def test_algo_time_nx(self): """ this test check the run time of connected_components and shortest path in networkx :return:None """ ga1 = GraphAlgo.GraphAlgo() filename = '../data/G_100_800_1.json' ga1.load_from_json(filename) ga = self.graph_nx(ga1.get_graph()) with self.elapsed_timer() as elapsed: star = elapsed() l = nx.single_source_dijkstra(ga, 0, 2) end = elapsed() res = end - star try: with open("res2.txt", "a") as f: f.write(f"\ngraph:{filename},shortest_path:{res}\n{l}") star = elapsed() # print(list(nx.strongly_connected_components(ga))) print(list(nx.kosaraju_strongly_connected_components(ga))) end = elapsed() res = end - star f.write(f"\ngraph:{filename},connected_component:{res}\n") except IOError as e: print(e)
def find_SCCS(self): """ (1) It first finds the SCCs of the transaction graph. verified """ # scc requires a digraph graph = self.create_graph(_type='di') self.SCCs = list(kosaraju_strongly_connected_components(graph)) self.SCCs.sort()
def city_graph_generator(city): """ Generate an OSMnx graph of **city**. Graph modified to be undirected, weighted, and meeting the triangle inequality. Parameters ---------- city: str The city to query road network from. *'City, Country'*. Returns ------- G: graph OSMnx generated graph of **city**. Graph is weighted, undirected, and satisfies the triangle inequality. Raises ------ AssertionError If **city** is not a string. """ # Assert city input is string. assert type(city) is str, "City name not valid, must be string." # Query and generate OSMNX graph from city. O = ox.graph_from_place(city, network_type='drive', simplify=True, retain_all=False, timeout=60) # Keep only the largest strongly connected component. keep = max(nx.kosaraju_strongly_connected_components(O), key=len) G_sub = O.subgraph(keep).copy() G_dir = nx.DiGraph(G_sub) G = nx.Graph() G.graph.update(G_dir.graph) # Iterate over edges to keep maximum weight edges # in the case where there are parallel edges. for u, v in G_dir.edges(): G.add_nodes_from([(u, G_dir.nodes[u]), (v, G_dir.nodes[v])]) if (v, u) in G_dir.edges(): wgt = max(G_dir.edges[u, v]['length'], G_dir.edges[v, u]['length']) else: wgt = G_dir.edges[u, v]['length'] G.add_edges_from([(u, v, G_dir.edges[u, v])]) G.edges[u, v]['length'] = wgt G.edges[u, v]['weight'] = wgt return G
def stronglyConnectedComponents(self) -> list: """ Gets strongly connected components of graph. Returns ------- list Strongly connected component of specified node """ return list(nodeSet for nodeSet in nx.kosaraju_strongly_connected_components(self.graph))
def test_connected_raise(self): G = nx.Graph() with pytest.raises(NetworkXNotImplemented): next(nx.strongly_connected_components(G)) with pytest.raises(NetworkXNotImplemented): next(nx.kosaraju_strongly_connected_components(G)) with pytest.raises(NetworkXNotImplemented): next(nx.strongly_connected_components_recursive(G)) pytest.raises(NetworkXNotImplemented, nx.is_strongly_connected, G) pytest.raises(nx.NetworkXPointlessConcept, nx.is_strongly_connected, nx.DiGraph()) pytest.raises(NetworkXNotImplemented, nx.condensation, G)
def build(self): """Finalise the graph, after adding all input files to it.""" assert not self.final, 'Trying to mutate a final graph.' # Replace each strongly connected component with a single node `NodeSet` for scc in sorted(nx.kosaraju_strongly_connected_components(self.graph), key=len, reverse=True): if len(scc) == 1: break self.shrink_to_node(NodeSet(scc)) self.final = True
def createGraphs2(subdata, deg): avg = 0 for j in range(len(subdata)): matrix = subdata[j] threshold = alzTest.findThresh(matrix, deg) for k in range(len(subdata[j])): for l in range(len(subdata[j][k])): if subdata[j][k][l] > threshold: subdata[j][k][l] = 1 else: subdata[j][k][l] = 0 G = nx.DiGraph(subdata[j]) listoflists = nx.kosaraju_strongly_connected_components(G) avg += len(listoflists[0]) return float(avg / len(subdata))
def createGraphs2(subdata, deg): avg = 0 for j in range(len(subdata)): matrix = subdata[j] threshold = alzTest.findThresh(matrix, deg) for k in range(len(subdata[j])): for l in range(len(subdata[j][k])): if subdata[j][k][l] > threshold: subdata[j][k][l] = 1 else: subdata[j][k][l] = 0 G = nx.DiGraph(subdata[j]) listoflists = nx.kosaraju_strongly_connected_components(G) avg += len(listoflists[0]) return float(avg/len(subdata))
def print_results(nx_g, cm_g): """ Print out result by each algorithm. For testing/debuging purposes only. """ print('Tarjan class:', [sorted(component) for component in tarjan.Tarjan(cm_g).get_scc()]) print() print('Tarjan func: ', [sorted(component) for component in tarjan.strongly_connected_components(cm_g)]) print() print('Gabow class:', [sorted(component) for component in gabow.Gabow(cm_g).get_scc()]) print() print('Gabow func: ', [sorted(component) for component in gabow.strongly_connected_components(cm_g)]) print() print('Tarjan NX: ', [sorted(component) for component in nx.strongly_connected_components(nx_g)]) print() print('Kosaraju NX:', [sorted(component) for component in nx.kosaraju_strongly_connected_components(nx_g)])
def degvssizeAvg(data): degreedict = {} for deg in range(1, 100, 5): subdata = copy.deepcopy(data[('NL', 'corr')]) threshold = determineThreshold(subdata, deg) print "degree: " + str(deg) + " threshold: " + str(threshold) myList = createGraphs(subdata, threshold) avg = 0 for graph in myList: listoflists = nx.kosaraju_strongly_connected_components(graph) avg += len(listoflists[0]) avg = float(avg/len(myList)) degreedict[deg] = avg plt.plot(degreedict.keys(), degreedict.values(), 'bo') plt.show()
def degvssizeAvg(data): degreedict = {} for deg in range(1, 100, 5): subdata = copy.deepcopy(data[('NL', 'corr')]) threshold = determineThreshold(subdata, deg) print "degree: " + str(deg) + " threshold: " + str(threshold) myList = createGraphs(subdata, threshold) avg = 0 for graph in myList: listoflists = nx.kosaraju_strongly_connected_components(graph) avg += len(listoflists[0]) avg = float(avg / len(myList)) degreedict[deg] = avg plt.plot(degreedict.keys(), degreedict.values(), 'bo') plt.show()
def stronglyConnectedSubgraphs(self) -> list[Graph[V, E]]: """ Gets strongly connected subgraphs of graph. Returns ------- list[Graph[V, E]] Graph strongly connected components """ subgraphs: list[Graph[V, E]] = list() for nodeSet in nx.kosaraju_strongly_connected_components(self.graph): subgraph: Graph[V, E] = Graph(is_directed=self.isDirected, is_weighted=self.isWeighted) subgraph.addNodes(nodeSet) for edge in self.graph.edges: if edge[0] in nodeSet and edge[1] in nodeSet: subgraph.addEdge(edge[0], edge[1]) subgraphs.append(subgraph) return subgraphs
def directed(self): D = self.Initial_Laplacian(self.size, self.prob) for i in range(self.size): if D[i][i] == 1.: D[i][i] = 0. """ Until here, we have the adjacency matrix of arandom directed graph, but we are not sure whether it is stringly connected or not! """ graph = nx.from_numpy_matrix(D, create_using=nx.DiGraph) largest = max(nx.kosaraju_strongly_connected_components(graph), key=len) adj = np.zeros((len(largest), len(largest))) v = 0 w = 0 for i in largest: for j in largest: adj[v][w] = D[i][j] w +=1 w = 0 v +=1 return adj
def topological_order_value_iteration(P, states, actions, gamma, eps, max_iteration): ''' A function that performs topological value iteration on the MDP input. INPUT: - P the transition table P[s][a] == [(probability, nextstate, reward, done), ...] - states, the discrete sets of states in the environment - actions, the discrete set of actions in the environment - gamma, the discount factor for rewards OUTPUT: value function values for discrete states ''' g, P = build_graph(P, actions, states) V = defaultdict(int) # returned in reversed topological order comps = list(nx.kosaraju_strongly_connected_components(g)) comps.reverse() for comp in comps: print("component is: {}".format(comp)) # update the VI values when you add each component V.update(hacky_value_iteration(P, comp, actions, V, gamma, eps, max_iteration)) return V
#!/usr/bin/env python2 import networkx as nx import graph, tarjan, gabow if __name__ == '__main__': for i in range(3): # generate random graph and convert to custom representation nx_graph = nx.gnm_random_graph(15, 25, directed=True) custom_graph = graph.nx2custom(nx_graph) # get strong connected components print "Strongly connected components by Tarjan's algorithm:" print [ sorted(component) for component in tarjan.strongly_connected_components(custom_graph) ] print print "Strongly connected components by Gabow's algorithm:" print [ sorted(component) for component in gabow.strongly_connected_components(custom_graph) ] print print "Strongly connected components by Tarjan's networkx library algorithm:" print [ sorted(component) for component in nx.strongly_connected_components(nx_graph) ] print print "Strongly connected components by Kosaraju's networkx library algorithm:" print [ sorted(component) for component in nx.kosaraju_strongly_connected_components(nx_graph) ] print '-----------------------------------------------------------------------'
def test_Expo_directed_2(self): C = Exponential(10).directed() CC = nx.from_numpy_matrix(C, create_using=nx.DiGraph) lenC = len(max(nx.kosaraju_strongly_connected_components(CC), key=len)) self.assertEqual(lenC, C.shape[0])
print("nx: ", f) start = time() algo.shortest_path(1, 2) print(f'shortest_path-Python: {time() - start}') print("algo: ", algo.shortest_path(1, 2)) """---------------connected components compare---------------""" print("test 1-SCC") g = compare_nx.load_from_json('../data/G_10_80_0.json') algo = GraphAlgo() algo.load_from_json('../data/G_10_80_0.json') start = time() f = nx.kosaraju_strongly_connected_components(g) print(f'scc-nx: {time() - start}') start = time() algo.connected_components() print(f'scc-Python: {time() - start}') print("test 2-SCC") g = compare_nx.load_from_json('../data/G_100_800_0.json') algo = GraphAlgo() algo.load_from_json('../data/G_100_800_0.json') start = time() f = nx.kosaraju_strongly_connected_components(g) print(f'scc-nx: {time() - start}')
def run_simulation(): nx_results = [ ] # contains the result (in sec) of all the functions in networkx (Short|Component|Components) py_results = [ ] # contains the result (in sec) of all the functions in python (Short|Component|Components) # contains the result (in sec) of all the functions in java (Short|Component|Components) java_results = [ 0.0024046, 0.0020393, 0.0286995, 0.3990609, 0.5003517, 0.2987889, 0.0001906, 0.000615, 0.0005584, 0.0255793, 0.0330737, 0.0009482, 0.0001255, 0.00016747, 0.0255405, 0.2244528, 0.757112, 0.9485512 ] """-------------------- Shortest_path comparison --------------------""" json_graph = [ '../data/G_10_80_1.json', '../data/G_100_800_1.json', '../data/G_1000_8000_1.json', '../data/G_10000_80000_1.json', '../data/G_20000_160000_1.json', '../data/G_30000_240000_1.json' ] i = 1 for f in json_graph: print('----- test', i, ': Shortest_path comparison -----') i = i + 1 graph_nx = compare_nx.load_from_json(f) graph_algo = GraphAlgo() graph_algo.load_from_json(f) time_start = time.time() src = int(uniform(0, graph_algo.graph.v_size())) dest = int(uniform(0, graph_algo.graph.v_size())) list_nx = nx.shortest_path(graph_nx, src, dest, weight='weight') time_end = time.time() delta = time_end - time_start nx_results.append(delta) print('Time_nx:', delta) print('graph_nx: ', list_nx) time_start = time.time() graph_algo.shortest_path(src, dest) time_end = time.time() delta = time_end - time_start py_results.append(delta) print('Time_python:', delta) print('graph_algo:', graph_algo.shortest_path(src, dest), '\n') """-------------------- Connected_component comparison --------------------""" i = 1 for f in json_graph: print('----- test', i, ': Connected_component (Id_scc) -----') i = i + 1 graph_algo = GraphAlgo() graph_algo.load_from_json(f) time_start = time.time() random = int(uniform(0, graph_algo.graph.v_size())) component_list = graph_algo.connected_component(random) time_end = time.time() delta = time_end - time_start py_results.append(delta) # print("component_list:", component_list) print('Time_python:', delta, '\n') nx_results.append( 0) # Connected_component does not exist in nx -> always zero """-------------------- Connected_components comparison --------------------""" i = 1 for f in json_graph: print('----- test', i, ': Connected_componentS (ALL_scc) -----') i = i + 1 graph_nx = compare_nx.load_from_json(f) graph_algo = GraphAlgo() graph_algo.load_from_json(f) time_start = time.time() list_nx = nx.kosaraju_strongly_connected_components(graph_nx) time_end = time.time() delta = time_end - time_start nx_results.append(delta) print('Time_nx:', delta) time_start = time.time() graph_algo.connected_components() time_end = time.time() delta = time_end - time_start py_results.append(delta) print('Time_python:', delta, '\n') # print('----- results -----') # print("nx_results:", nx_results) # print("py_results:", py_results) # print("java_results:", java_results) return nx_results, py_results, java_results
def graph_check(graph_matrix, size): graph = nx.from_numpy_matrix(graph_matrix, create_using=nx.DiGraph) largest = max(nx.kosaraju_strongly_connected_components(graph), key=len) assert size == len(largest)
def compute_SCC_graphs(p): graph = nx.DiGraph() t_triples, t_cardinality = hdt.search_triples("", p, "") print("amount of triples: ", t_cardinality) for (l, p, r) in t_triples: graph.add_edge(l, r) # compute SCC start = time.time() mydict = {} for n in graph.nodes: collect_succssor = [] for s in graph.successors(n): collect_succssor.append(s) mydict[n] = collect_succssor sccs = tarjan(mydict) filter_scc = [x for x in sccs if len(x) > 1] # compute the counter for ths filtered SCC ct = Counter() for f in filter_scc: ct[len(f)] += 1 print('SCC info by tarjan : ', ct) end = time.time() hours, rem = divmod(end - start, 3600) minutes, seconds = divmod(rem, 60) print("Time taken Tarjan: {:0>2}:{:0>2}:{:05.2f}".format( int(hours), int(minutes), seconds)) start = time.time() nx_sccs = nx.strongly_connected_components(graph) filter_nx_sccs = [x for x in nx_sccs if len(x) > 1] nx_ct = Counter() for f in filter_nx_sccs: nx_ct[len(f)] += 1 print('SCC info by original nx : ', nx_ct) end = time.time() hours, rem = divmod(end - start, 3600) minutes, seconds = divmod(rem, 60) print("Time taken original: {:0>2}:{:0>2}:{:05.2f}".format( int(hours), int(minutes), seconds)) start = time.time() nx_sccs = nx.kosaraju_strongly_connected_components(graph) filter_nx_sccs = [x for x in nx_sccs if len(x) > 1] nx_ct = Counter() for f in filter_nx_sccs: nx_ct[len(f)] += 1 print('SCC info by original nx : ', nx_ct) end = time.time() hours, rem = divmod(end - start, 3600) minutes, seconds = divmod(rem, 60) print("Time taken kosaraju: {:0>2}:{:0>2}:{:05.2f}".format( int(hours), int(minutes), seconds)) # obtain the corresponding scc graphs scc_graphs = [] for s in filter_scc: g = graph.subgraph(s).copy() scc_graphs.append(g) return filter_scc, scc_graphs