Exemplo n.º 1
0
    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"])
Exemplo n.º 2
0
    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'])
Exemplo n.º 3
0
    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"])
Exemplo n.º 4
0
    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'])
Exemplo n.º 5
0
    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'])
Exemplo n.º 6
0
    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)))
Exemplo n.º 7
0
    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())
Exemplo n.º 8
0
 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'}))
Exemplo n.º 9
0
    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'])
Exemplo n.º 10
0
 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'}))
Exemplo n.º 11
0
    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)
Exemplo n.º 12
0
    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"])
Exemplo n.º 13
0
 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)
Exemplo n.º 14
0
 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}))
Exemplo n.º 15
0
 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}))
Exemplo n.º 16
0
 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}))
Exemplo n.º 17
0
 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)])
Exemplo n.º 18
0
 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()))
Exemplo n.º 19
0
 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)
Exemplo n.º 20
0
 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)
Exemplo n.º 21
0
    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())
Exemplo n.º 22
0
 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}))
Exemplo n.º 23
0
 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)
Exemplo n.º 24
0
 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}))
Exemplo n.º 25
0
    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)
Exemplo n.º 26
0
    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)
Exemplo n.º 27
0
 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)
Exemplo n.º 28
0
    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)])
Exemplo n.º 29
0
 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
Exemplo n.º 30
0
 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}))
Exemplo n.º 31
0
    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
        })])
Exemplo n.º 32
0
    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)])
Exemplo n.º 33
0
    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()))
Exemplo n.º 34
0
 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()))
Exemplo n.º 35
0
 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)
Exemplo n.º 36
0
    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
Exemplo n.º 37
0
    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
Exemplo n.º 38
0
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),
        ],
    )
Exemplo n.º 39
0
    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)
Exemplo n.º 40
0
    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)
Exemplo n.º 41
0
    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)
Exemplo n.º 42
0
 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
         }))
Exemplo n.º 43
0
 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
         }))
Exemplo n.º 44
0
    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())
Exemplo n.º 45
0
    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'])
Exemplo n.º 46
0
 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)
Exemplo n.º 47
0
 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)
Exemplo n.º 48
0
    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"]
Exemplo n.º 49
0
    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
Exemplo n.º 50
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
            }))
Exemplo n.º 51
0
 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')])
Exemplo n.º 52
0
 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")])
Exemplo n.º 53
0
    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()), [])
Exemplo n.º 54
0
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))
Exemplo n.º 55
0
 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
        })])
Exemplo n.º 57
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})])
Exemplo n.º 58
0
 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')])
Exemplo n.º 59
0
 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')])
Exemplo n.º 60
0
    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')])