def test_complete_graph(self): G = nx.complete_graph(4) p = nx.builtin.voterank(G) assert p == [0, 1, 2] G = nx.complete_graph(5) p = nx.builtin.voterank(G) assert p == [0, 1, 2, 3]
def test_zero_personalization_vector(self): G = nx.complete_graph(4) personalize = {0: 0, 1: 0, 2: 0, 3: 0} pytest.raises(ZeroDivisionError, nx.builtin.pagerank, G, personalization=personalize)
def test_hamiltonian_path(self): from itertools import permutations G = nx.complete_graph(4) paths = [list(p) for p in hamiltonian_path(G, 0)] exact = [[0] + list(p) for p in permutations([1, 2, 3], 3)] assert sorted(paths) == sorted(exact)
def test_normalized_K5(self): """Edge betweenness centrality: K5""" G = nx.complete_graph(5) b = nx.edge_betweenness_centrality(G, weight=None, normalized=True) b_answer = dict.fromkeys(G.edges(), 1 / 10) for n in sorted(G.edges()): assert almost_equal(b[n], b_answer[n])
def test_K5(self): """Betweenness centrality: K5""" G = nx.complete_graph(5) b = nx.builtin.betweenness_centrality(G, weight=None, normalized=False) b_answer = {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0} for n in sorted(G): assert almost_equal(b[n], b_answer[n])
def test_selfloops(graph_type): G = nx.complete_graph(3, create_using=graph_type) G.add_edge(0, 0) assert nodes_equal(nx.nodes_with_selfloops(G), [0]) assert edges_equal(nx.selfloop_edges(G), [(0, 0)]) assert edges_equal(nx.selfloop_edges(G, data=True), [(0, 0, {})]) assert nx.number_of_selfloops(G) == 1
def watts_strogatz_graph(n, k, p, seed=None): if k > n: raise nx.NetworkXError("k>n, choose smaller k or larger n") # If k == n, the graph is complete not Watts-Strogatz if k == n: return nx.complete_graph(n) G = nx.Graph() nodes = list(range(n)) # nodes are labeled 0 to n-1 # connect each node to k/2 neighbors for j in range(1, k // 2 + 1): targets = nodes[j:] + nodes[0:j] # first j nodes are now last in list G.add_edges_from(zip(nodes, targets)) # rewire edges from each node # loop over all nodes in order (label) and neighbors in order (distance) # no self loops or multiple edges allowed for j in range(1, k // 2 + 1): # outer loop is neighbors targets = nodes[j:] + nodes[0:j] # first j nodes are now last in list # inner loop in node order for u, v in zip(nodes, targets): if seed.random() < p: w = seed.choice(nodes) # Enforce no self-loops or multiple edges while w == u or G.has_edge(u, w): w = seed.choice(nodes) if G.degree(u) >= n - 1: break # skip this rewiring else: G.remove_edge(u, v) G.add_edge(u, w) return G
def newman_watts_strogatz_graph(n, k, p, seed=None): if k > n: raise nx.NetworkXError("k>=n, choose smaller k or larger n") # If k == n the graph return is a complete graph if k == n: return nx.complete_graph(n) G = empty_graph(n) nlist = list(G.nodes()) fromv = nlist # connect the k/2 neighbors for j in range(1, k // 2 + 1): tov = fromv[j:] + fromv[0:j] # the first j are now last for i, value in enumerate(fromv): G.add_edge(value, tov[i]) # for each edge u-v, with probability p, randomly select existing # node w and add new edge u-w e = list(G.edges()) for (u, v) in e: if seed.random() < p: w = seed.choice(nlist) # no self-loops and reject if edge u-w exists # is that the correct NWS model? while w == u or G.has_edge(u, w): w = seed.choice(nlist) if G.degree(u) >= n - 1: break # skip this rewiring else: G.add_edge(u, w) return G
def test_selfloops_removal(graph_type): G = nx.complete_graph(3, create_using=graph_type) G.add_edge(0, 0) G.remove_edges_from(nx.selfloop_edges(G, keys=True)) G.add_edge(0, 0) G.remove_edges_from(nx.selfloop_edges(G, data=True)) G.add_edge(0, 0) G.remove_edges_from(nx.selfloop_edges(G, keys=True, data=True))
def test_is_at_free(self): is_at_free = nx.asteroidal.is_at_free cycle = nx.cycle_graph(6) assert not is_at_free(cycle) path = nx.path_graph(6) assert is_at_free(path) small_graph = nx.complete_graph(2) assert is_at_free(small_graph) petersen = nx.petersen_graph() assert not is_at_free(petersen) clique = nx.complete_graph(6) assert is_at_free(clique)
def test_K5(self): """Katz centrality: K5""" G = nx.complete_graph(5) alpha = 0.1 b = nx.builtin.katz_centrality(G, alpha) v = math.sqrt(1 / 5.0) b_answer = dict.fromkeys(G, v) for n in sorted(G): assert almost_equal(b[n], b_answer[n])
def test_hamiltonian__edge_path(self): from itertools import permutations G = nx.complete_graph(4) paths = hamiltonian_edge_path(G, 0) exact = [ list(pairwise([0] + list(p))) for p in permutations([1, 2, 3], 3) ] assert sorted(exact) == [p for p in sorted(paths)]
def test_complete_graph(self): K10 = nx.complete_graph(10) assert sorted(nx.builtin.node_boundary(K10, [0, 1, 2])) == [3, 4, 5, 6, 7, 8, 9] assert sorted(nx.builtin.node_boundary(K10, [3, 4, 5])) == [0, 1, 2, 6, 7, 8, 9] assert sorted(nx.builtin.node_boundary(K10, [2, 3, 4, 5, 6])) == [0, 1, 7, 8, 9] if os.environ.get("DEPLOYMENT", None) == "standalone": assert nx.builtin.node_boundary(K10, [0, 1, 2], [2, 3, 4]) == {3, 4} else: # num_workers=2 assert nx.builtin.node_boundary(K10, [0, 1, 2], [2, 3, 4]) == {4, 3}
def test_selfloop_edges_attr(graph_type): G = nx.complete_graph(3, create_using=graph_type) G.add_edge(0, 0) G.add_edge(1, 1, weight=2) assert edges_equal(nx.selfloop_edges(G, data=True), [(0, 0, {}), (1, 1, { "weight": 2 })]) assert edges_equal(nx.selfloop_edges(G, data="weight"), [(0, 0, None), (1, 1, 2)])
def test_all_simple_edge_paths_cutoff(self): G = nx.complete_graph(4) paths = nx.builtin.all_simple_edge_paths(G, 0, 1, cutoff=1) assert {tuple(p) for p in paths} == {((0, 1), )} paths = nx.builtin.all_simple_edge_paths(G, 0, 1, cutoff=2) assert {tuple(p) for p in paths} == { ((0, 1), ), ((0, 2), (2, 1)), ((0, 3), (3, 1)), }
def test_personalization(self): G = nx.complete_graph(4) personalize = {0: 1, 1: 1, 2: 4, 3: 4} answer = { 0: 0.23246732615667579, 1: 0.23246732615667579, 2: 0.267532673843324, 3: 0.2675326738433241, } p = nx.builtin.pagerank(G, alpha=0.85, personalization=personalize) for n in G: assert almost_equal(p[n], answer[n], places=4)
def test_K5(self): """Weighted betweenness centrality: K5""" G = nx.complete_graph(5) for e in G.edges: G.edges[e]["weight"] = 1 G[1][2]["weight"] = 10 b = nx.builtin.betweenness_centrality(G, weight="weight", normalized=False) b_answer = {0: 0.333, 1: 0.0, 2: 0.0, 3: 0.333, 4: 0.333} for n in sorted(G): assert almost_equal(b[n], b_answer[n], 3)
def test_incomplete_personalization(self): G = nx.complete_graph(4) personalize = {3: 1} answer = { 0: 0.22077931820379187, 1: 0.22077931820379187, 2: 0.22077931820379187, 3: 0.3376620453886241, } p = nx.builtin.pagerank(G, alpha=0.85, personalization=personalize) for n in G: assert almost_equal(p[n], answer[n], places=4)
def test_K5(self): """Eigenvector centrality: K5""" G = nx.complete_graph(5) b = nx.builtin.eigenvector_centrality(G) v = math.sqrt(1 / 5.0) b_answer = dict.fromkeys(G, v) for n in sorted(G): assert almost_equal(b[n], b_answer[n]) nstart = dict([(n, 1) for n in G]) b = nx.eigenvector_centrality_numpy(G) for n in sorted(G): assert almost_equal(b[n], b_answer[n], places=3)
def test_k5(self): G = nx.complete_graph(5) assert list(nx.builtin.clustering(G).values()) == [1, 1, 1, 1, 1] assert nx.builtin.average_clustering(G) == 1 G.remove_edge(1, 2) assert list(dict(sorted(nx.builtin.clustering(G).items())).values()) == [ 5.0 / 6.0, 1.0, 1.0, 5.0 / 6.0, 5.0 / 6.0, ] assert nx.builtin.clustering(G, [1, 4]) == {1: 1.0, 4: 0.83333333333333337}
def test_K5_unweighted(self): """Katz centrality: K5""" G = nx.complete_graph(5) alpha = 0.1 b = nx.katz_centrality(G, alpha, weight=None) v = math.sqrt(1 / 5.0) b_answer = dict.fromkeys(G, v) for n in sorted(G): assert almost_equal(b[n], b_answer[n]) nstart = dict([(n, 1) for n in G]) b = nx.eigenvector_centrality_numpy(G, weight=None) for n in sorted(G): assert almost_equal(b[n], b_answer[n], places=3)
def test_k5(self): G = nx.complete_graph(5) assert list(nx.builtin.triangles(G).values()) == [6, 6, 6, 6, 6] assert sum(nx.builtin.triangles(G).values()) / 3.0 == 10 assert nx.builtin.triangles(G, 1) == 6 G.remove_edge(1, 2) assert list(dict(sorted(nx.builtin.triangles(G).items())).values()) == [ 5, 3, 3, 5, 5, ] assert nx.builtin.triangles(G, 1) == 3
def test_K5_endpoints(self): """Betweenness centrality: K5 endpoints""" G = nx.complete_graph(5) b = nx.builtin.betweenness_centrality(G, weight=None, normalized=False, endpoints=True) b_answer = {0: 4.0, 1: 4.0, 2: 4.0, 3: 4.0, 4: 4.0} for n in sorted(G): assert almost_equal(b[n], b_answer[n]) # normalized = True case b = nx.builtin.betweenness_centrality(G, weight=None, normalized=True, endpoints=True) b_answer = {0: 0.4, 1: 0.4, 2: 0.4, 3: 0.4, 4: 0.4} for n in sorted(G): assert almost_equal(b[n], b_answer[n])
def test_complete_graph(self): K10 = nx.complete_graph(10) def ilen(iterable): return sum(1 for i in iterable) assert ilen(nx.builtin.edge_boundary(K10, [0, 1, 2])) == 21 assert ilen(nx.builtin.edge_boundary(K10, [3, 4, 5, 6])) == 24 assert ilen(nx.builtin.edge_boundary(K10, [2, 3, 4, 5, 6])) == 25 assert ilen(nx.builtin.edge_boundary(K10, [7, 8, 9])) == 21 assert_edges_equal( nx.builtin.edge_boundary(K10, [3, 4, 5], [8, 9]), [(3, 8), (3, 9), (4, 8), (4, 9), (5, 8), (5, 9)], ) assert_edges_equal( nx.builtin.edge_boundary(K10, [0, 1, 2], [2, 3, 4]), [(0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4)], )
def setup_class(cls): cls.K = nx.krackhardt_kite_graph() cls.P3 = nx.path_graph(3) cls.P4 = nx.path_graph(4) cls.K5 = nx.complete_graph(5) cls.C4 = nx.cycle_graph(4) cls.T = nx.balanced_tree(r=2, h=2) cls.Gb = nx.Graph() cls.Gb.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (4, 5), (3, 5)]) F = nx.florentine_families_graph() cls.F = F cls.LM = nx.les_miserables_graph() # Create random undirected, unweighted graph for testing incremental version cls.undirected_G = nx.fast_gnp_random_graph(n=100, p=0.6, seed=123) cls.undirected_G_cc = nx.builtin.closeness_centrality(cls.undirected_G)
def test_selfloops(): graphs = [nx.Graph(), nx.DiGraph()] for graph in graphs: G = nx.complete_graph(3, create_using=graph) G.add_edge(0, 0) assert_nodes_equal(nx.nodes_with_selfloops(G), [0]) assert_edges_equal(nx.selfloop_edges(G), [(0, 0)]) assert_edges_equal(nx.selfloop_edges(G, data=True), [(0, 0, {})]) assert nx.number_of_selfloops(G) == 1 # test selfloop attr G.add_edge(1, 1, weight=2) assert_edges_equal(nx.selfloop_edges(G, data=True), [(0, 0, {}), (1, 1, { "weight": 2 })]) assert_edges_equal(nx.selfloop_edges(G, data="weight"), [(0, 0, None), (1, 1, 2)]) # test removing selfloops behavior vis-a-vis altering a dict while iterating G.add_edge(0, 0) G.remove_edges_from(nx.selfloop_edges(G)) if G.is_multigraph(): G.add_edge(0, 0) pytest.raises(RuntimeError, G.remove_edges_from, nx.selfloop_edges(G, keys=True)) G.add_edge(0, 0) pytest.raises(TypeError, G.remove_edges_from, nx.selfloop_edges(G, data=True)) G.add_edge(0, 0) pytest.raises( RuntimeError, G.remove_edges_from, nx.selfloop_edges(G, data=True, keys=True), ) else: G.add_edge(0, 0) G.remove_edges_from(nx.selfloop_edges(G, keys=True)) G.add_edge(0, 0) G.remove_edges_from(nx.selfloop_edges(G, data=True)) G.add_edge(0, 0) G.remove_edges_from(nx.selfloop_edges(G, keys=True, data=True))
def test_k5(self): G = nx.complete_graph(5, create_using=nx.DiGraph()) assert list(nx.builtin.clustering(G, weight="weight").values()) == [ 1, 1, 1, 1, 1, ] assert nx.builtin.average_clustering(G, weight="weight") == 1 G.remove_edge(1, 2) assert G.number_of_nodes() == 5 assert list( dict(sorted(nx.builtin.clustering(G, weight="weight").items())).values() ) == [ 11.0 / 12.0, 1.0, 1.0, 11.0 / 12.0, 11.0 / 12.0, ] assert nx.builtin.clustering(G, [1, 4], weight="weight") == { 1: 1.0, 4: 11.0 / 12.0, } G.remove_edge(2, 1) assert list( dict(sorted(nx.builtin.clustering(G, weight="weight").items())).values() ) == [ 5.0 / 6.0, 1.0, 1.0, 5.0 / 6.0, 5.0 / 6.0, ] assert nx.builtin.clustering(G, [1, 4], weight="weight") == { 1: 1.0, 4: 0.83333333333333337, }
def setup_method(self): # self.K = nx.krackhardt_kite_graph() self.P3 = nx.path_graph(3) self.K5 = nx.complete_graph(5) # F = nx.Graph() # Florentine families # F.add_edge('Acciaiuoli', 'Medici') # F.add_edge('Castellani', 'Peruzzi') # F.add_edge('Castellani', 'Strozzi') # F.add_edge('Castellani', 'Barbadori') # F.add_edge('Medici', 'Barbadori') # F.add_edge('Medici', 'Ridolfi') # F.add_edge('Medici', 'Tornabuoni') # F.add_edge('Medici', 'Albizzi') # F.add_edge('Medici', 'Salviati') # F.add_edge('Salviati', 'Pazzi') # F.add_edge('Peruzzi', 'Strozzi') # F.add_edge('Peruzzi', 'Bischeri') # F.add_edge('Strozzi', 'Ridolfi') # F.add_edge('Strozzi', 'Bischeri') # F.add_edge('Ridolfi', 'Tornabuoni') # F.add_edge('Tornabuoni', 'Guadagni') # F.add_edge('Albizzi', 'Ginori') # F.add_edge('Albizzi', 'Guadagni') # F.add_edge('Bischeri', 'Guadagni') # F.add_edge('Guadagni', 'Lamberteschi') # self.F = F G = nx.DiGraph() G.add_edge(0, 5) G.add_edge(1, 5) G.add_edge(2, 5) G.add_edge(3, 5) G.add_edge(4, 5) G.add_edge(5, 6) G.add_edge(5, 7) G.add_edge(5, 8) self.G = G
def test_k5(self): G = nx.complete_graph(5) assert nx.generalized_degree(G, 0) == {3: 4} G.remove_edge(0, 1) assert nx.generalized_degree(G, 0) == {2: 3}
def test_k5(self): G = nx.complete_graph(5) assert list(nx.square_clustering(G).values()) == [1, 1, 1, 1, 1]