def test_project_weighted_jaccard(self): edges = [ ("A", "B", 2 / 5.0), ("A", "C", 1 / 2.0), ("B", "C", 1 / 5.0), ("B", "D", 1 / 5.0), ("B", "E", 2 / 6.0), ("E", "F", 1 / 3.0), ] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.overlap_weighted_projected_graph(self.G, "ABCDEF") assert_edges_equal(P.edges(), Panswer.edges()) for u, v in P.edges(): assert_equal(P[u][v]["weight"], Panswer[u][v]["weight"]) edges = [ ("A", "B", 3 / 3.0), ("A", "E", 1 / 3.0), ("A", "C", 1 / 3.0), ("A", "D", 1 / 3.0), ("B", "E", 1 / 3.0), ("B", "C", 1 / 3.0), ("B", "D", 1 / 3.0), ("C", "D", 1 / 1.0), ] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.overlap_weighted_projected_graph(self.N, "ABCDE") assert_edges_equal(P.edges(), Panswer.edges()) for u, v in P.edges(): assert_equal(P[u][v]["weight"], Panswer[u][v]["weight"])
def test_project_weighted_shared(self): edges=[('A','B',2), ('A','C',1), ('B','C',1), ('B','D',1), ('B','E',2), ('E','F',1)] Panswer=nx.Graph() Panswer.add_weighted_edges_from(edges) P=bipartite.weighted_projected_graph(self.G,'ABCDEF') assert_edges_equal(P.edges(),Panswer.edges()) for u,v in P.edges(): assert_equal(P[u][v]['weight'],Panswer[u][v]['weight']) edges=[('A','B',3), ('A','E',1), ('A','C',1), ('A','D',1), ('B','E',1), ('B','C',1), ('B','D',1), ('C','D',1)] Panswer=nx.Graph() Panswer.add_weighted_edges_from(edges) P=bipartite.weighted_projected_graph(self.N,'ABCDE') assert_edges_equal(P.edges(),Panswer.edges()) for u,v in P.edges(): assert_equal(P[u][v]['weight'],Panswer[u][v]['weight'])
def test_project_weighted_newman(self): edges = [("A", "B", 1.5), ("A", "C", 0.5), ("B", "C", 0.5), ("B", "D", 1), ("B", "E", 2), ("E", "F", 1)] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.collaboration_weighted_projected_graph(self.G, "ABCDEF") assert_edges_equal(P.edges(), Panswer.edges()) for u, v in P.edges(): assert_equal(P[u][v]["weight"], Panswer[u][v]["weight"]) edges = [ ("A", "B", 11 / 6.0), ("A", "E", 1 / 2.0), ("A", "C", 1 / 3.0), ("A", "D", 1 / 3.0), ("B", "E", 1 / 2.0), ("B", "C", 1 / 3.0), ("B", "D", 1 / 3.0), ("C", "D", 1 / 3.0), ] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.collaboration_weighted_projected_graph(self.N, "ABCDE") assert_edges_equal(P.edges(), Panswer.edges()) for u, v in P.edges(): assert_equal(P[u][v]["weight"], Panswer[u][v]["weight"])
def test_project_weighted_ratio(self): edges=[('A','B',2/6.0), ('A','C',1/6.0), ('B','C',1/6.0), ('B','D',1/6.0), ('B','E',2/6.0), ('E','F',1/6.0)] Panswer=nx.Graph() Panswer.add_weighted_edges_from(edges) P=bipartite.weighted_projected_graph(self.G, 'ABCDEF', ratio=True) assert_edges_equal(list(P.edges()),Panswer.edges()) for u,v in list(P.edges()): assert_equal(P[u][v]['weight'],Panswer[u][v]['weight']) edges=[('A','B',3/3.0), ('A','E',1/3.0), ('A','C',1/3.0), ('A','D',1/3.0), ('B','E',1/3.0), ('B','C',1/3.0), ('B','D',1/3.0), ('C','D',1/3.0)] Panswer=nx.Graph() Panswer.add_weighted_edges_from(edges) P=bipartite.weighted_projected_graph(self.N, 'ABCDE', ratio=True) assert_edges_equal(list(P.edges()),Panswer.edges()) for u,v in list(P.edges()): assert_equal(P[u][v]['weight'],Panswer[u][v]['weight'])
def test_project_weighted_newman(self): edges=[('A','B',1.5), ('A','C',0.5), ('B','C',0.5), ('B','D',1), ('B','E',2), ('E','F',1)] Panswer=nx.Graph() Panswer.add_weighted_edges_from(edges) P=bipartite.collaboration_weighted_projected_graph(self.G,'ABCDEF') assert_edges_equal(list(P.edges()),Panswer.edges()) for u,v in list(P.edges()): assert_equal(P[u][v]['weight'],Panswer[u][v]['weight']) edges=[('A','B',11/6.0), ('A','E',1/2.0), ('A','C',1/3.0), ('A','D',1/3.0), ('B','E',1/2.0), ('B','C',1/3.0), ('B','D',1/3.0), ('C','D',1/3.0)] Panswer=nx.Graph() Panswer.add_weighted_edges_from(edges) P=bipartite.collaboration_weighted_projected_graph(self.N,'ABCDE') assert_edges_equal(list(P.edges()),Panswer.edges()) for u,v in list(P.edges()): assert_equal(P[u][v]['weight'],Panswer[u][v]['weight'])
def test_graph(self): g = nx.cycle_graph(10) G = nx.Graph() G.add_nodes_from(g) G.add_weighted_edges_from((u, v, u) for u, v in g.edges()) # Dict of dicts dod = to_dict_of_dicts(G) GG = from_dict_of_dicts(dod, create_using=nx.Graph()) assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes())) assert_edges_equal(sorted(G.edges()), sorted(GG.edges())) GW = to_networkx_graph(dod, create_using=nx.Graph()) assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes())) assert_edges_equal(sorted(G.edges()), sorted(GW.edges())) GI = nx.Graph(dod) assert_equal(sorted(G.nodes()), sorted(GI.nodes())) assert_equal(sorted(G.edges()), sorted(GI.edges())) # Dict of lists dol = to_dict_of_lists(G) GG = from_dict_of_lists(dol, create_using=nx.Graph()) # dict of lists throws away edge data so set it to none enone = [(u, v, {}) for (u, v, d) in G.edges(data=True)] assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes())) assert_edges_equal(enone, sorted(GG.edges(data=True))) GW = to_networkx_graph(dol, create_using=nx.Graph()) assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes())) assert_edges_equal(enone, sorted(GW.edges(data=True))) GI = nx.Graph(dol) assert_nodes_equal(sorted(G.nodes()), sorted(GI.nodes())) assert_edges_equal(enone, sorted(GI.edges(data=True)))
def test_path_graph(self): p=path_graph(0) assert_true(is_isomorphic(p, null_graph())) p=path_graph(1) assert_true(is_isomorphic( p, empty_graph(1))) p=path_graph(10) assert_true(is_connected(p)) assert_equal(sorted(d for n, d in p.degree()), [1, 1, 2, 2, 2, 2, 2, 2, 2, 2]) assert_equal(p.order()-1, p.size()) dp=path_graph(3, create_using=DiGraph()) assert_true(dp.has_edge(0,1)) assert_false(dp.has_edge(1,0)) mp=path_graph(10, create_using=MultiGraph()) assert_edges_equal(mp.edges(), p.edges()) G=path_graph("abc") assert_equal(len(G), 3) assert_equal(G.size(), 2) g=path_graph("abc", nx.DiGraph()) assert_equal(len(g), 3) assert_equal(g.size(), 2) assert_true(g.is_directed())
def test_trivial6(self): """Small graph with arbitrary weight attribute""" G = nx.Graph() G.add_edge('one', 'two', weight=10, abcd=11) G.add_edge('two', 'three', weight=11, abcd=10) assert_edges_equal(nx.max_weight_matching(G, weight='abcd'), matching_dict_to_set({'one': 'two', 'two': 'one'}))
def test_project_weighted_jaccard(self): edges=[('A','B',2/5.0), ('A','C',1/2.0), ('B','C',1/5.0), ('B','D',1/5.0), ('B','E',2/6.0), ('E','F',1/3.0)] Panswer=nx.Graph() Panswer.add_weighted_edges_from(edges) P=bipartite.overlap_weighted_projected_graph(self.G,'ABCDEF') assert_edges_equal(list(P.edges()),Panswer.edges()) for u,v in list(P.edges()): assert_equal(P[u][v]['weight'],Panswer[u][v]['weight']) edges=[('A','B',3/3.0), ('A','E',1/3.0), ('A','C',1/3.0), ('A','D',1/3.0), ('B','E',1/3.0), ('B','C',1/3.0), ('B','D',1/3.0), ('C','D',1/1.0)] Panswer=nx.Graph() Panswer.add_weighted_edges_from(edges) P=bipartite.overlap_weighted_projected_graph(self.N,'ABCDE') assert_edges_equal(list(P.edges()),Panswer.edges()) for u,v in P.edges(): assert_equal(P[u][v]['weight'],Panswer[u][v]['weight'])
def test_trivial4(self): """Small graph""" G = nx.Graph() G.add_edge('one', 'two', weight=10) G.add_edge('two', 'three', weight=11) assert_edges_equal(nx.max_weight_matching(G), matching_dict_to_set({'three': 'two', 'two': 'three'}))
def test_lollipop_graph(self): # number of nodes = m1 + m2 # number of edges = number_of_edges(complete_graph(m1)) + m2 for m1, m2 in [(3, 5), (4, 10), (3, 20)]: b=lollipop_graph(m1,m2) assert_equal(number_of_nodes(b), m1+m2) assert_equal(number_of_edges(b), m1*(m1-1)/2 + m2) # Raise NetworkXError if m<2 assert_raises(networkx.exception.NetworkXError, lollipop_graph, 1, 20) # Raise NetworkXError if n<0 assert_raises(networkx.exception.NetworkXError, lollipop_graph, 5, -2) # lollipop_graph(2,m) = path_graph(m+2) for m1, m2 in [(2, 5), (2, 10), (2, 20)]: b=lollipop_graph(m1,m2) assert_true(is_isomorphic(b, path_graph(m2+2))) assert_raises(networkx.exception.NetworkXError, lollipop_graph, m1, m2, create_using=DiGraph()) mb=lollipop_graph(m1, m2, create_using=MultiGraph()) assert_edges_equal(mb.edges(), b.edges()) g=lollipop_graph([1,2,3,4], "abc") assert_equal(len(g), 7) assert_equal(g.size(), 9)
def test_project_weighted_shared(self): edges = [("A", "B", 2), ("A", "C", 1), ("B", "C", 1), ("B", "D", 1), ("B", "E", 2), ("E", "F", 1)] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.weighted_projected_graph(self.G, "ABCDEF") assert_edges_equal(P.edges(), Panswer.edges()) for u, v in P.edges(): assert_equal(P[u][v]["weight"], Panswer[u][v]["weight"]) edges = [ ("A", "B", 3), ("A", "E", 1), ("A", "C", 1), ("A", "D", 1), ("B", "E", 1), ("B", "C", 1), ("B", "D", 1), ("C", "D", 1), ] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.weighted_projected_graph(self.N, "ABCDE") assert_edges_equal(P.edges(), Panswer.edges()) for u, v in P.edges(): assert_equal(P[u][v]["weight"], Panswer[u][v]["weight"])
def test_decoding2(self): # Example from "An Optimal Algorithm for Prufer Codes". sequence = [2, 4, 0, 1, 3, 3] tree = nx.from_prufer_sequence(sequence) assert_nodes_equal(list(tree), list(range(8))) edges = [(0, 1), (0, 4), (1, 3), (2, 4), (2, 5), (3, 6), (3, 7)] assert_edges_equal(list(tree.edges()), edges)
def test_nested_s_blossom_relabel_expand(self): """Create nested S-blossom, relabel as T, expand:""" G = nx.Graph() G.add_weighted_edges_from([(1, 2, 19), (1, 3, 20), (1, 8, 8), (2, 3, 25), (2, 4, 18), (3, 5, 18), (4, 5, 13), (4, 7, 7), (5, 6, 7)]) assert_edges_equal(nx.max_weight_matching(G), matching_dict_to_set({1: 8, 2: 3, 3: 2, 4: 7, 5: 6, 6: 5, 7: 4, 8: 1}))
def test_s_blossom_relabel_expand(self): """Create S-blossom, relabel as T, expand:""" G = nx.Graph() G.add_weighted_edges_from([(1, 2, 23), (1, 5, 22), (1, 6, 15), (2, 3, 25), (3, 4, 22), (4, 5, 25), (4, 8, 14), (5, 7, 13)]) assert_edges_equal(nx.max_weight_matching(G), matching_dict_to_set({1: 6, 2: 3, 3: 2, 4: 8, 5: 7, 6: 1, 7: 5, 8: 4}))
def test_nested_s_blossom_relabel(self): """Create S-blossom, relabel as S, include in nested S-blossom:""" G = nx.Graph() G.add_weighted_edges_from([(1, 2, 10), (1, 7, 10), (2, 3, 12), (3, 4, 20), (3, 5, 20), (4, 5, 25), (5, 6, 10), (6, 7, 10), (7, 8, 8)]) assert_edges_equal(nx.max_weight_matching(G), matching_dict_to_set({1: 2, 2: 1, 3: 4, 4: 3, 5: 6, 6: 5, 7: 8, 8: 7}))
def test_path_projected_graph(self): G=nx.path_graph(4) P=bipartite.projected_graph(G, [1, 3]) assert_nodes_equal(list(P), [1, 3]) assert_edges_equal(list(P.edges()), [(1, 3)]) P=bipartite.projected_graph(G, [0, 2]) assert_nodes_equal(list(P), [0, 2]) assert_edges_equal(list(P.edges()), [(0, 2)])
def test_multiline_adjlist_delimiter(self): fh = io.BytesIO() G = nx.path_graph(3) nx.write_multiline_adjlist(G, fh, delimiter=':') fh.seek(0) H = nx.read_multiline_adjlist(fh, nodetype=int, delimiter=':') assert_nodes_equal(list(H), list(G)) assert_edges_equal(list(H.edges()), list(G.edges()))
def test_decoding(self): """Tests for decoding a tree from a Prüfer sequence.""" # Example from Wikipedia. sequence = [3, 3, 3, 4] tree = nx.from_prufer_sequence(sequence) assert_nodes_equal(list(tree), list(range(6))) edges = [(0, 3), (1, 3), (2, 3), (3, 4), (4, 5)] assert_edges_equal(list(tree.edges()), edges)
def test_without_data(self): edges = nx.minimum_spanning_edges(self.G, algorithm=self.algo, data=False) # Edges from the spanning edges functions don't come in sorted # orientation, so we need to sort each edge individually. actual = sorted((min(u, v), max(u, v)) for u, v in edges) expected = [(u, v) for u, v, d in self.minimum_spanning_edgelist] assert_edges_equal(actual, expected)
def test_complete_2_partite_graph(self): """Tests that the complete 2-partite graph is the complete bipartite graph. """ G = nx.complete_multipartite_graph(2, 3) H = nx.complete_bipartite_graph(2, 3) assert_nodes_equal(G, H) assert_edges_equal(G.edges(), H.edges())
def test_floating_point_weights(self): """Floating point weights""" G = nx.Graph() G.add_edge(1, 2, weight=math.pi) G.add_edge(2, 3, weight=math.exp(1)) G.add_edge(1, 3, weight=3.0) G.add_edge(1, 4, weight=math.sqrt(2.0)) assert_edges_equal(nx.max_weight_matching(G), matching_dict_to_set({1: 4, 2: 3, 3: 2, 4: 1}))
def test_node_input(self): G = nx.grid_2d_graph(4, 2, periodic=True) H = nx.grid_2d_graph(range(4), range(2), periodic=True) assert_true(nx.is_isomorphic(H, G)) H = nx.grid_2d_graph("abcd", "ef", periodic=True) assert_true(nx.is_isomorphic(H, G)) G = nx.grid_2d_graph(5, 6) H = nx.grid_2d_graph(range(5), range(6)) assert_edges_equal(H, G)
def test_nested_s_blossom_expand(self): """Create nested S-blossom, augment, expand recursively:""" G = nx.Graph() G.add_weighted_edges_from([(1, 2, 8), (1, 3, 8), (2, 3, 10), (2, 4, 12), (3, 5, 12), (4, 5, 14), (4, 6, 12), (5, 7, 12), (6, 7, 14), (7, 8, 12)]) assert_edges_equal(nx.max_weight_matching(G), matching_dict_to_set({1: 2, 2: 1, 3: 5, 4: 6, 5: 3, 6: 4, 7: 8, 8: 7}))
def test_unicode_name(self): """Tests that using a Unicode string can correctly indicate Borůvka's algorithm. """ edges = nx.minimum_spanning_edges(self.G, algorithm=u'borůvka') # Edges from the spanning edges functions don't come in sorted # orientation, so we need to sort each edge individually. actual = sorted((min(u, v), max(u, v), d) for u, v, d in edges) assert_edges_equal(actual, self.minimum_spanning_edgelist)
def assert_equal(self, G, data=False): (fd, fname) = tempfile.mkstemp() nx.write_yaml(G, fname) Gin = nx.read_yaml(fname) assert_nodes_equal(list(G), list(Gin)) assert_edges_equal(G.edges(data=data), Gin.edges(data=data)) os.close(fd) os.unlink(fname)
def test_multiline_adjlist_integers(self): (fd, fname) = tempfile.mkstemp() G = nx.convert_node_labels_to_integers(self.G) nx.write_multiline_adjlist(G, fname) H = nx.read_multiline_adjlist(fname, nodetype=int) H2 = nx.read_multiline_adjlist(fname, nodetype=int) assert_nodes_equal(list(H), list(G)) assert_edges_equal(list(H.edges()), list(G.edges())) os.close(fd) os.unlink(fname)
def test_read_edgelist_1(self): s = b"""\ # comment line 1 2 # comment line 2 3 """ bytesIO = io.BytesIO(s) G = nx.read_edgelist(bytesIO, nodetype=int) assert_edges_equal(G.edges(), [(1, 2), (2, 3)])
def test_path_weighted_projected_graph(self): G=nx.path_graph(4) P=bipartite.weighted_projected_graph(G,[1,3]) assert_nodes_equal(list(P),[1,3]) assert_edges_equal(list(P.edges()),[(1,3)]) P[1][3]['weight']=1 P=bipartite.weighted_projected_graph(G,[0,2]) assert_nodes_equal(list(P),[0,2]) assert_edges_equal(list(P.edges()),[(0,2)]) P[0][2]['weight']=1
def test_trivial5(self): """Path""" G = nx.Graph() G.add_edge(1, 2, weight=5) G.add_edge(2, 3, weight=11) G.add_edge(3, 4, weight=5) assert_edges_equal(nx.max_weight_matching(G), matching_dict_to_set({2: 3, 3: 2})) assert_edges_equal(nx.max_weight_matching(G, 1), matching_dict_to_set({1: 2, 2: 1, 3: 4, 4: 3}))
def test_generic_weighted_projected_graph_simple(self): def shared(G, u, v): return len(set(G[u]) & set(G[v])) B = nx.path_graph(5) G = bipartite.generic_weighted_projected_graph(B, [0, 2, 4], weight_function=shared) assert_nodes_equal(list(G), [0, 2, 4]) assert_edges_equal(list(list(G.edges(data=True))), [(0, 2, { 'weight': 1 }), (2, 4, { 'weight': 1 })]) G = bipartite.generic_weighted_projected_graph(B, [0, 2, 4]) assert_nodes_equal(list(G), [0, 2, 4]) assert_edges_equal(list(list(G.edges(data=True))), [(0, 2, { 'weight': 1 }), (2, 4, { 'weight': 1 })]) B = nx.DiGraph() nx.add_path(B, range(5)) G = bipartite.generic_weighted_projected_graph(B, [0, 2, 4]) assert_nodes_equal(list(G), [0, 2, 4]) assert_edges_equal(list(G.edges(data=True)), [(0, 2, { 'weight': 1 }), (2, 4, { 'weight': 1 })])
def test_nonisomorphic_trees(self): def f(x): return list(nx.nonisomorphic_trees(x)) assert_edges_equal(f(3)[0].edges(), [(0, 1), (0, 2)]) assert_edges_equal(f(4)[0].edges(), [(0, 1), (0, 3), (1, 2)]) assert_edges_equal(f(4)[1].edges(), [(0, 1), (0, 2), (0, 3)])
def test_digraphs(self): for dest, source in [(to_dict_of_dicts, from_dict_of_dicts), (to_dict_of_lists, from_dict_of_lists)]: G = cycle_graph(10) # Dict of [dicts, lists] dod = dest(G) GG = source(dod) assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes())) assert_edges_equal(sorted(G.edges()), sorted(GG.edges())) GW = to_networkx_graph(dod) assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes())) assert_edges_equal(sorted(G.edges()), sorted(GW.edges())) GI = nx.Graph(dod) assert_nodes_equal(sorted(G.nodes()), sorted(GI.nodes())) assert_edges_equal(sorted(G.edges()), sorted(GI.edges())) G = cycle_graph(10, create_using=nx.DiGraph()) dod = dest(G) GG = source(dod, create_using=nx.DiGraph()) assert_equal(sorted(G.nodes()), sorted(GG.nodes())) assert_equal(sorted(G.edges()), sorted(GG.edges())) GW = to_networkx_graph(dod, create_using=nx.DiGraph()) assert_equal(sorted(G.nodes()), sorted(GW.nodes())) assert_equal(sorted(G.edges()), sorted(GW.edges())) GI = nx.DiGraph(dod) assert_equal(sorted(G.nodes()), sorted(GI.nodes())) assert_equal(sorted(G.edges()), sorted(GI.edges()))
def test_from_datafram(self, ): # Pandas DataFrame g = nx.cycle_graph(10) G = nx.Graph() G.add_nodes_from(g) G.add_weighted_edges_from((u, v, u) for u, v in g.edges()) edgelist = nx.to_edgelist(G) source = [s for s, t, d in edgelist] target = [t for s, t, d in edgelist] weight = [d['weight'] for s, t, d in edgelist] import pandas as pd edges = pd.DataFrame({ 'source': source, 'target': target, 'weight': weight }) GG = nx.from_pandas_dataframe(edges, edge_attr='weight') assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes())) assert_edges_equal(sorted(G.edges()), sorted(GG.edges())) GW = nx.to_networkx_graph(edges, create_using=nx.Graph()) assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes())) assert_edges_equal(sorted(G.edges()), sorted(GW.edges()))
def test_nan_weights(self): # Edge weights NaN never appear in the spanning tree. see #2164 G = self.G G.add_edge(0, 12, weight=float('nan')) edges = nx.minimum_spanning_edges(G, algorithm=self.algo, data=False, ignore_nan=True) actual = sorted((min(u, v), max(u, v)) for u, v in edges) expected = [(u, v) for u, v, d in self.minimum_spanning_edgelist] assert_edges_equal(actual, expected) # Now test for raising exception edges = nx.minimum_spanning_edges(G, algorithm=self.algo, data=False, ignore_nan=False) with pytest.raises(ValueError): list(edges) # test default for ignore_nan as False edges = nx.minimum_spanning_edges(G, algorithm=self.algo, data=False) with pytest.raises(ValueError): list(edges)
def test_wheel_graph(self): for n, G in [(0, nx.null_graph()), (1, nx.empty_graph(1)), (2, nx.path_graph(2)), (3, nx.complete_graph(3)), (4, nx.complete_graph(4))]: g = nx.wheel_graph(n) assert is_isomorphic(g, G) g = nx.wheel_graph(10) assert (sorted( d for n, d in g.degree()) == [3, 3, 3, 3, 3, 3, 3, 3, 3, 9]) pytest.raises(nx.NetworkXError, nx.wheel_graph, 10, create_using=nx.DiGraph) mg = nx.wheel_graph(10, create_using=nx.MultiGraph()) assert_edges_equal(mg.edges(), g.edges()) G = nx.wheel_graph("abc") assert len(G) == 3 assert G.size() == 3
def test_star_graph(self): star_graph = nx.star_graph assert is_isomorphic(star_graph(0), nx.empty_graph(1)) assert is_isomorphic(star_graph(1), nx.path_graph(2)) assert is_isomorphic(star_graph(2), nx.path_graph(3)) assert is_isomorphic(star_graph(5), nx.complete_bipartite_graph(1, 5)) s = star_graph(10) assert sorted( d for n, d in s.degree()) == [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10] pytest.raises(nx.NetworkXError, star_graph, 10, create_using=nx.DiGraph) ms = star_graph(10, create_using=nx.MultiGraph) assert_edges_equal(ms.edges(), s.edges()) G = star_graph("abcdefg") assert len(G) == 7 assert G.size() == 6
def test_graph_power(): # wikipedia example for graph power G = nx.cycle_graph(7) G.add_edge(6, 7) G.add_edge(7, 8) G.add_edge(8, 9) G.add_edge(9, 2) H = nx.power(G, 2) assert_edges_equal( list(H.edges()), [ (0, 1), (0, 2), (0, 5), (0, 6), (0, 7), (1, 9), (1, 2), (1, 3), (1, 6), (2, 3), (2, 4), (2, 8), (2, 9), (3, 4), (3, 5), (3, 9), (4, 5), (4, 6), (5, 6), (5, 7), (6, 7), (6, 8), (7, 8), (7, 9), (8, 9), ], )
def test_wheel_graph(self): for n, G in [(0, null_graph()), (1, empty_graph(1)), (2, path_graph(2)), (3, complete_graph(3)), (4, complete_graph(4))]: g=wheel_graph(n) assert_true(is_isomorphic( g, G)) assert_equal(g.name, 'wheel_graph(4)') g=wheel_graph(10) assert_equal(sorted(d for n, d in g.degree()), [3, 3, 3, 3, 3, 3, 3, 3, 3, 9]) assert_raises(networkx.exception.NetworkXError, wheel_graph, 10, create_using=DiGraph()) mg=wheel_graph(10, create_using=MultiGraph()) assert_edges_equal(mg.edges(), g.edges()) G=wheel_graph("abc") assert_equal(len(G), 3) assert_equal(G.size(), 3)
def test_star_graph(self): assert_true(is_isomorphic(star_graph(0), empty_graph(1))) assert_true(is_isomorphic(star_graph(1), path_graph(2))) assert_true(is_isomorphic(star_graph(2), path_graph(3))) assert_true( is_isomorphic(star_graph(5), nx.complete_bipartite_graph(1, 5))) s = star_graph(10) assert_equal(sorted(d for n, d in s.degree()), [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 10]) assert_raises(networkx.exception.NetworkXError, star_graph, 10, create_using=DiGraph()) ms = star_graph(10, create_using=MultiGraph()) assert_edges_equal(ms.edges(), s.edges()) G = star_graph("abcdefg") assert_equal(len(G), 7) assert_equal(G.size(), 6)
def test_dorogovtsev_goltsev_mendes_graph(self): G = nx.dorogovtsev_goltsev_mendes_graph(0) assert_edges_equal(G.edges(), [(0, 1)]) assert_nodes_equal(list(G), [0, 1]) G = nx.dorogovtsev_goltsev_mendes_graph(1) assert_edges_equal(G.edges(), [(0, 1), (0, 2), (1, 2)]) assert nx.average_clustering(G) == 1.0 assert sorted(nx.triangles(G).values()) == [1, 1, 1] G = nx.dorogovtsev_goltsev_mendes_graph(10) assert nx.number_of_nodes(G) == 29526 assert nx.number_of_edges(G) == 59049 assert G.degree(0) == 1024 assert G.degree(1) == 1024 assert G.degree(2) == 1024 pytest.raises(nx.NetworkXError, nx.dorogovtsev_goltsev_mendes_graph, 7, create_using=nx.DiGraph) pytest.raises(nx.NetworkXError, nx.dorogovtsev_goltsev_mendes_graph, 7, create_using=nx.MultiGraph)
def test_nasty_blossom1(self): """Create blossom, relabel as T in more than one way, expand, augment: """ G = nx.Graph() G.add_weighted_edges_from([(1, 2, 45), (1, 5, 45), (2, 3, 50), (3, 4, 45), (4, 5, 50), (1, 6, 30), (3, 9, 35), (4, 8, 35), (5, 7, 26), (9, 10, 5)]) assert_edges_equal( nx.max_weight_matching(G), matching_dict_to_set({ 1: 6, 2: 3, 3: 2, 4: 8, 5: 7, 6: 1, 7: 5, 8: 4, 9: 10, 10: 9 }))
def test_nasty_blossom_least_slack(self): """Create blossom, relabel as T, expand such that a new least-slack S-to-free dge is produced, augment: """ G = nx.Graph() G.add_weighted_edges_from([(1, 2, 45), (1, 5, 45), (2, 3, 50), (3, 4, 45), (4, 5, 50), (1, 6, 30), (3, 9, 35), (4, 8, 28), (5, 7, 26), (9, 10, 5)]) assert_edges_equal( nx.max_weight_matching(G), matching_dict_to_set({ 1: 6, 2: 3, 3: 2, 4: 8, 5: 7, 6: 1, 7: 5, 8: 4, 9: 10, 10: 9 }))
def test_dorogovtsev_goltsev_mendes_graph(self): G = dorogovtsev_goltsev_mendes_graph(0) assert_edges_equal(G.edges(), [(0, 1)]) assert_nodes_equal(list(G), [0, 1]) G = dorogovtsev_goltsev_mendes_graph(1) assert_edges_equal(G.edges(), [(0, 1), (0, 2), (1, 2)]) assert_equal(average_clustering(G), 1.0) assert_equal(sorted(triangles(G).values()), [1, 1, 1]) G = dorogovtsev_goltsev_mendes_graph(10) assert_equal(number_of_nodes(G), 29526) assert_equal(number_of_edges(G), 59049) assert_equal(G.degree(0), 1024) assert_equal(G.degree(1), 1024) assert_equal(G.degree(2), 1024) assert_raises(networkx.exception.NetworkXError, dorogovtsev_goltsev_mendes_graph, 7, create_using=DiGraph()) assert_raises(networkx.exception.NetworkXError, dorogovtsev_goltsev_mendes_graph, 7, create_using=MultiGraph())
def test_project_weighted_overlap(self): edges = [('A', 'B', 2 / 2.0), ('A', 'C', 1 / 1.0), ('B', 'C', 1 / 1.0), ('B', 'D', 1 / 1.0), ('B', 'E', 2 / 3.0), ('E', 'F', 1 / 1.0)] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.overlap_weighted_projected_graph(self.G, 'ABCDEF', jaccard=False) assert_edges_equal(list(P.edges()), Panswer.edges()) for u, v in list(P.edges()): assert_equal(P[u][v]['weight'], Panswer[u][v]['weight']) edges = [('A', 'B', 3 / 3.0), ('A', 'E', 1 / 1.0), ('A', 'C', 1 / 1.0), ('A', 'D', 1 / 1.0), ('B', 'E', 1 / 1.0), ('B', 'C', 1 / 1.0), ('B', 'D', 1 / 1.0), ('C', 'D', 1 / 1.0)] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.overlap_weighted_projected_graph(self.N, 'ABCDE', jaccard=False) assert_edges_equal(list(P.edges()), Panswer.edges()) for u, v in list(P.edges()): assert_equal(P[u][v]['weight'], Panswer[u][v]['weight'])
def test_nasty_blossom_augmenting(self): """Create nested blossom, relabel as T in more than one way""" # expand outer blossom such that inner blossom ends up on an # augmenting path: G = nx.Graph() G.add_weighted_edges_from([ (1, 2, 45), (1, 7, 45), (2, 3, 50), (3, 4, 45), (4, 5, 95), (4, 6, 94), (5, 6, 94), (6, 7, 50), (1, 8, 30), (3, 11, 35), (5, 9, 36), (7, 10, 26), (11, 12, 5), ]) ans = { 1: 8, 2: 3, 3: 2, 4: 6, 5: 9, 6: 4, 7: 10, 8: 1, 9: 5, 10: 7, 11: 12, 12: 11, } answer = matching_dict_to_set(ans) assert_edges_equal(nx.max_weight_matching(G), answer) assert_edges_equal(nx.min_weight_matching(G), answer)
def test_isolated_node(self): # now try again with an isolated node edges = [ (0, 1, 7), (0, 3, 5), (1, 2, 8), (1, 3, 9), (1, 4, 7), (2, 4, 5), (3, 4, 15), (3, 5, 6), (4, 5, 8), (4, 6, 9), (5, 6, 11), ] G = nx.Graph() G.add_weighted_edges_from([(u + 1, v + 1, wt) for u, v, wt in edges]) G.add_node(0) edges = nx.minimum_spanning_edges( G, algorithm=self.algo, data=False, ignore_nan=True ) actual = sorted((min(u, v), max(u, v)) for u, v in edges) shift = [(u + 1, v + 1) for u, v, d in self.minimum_spanning_edgelist] assert_edges_equal(actual, shift)
def test_project_weighted_overlap(self): edges = [ ("A", "B", 2 / 2.0), ("A", "C", 1 / 1.0), ("B", "C", 1 / 1.0), ("B", "D", 1 / 1.0), ("B", "E", 2 / 3.0), ("E", "F", 1 / 1.0), ] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.overlap_weighted_projected_graph(self.G, "ABCDEF", jaccard=False) assert_edges_equal(list(P.edges()), Panswer.edges()) for u, v in list(P.edges()): assert P[u][v]["weight"] == Panswer[u][v]["weight"] edges = [ ("A", "B", 3 / 3.0), ("A", "E", 1 / 1.0), ("A", "C", 1 / 1.0), ("A", "D", 1 / 1.0), ("B", "E", 1 / 1.0), ("B", "C", 1 / 1.0), ("B", "D", 1 / 1.0), ("C", "D", 1 / 1.0), ] Panswer = nx.Graph() Panswer.add_weighted_edges_from(edges) P = bipartite.overlap_weighted_projected_graph(self.N, "ABCDE", jaccard=False) assert_edges_equal(list(P.edges()), Panswer.edges()) for u, v in list(P.edges()): assert P[u][v]["weight"] == Panswer[u][v]["weight"]
def test_iterators(self): G = self.G() G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")]) G.add_nodes_from("GJK") assert sorted(G.nodes()) == ["A", "B", "C", "D", "G", "J", "K"] assert_edges_equal(G.edges(), [("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")]) assert sorted([v for k, v in G.degree()]) == [0, 0, 0, 2, 2, 3, 3] assert sorted(G.degree(), key=str) == [ ("A", 2), ("B", 3), ("C", 3), ("D", 2), ("G", 0), ("J", 0), ("K", 0), ] assert sorted(G.neighbors("A")) == ["B", "C"] pytest.raises(nx.NetworkXError, G.neighbors, "X") G.clear() assert nx.number_of_nodes(G) == 0 assert nx.number_of_edges(G) == 0
def test_s_blossom(self): """Create S-blossom and use it for augmentation:""" G = nx.Graph() G.add_weighted_edges_from([(1, 2, 8), (1, 3, 9), (2, 3, 10), (3, 4, 7)]) assert_edges_equal(nx.max_weight_matching(G), matching_dict_to_set({ 1: 2, 2: 1, 3: 4, 4: 3 })) G.add_weighted_edges_from([(1, 6, 5), (4, 5, 6)]) assert_edges_equal( nx.max_weight_matching(G), matching_dict_to_set({ 1: 6, 2: 3, 3: 2, 4: 5, 5: 4, 6: 1 }))
def test_project_multigraph(self): G = nx.Graph() G.add_edge('a', 1) G.add_edge('b', 1) G.add_edge('a', 2) G.add_edge('b', 2) P = bipartite.projected_graph(G, 'ab') assert_edges_equal(list(P.edges()), [('a', 'b')]) P = bipartite.weighted_projected_graph(G, 'ab') assert_edges_equal(list(P.edges()), [('a', 'b')]) P = bipartite.projected_graph(G, 'ab', multigraph=True) assert_edges_equal(list(P.edges()), [('a', 'b'), ('a', 'b')])
def test_project_multigraph(self): G = nx.Graph() G.add_edge("a", 1) G.add_edge("b", 1) G.add_edge("a", 2) G.add_edge("b", 2) P = bipartite.projected_graph(G, "ab") assert_edges_equal(list(P.edges()), [("a", "b")]) P = bipartite.weighted_projected_graph(G, "ab") assert_edges_equal(list(P.edges()), [("a", "b")]) P = bipartite.projected_graph(G, "ab", multigraph=True) assert_edges_equal(list(P.edges()), [("a", "b"), ("a", "b")])
def test_star_projected_graph(self): G = nx.star_graph(3) P = bipartite.projected_graph(G, [1, 2, 3]) assert_nodes_equal(list(P), [1, 2, 3]) assert_edges_equal(list(P.edges()), [(1, 2), (1, 3), (2, 3)]) P = bipartite.weighted_projected_graph(G, [1, 2, 3]) assert_nodes_equal(list(P), [1, 2, 3]) assert_edges_equal(list(P.edges()), [(1, 2), (1, 3), (2, 3)]) P = bipartite.projected_graph(G, [0]) assert_nodes_equal(list(P), [0]) assert_edges_equal(list(P.edges()), [])
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_s_t_blossom(self): """Create S-blossom, relabel as T-blossom, use for augmentation:""" G = nx.Graph() G.add_weighted_edges_from([(1, 2, 9), (1, 3, 8), (2, 3, 10), (1, 4, 5), (4, 5, 4), (1, 6, 3)]) assert_edges_equal(nx.max_weight_matching(G), matching_dict_to_set({1: 6, 2: 3, 3: 2, 4: 5, 5: 4, 6: 1})) G.add_edge(4, 5, weight=3) G.add_edge(1, 6, weight=4) assert_edges_equal(nx.max_weight_matching(G), matching_dict_to_set({1: 6, 2: 3, 3: 2, 4: 5, 5: 4, 6: 1})) G.remove_edge(1, 6) G.add_edge(3, 6, weight=4) assert_edges_equal(nx.max_weight_matching(G), matching_dict_to_set({1: 2, 2: 1, 3: 6, 4: 5, 5: 4, 6: 3}))
def test_read_edgelist_4(self): s = b"""\ # comment line 1 2 {'weight':2.0} # comment line 2 3 {'weight':3.0} """ bytesIO = io.BytesIO(s) G = nx.read_edgelist(bytesIO, nodetype=int, data=False) assert_edges_equal(G.edges(), [(1, 2), (2, 3)]) bytesIO = io.BytesIO(s) G = nx.read_edgelist(bytesIO, nodetype=int, data=True) assert_edges_equal(G.edges(data=True), [(1, 2, { 'weight': 2.0 }), (2, 3, { 'weight': 3.0 })]) s = """\ # comment line 1 2 {'weight':2.0} # comment line 2 3 {'weight':3.0} """ StringIO = io.StringIO(s) G = nx.read_edgelist(StringIO, nodetype=int, data=False) assert_edges_equal(G.edges(), [(1, 2), (2, 3)]) StringIO = io.StringIO(s) G = nx.read_edgelist(StringIO, nodetype=int, data=True) assert_edges_equal(G.edges(data=True), [(1, 2, { 'weight': 2.0 }), (2, 3, { 'weight': 3.0 })])
def test_generic_weighted_projected_graph_custom(self): def jaccard(G, u, v): unbrs = set(G[u]) vnbrs = set(G[v]) return float(len(unbrs & vnbrs)) / len(unbrs | vnbrs) def my_weight(G, u, v, weight='weight'): w = 0 for nbr in set(G[u]) & set(G[v]): w += G.edge[u][nbr].get(weight, 1) + G.edge[v][nbr].get(weight, 1) return w B = nx.complete_bipartite_graph(2,2) for i,(u,v) in enumerate(B.edges()): B.edge[u][v]['weight'] = i + 1 G = bipartite.generic_weighted_projected_graph(B, [0, 1], weight_function=jaccard) assert_edges_equal(G.edges(data=True), [(0, 1, {'weight': 1.0})]) G = bipartite.generic_weighted_projected_graph(B, [0, 1], weight_function=my_weight) assert_edges_equal(G.edges(data=True), [(0, 1, {'weight': 10})]) G = bipartite.generic_weighted_projected_graph(B, [0, 1]) assert_edges_equal(G.edges(data=True), [(0, 1, {'weight': 2})])
def test_parse_pajek(self): G = nx.parse_pajek(self.data) assert sorted(G.nodes()) == ['A1', 'Bb', 'C', 'D2'] assert_edges_equal(G.edges(), [('A1', 'A1'), ('A1', 'Bb'), ('A1', 'C'), ('Bb', 'A1'), ('C', 'C'), ('C', 'D2'), ('D2', 'Bb')])
def test_parse_pajek_simple(self): # Example without node positions or shape data = """*Vertices 2\n1 "1"\n2 "2"\n*Edges\n1 2\n2 1""" G = nx.parse_pajek(data) assert sorted(G.nodes()) == ['1', '2'] assert_edges_equal(G.edges(), [('1', '2'), ('1', '2')])
def test_directed_projection(self): G = nx.DiGraph() G.add_edge('A', 1) G.add_edge(1, 'B') G.add_edge('A', 2) G.add_edge('B', 2) P = bipartite.projected_graph(G, 'AB') assert_edges_equal(list(P.edges()), [('A', 'B')]) P = bipartite.weighted_projected_graph(G, 'AB') assert_edges_equal(list(P.edges()), [('A', 'B')]) assert_equal(P['A']['B']['weight'], 1) P = bipartite.projected_graph(G, 'AB', multigraph=True) assert_edges_equal(list(P.edges()), [('A', 'B')]) G = nx.DiGraph() G.add_edge('A', 1) G.add_edge(1, 'B') G.add_edge('A', 2) G.add_edge(2, 'B') P = bipartite.projected_graph(G, 'AB') assert_edges_equal(list(P.edges()), [('A', 'B')]) P = bipartite.weighted_projected_graph(G, 'AB') assert_edges_equal(list(P.edges()), [('A', 'B')]) assert_equal(P['A']['B']['weight'], 2) P = bipartite.projected_graph(G, 'AB', multigraph=True) assert_edges_equal(list(P.edges()), [('A', 'B'), ('A', 'B')])