def test_complete_graphs(): for n in range(5, 25, 5): G = nx.complete_graph(n) assert_equal(n - 1, nx.node_connectivity(G)) assert_equal(n - 1, nx.node_connectivity(G.to_directed())) assert_equal(n - 1, nx.edge_connectivity(G)) assert_equal(n - 1, nx.edge_connectivity(G.to_directed()))
def cohesiveness(g: nx.Graph, v): before = nx.node_connectivity(g) copy = g.copy() copy.remove_node(v) after = nx.node_connectivity(copy) # print(f"before: {before} after: {after}, cohesiveness of node {v}: {before - after}") return before - after
def test_complete_graphs(): for n in range(5, 25, 5): G = nx.complete_graph(n) assert_equal(n-1, nx.node_connectivity(G)) assert_equal(n-1, nx.node_connectivity(G.to_directed())) assert_equal(n-1, nx.edge_connectivity(G)) assert_equal(n-1, nx.edge_connectivity(G.to_directed()))
def test_brandes_erlebach(): # Figure 1 chapter 7: Connectivity # http://www.informatik.uni-augsburg.de/thi/personen/kammer/Graph_Connectivity.pdf G = nx.Graph() G.add_edges_from([(1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 6), (3, 4), (3, 6), (4, 6), (4, 7), (5, 7), (6, 8), (6, 9), (7, 8), (7, 10), (8, 11), (9, 10), (9, 11), (10, 11)]) for flow_func in flow_funcs: kwargs = dict(flow_func=flow_func) assert_equal(3, local_edge_connectivity(G, 1, 11, **kwargs), msg=msg.format(flow_func.__name__)) assert_equal(3, nx.edge_connectivity(G, 1, 11, **kwargs), msg=msg.format(flow_func.__name__)) assert_equal(2, local_node_connectivity(G, 1, 11, **kwargs), msg=msg.format(flow_func.__name__)) assert_equal(2, nx.node_connectivity(G, 1, 11, **kwargs), msg=msg.format(flow_func.__name__)) assert_equal( 2, nx.edge_connectivity(G, **kwargs), # node 5 has degree 2 msg=msg.format(flow_func.__name__)) assert_equal(2, nx.node_connectivity(G, **kwargs), msg=msg.format(flow_func.__name__))
def test_all_pairs_connectivity(self, nodelist=[0, 1, 2, 3]): G = nx.Graph() nodes = [0, 1, 2, 3] G.add_path(nodes) A = numpy.zeros((4, 4), dtype=int) for u, v in itertools.combinations(nodes, 2): A[u][v] = nx.node_connectivity(G, u, v) A[v][u] = nx.node_connectivity(G, u, v) C = nx.all_pairs_node_connectivity_matrix(G) assert_equal(A, C)
def print_robustness(): #What is the smallest number of nodes that can be removed from this graph in order to disconnect it? # 1) whole graph: nx.node_connectivity(G) #1 - too small, When higher - it is good nx.minimum_node_cut(G) #{'Чкаловская'} nx.edge_connectivity(G) # 1 nx.minimum_edge_cut(G) #{('Марьино', 'Чкаловская')} # 2) concrete path nx.node_connectivity(G, 'Киевская', 'Чкаловская') #2 - better nx.minimum_node_cut(G, 'Киевская', 'Чкаловская') #{'Курская', 'Сретенский бульвар'} nx.edge_connectivity(G, 'Киевская', 'Чкаловская') #2 - better nx.minimum_edge_cut(G, 'Киевская', 'Чкаловская') #{('Курская', 'Чкаловская'), ('Сретенский бульвар', 'Чкаловская')}
def calculate_node_connectivity(graph, graph_type): if graph_type == 'subscription': user_nodes = set(n for n, d in graph.nodes(data=True) if d.get('bipartite') == 0) results = [ nx.node_connectivity(graph, s=start, t=end) for start, end in combinations(user_nodes, 2) ] return min(results) if results else 0 elif graph_type == 'mention': return nx.node_connectivity(graph)
def test_brandes_erlebach(): # Figure 1 chapter 7: Connectivity # http://www.informatik.uni-augsburg.de/thi/personen/kammer/Graph_Connectivity.pdf G = nx.Graph() G.add_edges_from([(1,2),(1,3),(1,4),(1,5),(2,3),(2,6),(3,4), (3,6),(4,6),(4,7),(5,7),(6,8),(6,9),(7,8), (7,10),(8,11),(9,10),(9,11),(10,11)]) assert_equal(3,nx.local_edge_connectivity(G,1,11)) assert_equal(3,nx.edge_connectivity(G,1,11)) assert_equal(2,nx.local_node_connectivity(G,1,11)) assert_equal(2,nx.node_connectivity(G,1,11)) assert_equal(2,nx.edge_connectivity(G)) # node 5 has degree 2 assert_equal(2,nx.node_connectivity(G))
def test_complete_graphs(): for n in range(5, 20, 5): for flow_func in flow_funcs: G = nx.complete_graph(n) errmsg = f"Assertion failed in function: {flow_func.__name__}" assert n - 1 == nx.node_connectivity(G, flow_func=flow_func), errmsg assert n - 1 == nx.node_connectivity(G.to_directed(), flow_func=flow_func), errmsg assert n - 1 == nx.edge_connectivity(G, flow_func=flow_func), errmsg assert n - 1 == nx.edge_connectivity(G.to_directed(), flow_func=flow_func), errmsg
def test_brandes_erlebach(): # Figure 1 chapter 7: Connectivity # http://www.informatik.uni-augsburg.de/thi/personen/kammer/Graph_Connectivity.pdf G = nx.Graph() G.add_edges_from([(1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 6), (3, 4), (3, 6), (4, 6), (4, 7), (5, 7), (6, 8), (6, 9), (7, 8), (7, 10), (8, 11), (9, 10), (9, 11), (10, 11)]) assert_equal(3, nx.local_edge_connectivity(G, 1, 11)) assert_equal(3, nx.edge_connectivity(G, 1, 11)) assert_equal(2, nx.local_node_connectivity(G, 1, 11)) assert_equal(2, nx.node_connectivity(G, 1, 11)) assert_equal(2, nx.edge_connectivity(G)) # node 5 has degree 2 assert_equal(2, nx.node_connectivity(G))
def test_complete_graphs(): for n in range(5, 20, 5): for flow_func in flow_funcs: G = nx.complete_graph(n) assert_equal(n-1, nx.node_connectivity(G, flow_func=flow_func), msg=msg.format(flow_func.__name__)) assert_equal(n-1, nx.node_connectivity(G.to_directed(), flow_func=flow_func), msg=msg.format(flow_func.__name__)) assert_equal(n-1, nx.edge_connectivity(G, flow_func=flow_func), msg=msg.format(flow_func.__name__)) assert_equal(n-1, nx.edge_connectivity(G.to_directed(), flow_func=flow_func), msg=msg.format(flow_func.__name__))
def test_articulation_points(): Ggen = _generate_no_biconnected() for flow_func in flow_funcs: for i in range(3): G = next(Ggen) errmsg = f"Assertion failed in function: {flow_func.__name__}" assert nx.node_connectivity(G, flow_func=flow_func) == 1, errmsg
def test_empty_graphs(): for k in range(5, 25, 5): G = nx.empty_graph(k) for flow_func in flow_funcs: errmsg = f"Assertion failed in function: {flow_func.__name__}" assert 0 == nx.node_connectivity(G, flow_func=flow_func), errmsg assert 0 == nx.edge_connectivity(G, flow_func=flow_func), errmsg
def updateGraphStats(self, graph): origgraph = graph if nx.is_connected(graph): random = 0 else: connectedcomp = nx.connected_component_subgraphs(graph) graph = max(connectedcomp) if len(graph) > 1: pathlength = nx.average_shortest_path_length(graph) else: pathlength = 0 # print graph.nodes(), len(graph), nx.is_connected(graph) stats = { "radius": nx.radius(graph), "density": nx.density(graph), "nodecount": len(graph.nodes()), "center": nx.center(graph), "avgcluscoeff": nx.average_clustering(graph), "nodeconnectivity": nx.node_connectivity(graph), "components": nx.number_connected_components(graph), "avgpathlength": pathlength } # print "updated graph stats", stats return stats
def test_node_cutset_random_graphs(): for i in range(5): G = nx.fast_gnp_random_graph(50,0.2) cutset = nx.minimum_node_cut(G) assert_equal(nx.node_connectivity(G), len(cutset)) G.remove_nodes_from(cutset) assert_false(nx.is_connected(G))
def k_connectedness(G): # returns (is_conn,k_connectivity) where is_conn (boolean) says if the network is fully connected, # if is_conn = False, then k_connectivity is the k value for the GIANT COMPONENT, not the whole thing, whole thing is obviously 0 because it's not connected. is_conn = is_connected(G) # is_conn is boolean if is_conn == True: k_connectivity = nx.node_connectivity(G) return (is_conn, k_connectivity) else: Gcc = sorted(nx.connected_component_subgraphs(G), key=len, reverse=True) G0 = Gcc[0] # Got the giant component k_connectivity = nx.node_connectivity(G0) return (is_conn, k_connectivity)
def q12(G_sc): src_nodes = q10(G_sc) dst_node = execute_q11()[0] return sum([ nx.node_connectivity(G_sc, src_node, dst_node) for src_node in src_nodes ])
def main(): done = [ 'dfn_58.graphml', 'colt_153.graphml', 'gts_ce_149.graphml', 'intellifiber_73.graphml', 'triangle.graphml' ] networks = ['abilene_11.graphml'] for net_file in networks: node_connectivity = {} edge_connectivity = {} graphml_network = nx.read_graphml(net_file, node_type=int) for u in graphml_network.nodes(): u_id = f'pop{u}' node_connectivity[u_id] = {} edge_connectivity[u_id] = {} for v in graphml_network.nodes(): v_id = f'pop{v}' if u_id != v_id: node_connectivity[u_id][v_id] = nx.node_connectivity( graphml_network, s=u, t=v) edge_connectivity[u_id][v_id] = nx.edge_connectivity( graphml_network, s=u, t=v) os.makedirs('connectivity/', exist_ok=True) with open(f'connectivity/{net_file}_node_con.json', 'w') as fp: json.dump(node_connectivity, fp) with open(f'connectivity/{net_file}_edge_con.json', 'w') as fp: json.dump(edge_connectivity, fp)
def test_tutte(): G = nx.tutte_graph() for flow_func in flow_funcs: assert_equal(3, nx.node_connectivity(G, flow_func=flow_func), msg=msg.format(flow_func.__name__)) assert_equal(3, nx.edge_connectivity(G, flow_func=flow_func), msg=msg.format(flow_func.__name__))
def test_graph_from_pr_2053(): G = nx.Graph() G.add_edges_from([ ("A", "B"), ("A", "D"), ("A", "F"), ("A", "G"), ("B", "C"), ("B", "D"), ("B", "G"), ("C", "D"), ("C", "E"), ("C", "Z"), ("D", "E"), ("D", "F"), ("E", "F"), ("E", "Z"), ("F", "Z"), ("G", "Z"), ]) for flow_func in flow_funcs: kwargs = dict(flow_func=flow_func) errmsg = f"Assertion failed in function: {flow_func.__name__}" # edge disjoint paths edge_paths = list(nx.edge_disjoint_paths(G, "A", "Z", **kwargs)) assert are_edge_disjoint_paths(G, edge_paths), errmsg assert nx.edge_connectivity(G, "A", "Z") == len(edge_paths), errmsg # node disjoint paths node_paths = list(nx.node_disjoint_paths(G, "A", "Z", **kwargs)) assert are_node_disjoint_paths(G, node_paths), errmsg assert nx.node_connectivity(G, "A", "Z") == len(node_paths), errmsg
def find_which_nodes_and_edges_to_remove(G, n1, n2): a = nx.node_connectivity(G, n1, n2) b = nx.minimum_node_cut(G, n1, n2) c = nx.edge_connectivity(G, n1, n2) d = nx.minimum_edge_cut(G, n1, n2) print(a, b, c, d) return (a, b, c, d)
def embed_metrics_connectivity(graph, metrics, g, namefield): connectivity = dict() print('connectivity_edge') connectivity['connectivity_edge'] = networkx.edge_connectivity(g) print('connectivity_node') connectivity['connectivity_node'] = networkx.node_connectivity(g) return connectivity
def test_petersen(): G = nx.petersen_graph() for flow_func in flow_funcs: assert 3 == nx.node_connectivity(G, flow_func=flow_func), msg.format( flow_func.__name__) assert 3 == nx.edge_connectivity(G, flow_func=flow_func), msg.format( flow_func.__name__)
def test_graph_from_pr_2053(): G = nx.Graph() G.add_edges_from([ ('A', 'B'), ('A', 'D'), ('A', 'F'), ('A', 'G'), ('B', 'C'), ('B', 'D'), ('B', 'G'), ('C', 'D'), ('C', 'E'), ('C', 'Z'), ('D', 'E'), ('D', 'F'), ('E', 'F'), ('E', 'Z'), ('F', 'Z'), ('G', 'Z')]) for flow_func in flow_funcs: kwargs = dict(flow_func=flow_func) # edge disjoint paths edge_paths = list(nx.edge_disjoint_paths(G, 'A', 'Z', **kwargs)) assert_true(are_edge_disjoint_paths(G, edge_paths), msg=msg.format(flow_func.__name__)) assert_equal( nx.edge_connectivity(G, 'A', 'Z'), len(edge_paths), msg=msg.format(flow_func.__name__), ) # node disjoint paths node_paths = list(nx.node_disjoint_paths(G, 'A', 'Z', **kwargs)) assert_true(are_node_disjoint_paths(G, node_paths), msg=msg.format(flow_func.__name__)) assert_equal( nx.node_connectivity(G, 'A', 'Z'), len(node_paths), msg=msg.format(flow_func.__name__), )
def test_octahedral(): G = nx.octahedral_graph() for flow_func in flow_funcs: assert 4 == nx.node_connectivity(G, flow_func=flow_func), msg.format( flow_func.__name__) assert 4 == nx.edge_connectivity(G, flow_func=flow_func), msg.format( flow_func.__name__)
def test_articulation_points(): Ggen = _generate_no_biconnected() for flow_func in flow_funcs: for i in range(3): G = next(Ggen) assert_equal(nx.node_connectivity(G, flow_func=flow_func), 1, msg=msg.format(flow_func.__name__))
def test_icosahedral(): G=nx.icosahedral_graph() for flow_func in flow_funcs: assert_equal(5, nx.node_connectivity(G, flow_func=flow_func), msg=msg.format(flow_func.__name__)) assert_equal(5, nx.edge_connectivity(G, flow_func=flow_func), msg=msg.format(flow_func.__name__))
def draw_graph(nodes, edges, graphs_dir, default_lang='all'): lang_graph = nx.MultiDiGraph() lang_graph.add_nodes_from(nodes) for edge in edges: if edges[edge] == 0: lang_graph.add_edge(edge[0], edge[1]) else: lang_graph.add_edge(edge[0], edge[1], weight=float(edges[edge]), label=str(edges[edge])) # print graph info in stdout # degree centrality print('-----------------\n\n') print(default_lang) print(nx.info(lang_graph)) try: # When ties are associated to some positive aspects such as friendship or collaboration, # indegree is often interpreted as a form of popularity, and outdegree as gregariousness. DC = nx.degree_centrality(lang_graph) max_dc = max(DC.values()) max_dc_list = [item for item in DC.items() if item[1] == max_dc] except ZeroDivisionError: max_dc_list = [] # https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D0%BB%D0%B5%D0%BA%D1%81%D0%BD%D1%8B%D0%B5_%D1%81%D0%B5%D1%82%D0%B8 print('maxdc', str(max_dc_list), sep=': ') # assortativity coef AC = nx.degree_assortativity_coefficient(lang_graph) print('AC', str(AC), sep=': ') # connectivity print("Слабо-связный граф: ", nx.is_weakly_connected(lang_graph)) print("количество слабосвязанных компонент: ", nx.number_weakly_connected_components(lang_graph)) print("Сильно-связный граф: ", nx.is_strongly_connected(lang_graph)) print("количество сильносвязанных компонент: ", nx.number_strongly_connected_components(lang_graph)) print("рекурсивные? компоненты: ", nx.number_attracting_components(lang_graph)) print("число вершинной связности: ", nx.node_connectivity(lang_graph)) print("число рёберной связности: ", nx.edge_connectivity(lang_graph)) # other info print("average degree connectivity: ", nx.average_degree_connectivity(lang_graph)) print("average neighbor degree: ", sorted(nx.average_neighbor_degree(lang_graph).items(), key=itemgetter(1), reverse=True)) # best for small graphs, and our graphs are pretty small print("pagerank: ", sorted(nx.pagerank_numpy(lang_graph).items(), key=itemgetter(1), reverse=True)) plt.figure(figsize=(16.0, 9.0), dpi=80) plt.axis('off') pos = graphviz_layout(lang_graph) nx.draw_networkx_edges(lang_graph, pos, alpha=0.5, arrows=True) nx.draw_networkx(lang_graph, pos, node_size=1000, font_size=12, with_labels=True, node_color='green') nx.draw_networkx_edge_labels(lang_graph, pos, edges) # saving file to draw it with dot-graphviz # changing overall graph view, default is top-bottom lang_graph.graph['graph'] = {'rankdir': 'LR'} # marking with blue nodes with maximum degree centrality for max_dc_node in max_dc_list: lang_graph.node[max_dc_node[0]]['fontcolor'] = 'blue' write_dot(lang_graph, os.path.join(graphs_dir, default_lang + '_links.dot')) # plt.show() plt.savefig(os.path.join(graphs_dir, 'python_' + default_lang + '_graph.png'), dpi=100) plt.close()
def test_get_new_maze(set_seed, iteration): # generate a few mazes and check them for consistency local_seed = random.randint(1, 2**31 - 1) * iteration maze_str = mg.get_new_maze(8, 16, nfood=15, seed=local_seed) maze = mg.str_to_maze(maze_str) height, width = maze.shape # check that the returned maze has all the pacmen for pacman in (b'0', b'1', b'2', b'3'): assert np.any(maze == pacman) # now that we now we have a pacman, check that we have it only once # and remove it by putting an empty space instead row, col = np.nonzero(maze == pacman) assert len(row) == 1 assert len(col) == 1 maze[row, col] = mg.E # check that we have in total twice nfood in the maze assert (maze == mg.F).sum() == 15 * 2 # remove the food for computing dead ends and chambers maze[maze == mg.F] = mg.E # check that the returned maze is center-mirror symmetric left_maze = np.flipud(np.fliplr(maze[:, width // 2:])) assert np.all(left_maze == maze[:, :width // 2]) # check that we don't have any dead ends # no node in the graph should have only one connection graph = mg.walls_to_graph(maze) for node, degree in graph.degree(): assert degree > 1 # now check that we don't have chambers, i.e. the connectivity of the # graph is > 1 assert nx.node_connectivity(graph) > 1
def get_graph_property(fn, i): doc = [ 'Order', 'Index', 'Mean degree', 'Number of connected components', 'Variance of degree', 'Min degree', 'Max degree', 'Radius', 'Diameter', 'Density', 'Connectivity', 'Mean eccentricity', 'Variance of eccentricity', 'Min eccentricity', 'Max eccentricity', 'Mean clustering', 'Variance of clustering', 'Min clustering', 'Max clustering' ] with open('graphproperties_%d.csv' % i, 'ab') as fout: fout.write('\t'.join(doc) + '\n') if 'sw' in fn: return if '10000' not in fn: return print 'Processing', fn with gzip.open('../graphs/' + fn) as f: jdata = json.load(f) index = jdata['index'] del jdata['index'] order = jdata['order'] del jdata['order'] mean_degree = jdata['mean_degree'] del jdata['mean_degree'] var_degree = jdata['var_degree'] del jdata['var_degree'] del jdata['meanSharedNeighbors'] G = json_graph.node_link_graph(jdata) min_degree = np.min(G.degree().values()) max_degree = np.max(G.degree().values()) ecc = nx.eccentricity(G) min_ecc = np.min(ecc.values()) max_ecc = np.max(ecc.values()) mean_ecc = np.mean(ecc.values()) var_ecc = np.var(ecc.values()) radius = min_ecc diameter = max_ecc #center = nx.center(G) #periphery = nx.periphery(G) density = nx.density(G) connectivity = nx.node_connectivity(G) clustering = nx.clustering(G) min_clust = np.min(clustering.values()) max_clust = np.max(clustering.values()) mean_clust = np.mean(clustering.values()) var_clust = np.var(clustering.values()) num_cc = nx.number_connected_components(G) row = [ order, index, mean_degree, num_cc, var_degree, min_degree, max_degree, radius, diameter, density, connectivity, mean_ecc, var_ecc, min_ecc, max_ecc, mean_clust, var_clust, min_clust, max_clust ] fout.write('\t'.join(map(str, row)) + '\n')
def test_graph_from_pr_2053(): G = nx.Graph() G.add_edges_from([ ('A', 'B'), ('A', 'D'), ('A', 'F'), ('A', 'G'), ('B', 'C'), ('B', 'D'), ('B', 'G'), ('C', 'D'), ('C', 'E'), ('C', 'Z'), ('D', 'E'), ('D', 'F'), ('E', 'F'), ('E', 'Z'), ('F', 'Z'), ('G', 'Z') ]) for flow_func in flow_funcs: kwargs = dict(flow_func=flow_func) # edge disjoint paths edge_paths = list(nx.edge_disjoint_paths(G, 'A', 'Z', **kwargs)) assert_true(are_edge_disjoint_paths(G, edge_paths), msg=msg.format(flow_func.__name__)) assert_equal( nx.edge_connectivity(G, 'A', 'Z'), len(edge_paths), msg=msg.format(flow_func.__name__), ) # node disjoint paths node_paths = list(nx.node_disjoint_paths(G, 'A', 'Z', **kwargs)) assert_true(are_node_disjoint_paths(G, node_paths), msg=msg.format(flow_func.__name__)) assert_equal( nx.node_connectivity(G, 'A', 'Z'), len(node_paths), msg=msg.format(flow_func.__name__), )
def test_node_cutset_random_graphs(): for i in range(5): G = nx.fast_gnp_random_graph(50, 0.2) cutset = nx.minimum_node_cut(G) assert_equal(nx.node_connectivity(G), len(cutset)) G.remove_nodes_from(cutset) assert_false(nx.is_connected(G))
def test_not_connected(): G = nx.Graph() nx.add_path(G, [1, 2, 3]) nx.add_path(G, [4, 5]) for flow_func in flow_funcs: assert nx.node_connectivity(G) == 0, msg.format(flow_func.__name__) assert nx.edge_connectivity(G) == 0, msg.format(flow_func.__name__)
def generate_KRegularKConnectedRandomGraph(N, k, f): # k-regular k-connected random graph (done) done = False while not done: G = nx.random_regular_graph(k, N) done = len(list(nx.connected_components(G))) == 1 and nx.node_connectivity(G) >= 2*f+1 return G
def test_empty_graphs(): for k in range(5, 25, 5): G = nx.empty_graph(k) for flow_func in flow_funcs: assert_equal(0, nx.node_connectivity(G, flow_func=flow_func), msg=msg.format(flow_func.__name__)) assert_equal(0, nx.edge_connectivity(G, flow_func=flow_func), msg=msg.format(flow_func.__name__))
def _check_connectivity(G): result = nx.k_components(G) for k, components in result.items(): if k < 3: continue for component in components: C = G.subgraph(component) assert_true(nx.node_connectivity(C) >= k)
def _check_connectivity(G, k_components): for k, components in k_components.items(): if k < 3: continue # check that k-components have node connectivity >= k. for component in components: C = G.subgraph(component) K = nx.node_connectivity(C) assert_greater_equal(K, k)
def test_not_connected(): G = nx.Graph() G.add_path([1, 2, 3]) G.add_path([4, 5]) for flow_func in flow_funcs: assert_equal(nx.node_connectivity(G), 0, msg=msg.format(flow_func.__name__)) assert_equal(nx.edge_connectivity(G), 0, msg=msg.format(flow_func.__name__))
def _check_separating_sets(G): for Gc in nx.connected_component_subgraphs(G): if len(Gc) < 3: continue for cut in nx.all_node_cuts(Gc): assert_equal(nx.node_connectivity(Gc), len(cut)) H = Gc.copy() H.remove_nodes_from(cut) assert_false(nx.is_connected(H))
def test_all_pairs_connectivity_nbunch(self): G = nx.complete_graph(5) nbunch = [0, 2, 3] A = {n: {} for n in nbunch} for u, v in itertools.combinations(nbunch, 2): A[u][v] = A[v][u] = nx.node_connectivity(G, u, v) C = nx.all_pairs_node_connectivity(G, nbunch=nbunch) assert_equal(sorted((k, sorted(v)) for k, v in A.items()), sorted((k, sorted(v)) for k, v in C.items()))
def _check_connectivity(G): result = nx.k_components(G) for k, components in result.items(): if k < 3: continue for component in components: C = G.subgraph(component) K = nx.node_connectivity(C) assert_greater_equal(K, k)
def test_white_harary_2(): # Figure 8 white and harary (2001) # # http://eclectic.ss.uci.edu/~drwhite/sm-w23.PDF G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4)) G.add_edge(0,4) # kappa <= lambda <= delta assert_equal(3, min(nx.core_number(G).values())) assert_equal(1, nx.node_connectivity(G)) assert_equal(1, nx.edge_connectivity(G))
def test_all_pairs_connectivity_nbunch_iter(self): G = nx.complete_graph(5) nbunch = [0, 2, 3] A = dict.fromkeys(nbunch, dict()) for u, v in itertools.combinations(nbunch, 2): A[u][v] = nx.node_connectivity(G, u, v) C = nx.all_pairs_node_connectivity(G, nbunch=iter(nbunch)) assert_equal(sorted((k, sorted(v)) for k, v in A.items()), sorted((k, sorted(v)) for k, v in C.items()))
def test_alternative_flow_functions(): graph_funcs = [graph_example_1, nx.davis_southern_women_graph] for graph_func in graph_funcs: G = graph_func() for flow_func in flow_funcs: for cut in nx.all_node_cuts(G, flow_func=flow_func): assert_equal(nx.node_connectivity(G), len(cut)) H = G.copy() H.remove_nodes_from(cut) assert_false(nx.is_connected(H))
def test_all_pairs_connectivity_directed(self): G = nx.DiGraph() nodes = [0, 1, 2, 3] G.add_path(nodes) A = dict.fromkeys(G, dict()) for u, v in itertools.permutations(nodes, 2): A[u][v] = nx.node_connectivity(G, u, v) C = nx.all_pairs_node_connectivity(G) assert_equal(sorted((k, sorted(v)) for k, v in A.items()), sorted((k, sorted(v)) for k, v in C.items()))
def test_all_pairs_connectivity(self): G = nx.Graph() nodes = [0, 1, 2, 3] nx.add_path(G, nodes) A = {n: {} for n in G} for u, v in itertools.combinations(nodes,2): A[u][v] = A[v][u] = nx.node_connectivity(G, u, v) C = nx.all_pairs_node_connectivity(G) assert_equal(sorted((k, sorted(v)) for k, v in A.items()), sorted((k, sorted(v)) for k, v in C.items()))
def test_node_cutset_random_graphs(): for i in range(5): G = nx.fast_gnp_random_graph(50,0.2) if not nx.is_connected(G): ccs = iter(nx.connected_components(G)) start = next(ccs)[0] G.add_edges_from( (start,c[0]) for c in ccs ) cutset = nx.minimum_node_cut(G) assert_equal(nx.node_connectivity(G), len(cutset)) G.remove_nodes_from(cutset) assert_false(nx.is_connected(G))
def create_3(nodes, edges): conn = 1 loop_count = 0 while conn < 3 and loop_count < 1000: G = nx.gnm_random_graph(nodes, edges) conn = nx.node_connectivity(G) loop_count = loop_count + 1 return G
def _check_separating_sets(G): for cc in nx.connected_components(G): if len(cc) < 3: continue Gc = G.subgraph(cc) node_conn = nx.node_connectivity(Gc) all_cuts = nx.all_node_cuts(Gc) # Only test a limited number of cut sets to reduce test time. for cut in itertools.islice(all_cuts, MAX_CUTSETS_TO_TEST): assert_equal(node_conn, len(cut)) assert_false(nx.is_connected(nx.restricted_view(G, cut, [])))
def test_alternative_flow_functions(): graphs = [nx.grid_2d_graph(4, 4), nx.cycle_graph(5)] for G in graphs: node_conn = nx.node_connectivity(G) for flow_func in flow_funcs: all_cuts = nx.all_node_cuts(G, flow_func=flow_func) # Only test a limited number of cut sets to reduce test time. for cut in itertools.islice(all_cuts, MAX_CUTSETS_TO_TEST): assert_equal(node_conn, len(cut)) assert_false(nx.is_connected(nx.restricted_view(G, cut, [])))
def test_brandes_erlebach(): # Figure 1 chapter 7: Connectivity # http://www.informatik.uni-augsburg.de/thi/personen/kammer/Graph_Connectivity.pdf G = nx.Graph() G.add_edges_from([(1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 6), (3, 4), (3, 6), (4, 6), (4, 7), (5, 7), (6, 8), (6, 9), (7, 8), (7, 10), (8, 11), (9, 10), (9, 11), (10, 11)]) for flow_func in flow_funcs: kwargs = dict(flow_func=flow_func) assert_equal(3, local_edge_connectivity(G, 1, 11, **kwargs), msg=msg.format(flow_func.__name__)) assert_equal(3, nx.edge_connectivity(G, 1, 11, **kwargs), msg=msg.format(flow_func.__name__)) assert_equal(2, local_node_connectivity(G, 1, 11, **kwargs), msg=msg.format(flow_func.__name__)) assert_equal(2, nx.node_connectivity(G, 1, 11, **kwargs), msg=msg.format(flow_func.__name__)) assert_equal(2, nx.edge_connectivity(G, **kwargs), # node 5 has degree 2 msg=msg.format(flow_func.__name__)) assert_equal(2, nx.node_connectivity(G, **kwargs), msg=msg.format(flow_func.__name__))
def test_node_cutset_random_graphs(): for flow_func in flow_funcs: for i in range(3): G = nx.fast_gnp_random_graph(50, 0.25) if not nx.is_connected(G): ccs = iter(nx.connected_components(G)) start = arbitrary_element(next(ccs)) G.add_edges_from((start, arbitrary_element(c)) for c in ccs) cutset = nx.minimum_node_cut(G, flow_func=flow_func) assert_equal(nx.node_connectivity(G), len(cutset), msg=msg.format(flow_func.__name__)) G.remove_nodes_from(cutset) assert_false(nx.is_connected(G), msg=msg.format(flow_func.__name__))
def test_white_harary_1(): # Figure 1b white and harary (2001) # # http://eclectic.ss.uci.edu/~drwhite/sm-w23.PDF # A graph with high adhesion (edge connectivity) and low cohesion # (vertex connectivity) G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4)) G.remove_node(7) for i in range(4,7): G.add_edge(0,i) G = nx.disjoint_union(G, nx.complete_graph(4)) G.remove_node(G.order()-1) for i in range(7,10): G.add_edge(0,i) assert_equal(1, nx.node_connectivity(G)) assert_equal(3, nx.edge_connectivity(G))