Python graphs.Graph类代码示例

    def test_add_edge_not_valid_vertex(self):
        """Tests the add_edge method in a graph with a non-existing vertex.
        """
        graph = Graph(graph = { 'A' : [] })

        graph.add_edge('A', 'B')
        self.assertFalse(graph.has_edge('A', 'B'), 'No edge between A and non-existing B.')

    def test_has_edge_no_connexion(self):
        """Tests the has_edge method for a graph without connexion.
        """
        graph = Graph(graph = {'Z' : []})

        self.assertFalse(graph.has_edge('Z', 'A'), 'There is no edge between Z to A.')
        self.assertFalse(graph.has_edge('Z', None), 'There is no edge between Z and a None vertex.')

def build_graph(code):
    graph = Graph()
    blocks = [b["name"] for b in code["blocks"]]
    edges = [(b["name"], e) for b in code["blocks"] for e in b["next_block"]]
    graph.add_nodes(*blocks)
    graph.add_edges(*edges)
    return graph

    def test_has_edge_directed(self):
        """Tests the has_edge method for a directed graph.
        """
        directed = Graph(graph = { 'C' : ['D'], 'D' : [] }, is_directed = True)

        self.assertTrue(directed.has_edge('C', 'D'), 'There is an edge from C to D.')
        self.assertFalse(directed.has_edge('D', 'C'), 'There is no edge from D to C.')

    def test_has_edge_undirected(self):
        """Tests the has_edge method for an undirected graph.
        """
        undirected = Graph(graph = { 'A' : ['B'], 'B' : ['A'] })

        self.assertTrue(undirected.has_edge('A', 'B'), 'There is an edge between A and B.')
        self.assertTrue(undirected.has_edge('B', 'A'), 'There is an edge between B and A.')

    def test_contains_vertex(self):
        """Tests the contains_vertex method with a single vertex.
        """
        data = { 'A' : [] }
        graph = Graph(graph=data)

        self.assertTrue(graph.contains_vertex('A'), 'The graph contains A.')
        self.assertFalse(graph.contains_vertex('B'), 'The graph does not contain B.')

 def test_degree(self):
     """Tests the degree methods in a graph.
     """
     graph = Graph(graph = { 'A' : ['B', 'C'], 'B' : ['A'], 'C' : [] })
     
     self.assertEqual(graph.interior_degree('A'), 1, 'There is 1 edge coming to A.')
     self.assertEqual(graph.exterior_degree('A'), 2, 'There are 2 edges extending from A.')
     self.assertEqual(graph.degree('A'), 3, 'There are 3 edges from and to A.')

    def test_remove_unexisting_edge_with_unexisting_vertex(self):
        """Tests the remove_edge method in a graph between an existing vertex and a non-existing one.
        """
        graph = Graph(graph = { 'A' : [] })

        self.assertFalse(graph.has_edge('A', 'C'), 'There cannot be edge between A and C.')
        graph.remove_edge('A', 'C')
        self.assertFalse(graph.has_edge('A', 'C'), 'Nothing changed.')

    def test_add_vertex(self):
        """Tests the add_vertex method with an empty graph.
        """
        graph = Graph()

        self.assertFalse(graph.contains_vertex('A'), 'The graph does not contain A yet.')
        graph.add_vertex('A')
        self.assertTrue(graph.contains_vertex('A'), 'The graph now contains A.')

    def test_remove_unexisting_edge(self):
        """Tests the remove_edge method in a graph without edge between two vertex
        """
        graph = Graph(graph = { 'A' : [], 'B' : [] })

        self.assertFalse(graph.has_edge('A', 'B'), 'There is no edge between A and B.')
        graph.remove_edge('A', 'B')
        self.assertFalse(graph.has_edge('A', 'B'), 'Nothing changed.')

    def test_remove_edge_undirected(self):
        """Tests the remove_edge method in an undirected graph.
        """
        graph = Graph(graph = { 'A' : ['B'], 'B' : ['A'] })

        self.assertTrue(graph.has_edge('A', 'B'), 'There is an edge between A and B.')
        graph.remove_edge('A', 'B')
        self.assertFalse(graph.has_edge('A', 'B'), 'No more edge between A and B.')

    def __init__(self):
        Graph.__init__(self)

        # stop to cluster matching
        self.stop_to_cluster = {}

        # cluster's name to node id matching
        self.cluster_id = {}

 def test_circular_layout(self):
   G = Graph.from_edge_pairs([], num_vertices=4)
   expected = np.array([[1,0],[0,1],[-1,0],[0,-1]])
   assert_array_almost_equal(G.layout_circle(), expected)
   # edge cases
   for nv in (0, 1):
     G = Graph.from_edge_pairs([], num_vertices=nv)
     X = G.layout_circle()
     self.assertEqual(X.shape, (nv, 2))

    def test_add_edge_undirected(self):
        """Tests the add_edge method for an undirected graph.
        """
        graph = Graph(graph = { 'A' : [], 'B' : [] })

        self.assertFalse(graph.has_edge('A', 'B'), 'There is no edge between A and B.')

        graph.add_edge('A', 'B')

        self.assertTrue(graph.has_edge('A', 'B'), 'There is now an edge between A and B.')

 def test_kernelize(self):
   graphs = [
       Graph.from_edge_pairs(PAIRS),
       Graph.from_adj_matrix(ADJ),
       Graph.from_adj_matrix(coo_matrix(ADJ)),
       Graph.from_adj_matrix(csr_matrix(ADJ)),
   ]
   for G in graphs:
     for kernel in ('none', 'binary'):
       K = G.kernelize(kernel)
       assert_array_equal(K.matrix('dense'), ADJ)
     self.assertRaises(ValueError, G.kernelize, 'foobar')