← Back to branch summary

~ubuntu-branches/ubuntu/utopic/python-networkx/utopic

« back to all changes in this revision

Viewing changes to networkx/tests/test_convert.py

  • Committer: Package Import Robot
  • Author(s): Sandro Tosi
  • Date: 2012-08-11 12:41:30 UTC
  • mfrom: (1.4.1) (5.1.13 sid)
  • Revision ID: package-import@ubuntu.com-20120811124130-whr6uso7fncyg8bi
Tags: 1.7-1
* New upstream release
* debian/patches/changeset_*
  - removed, included upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
networkx/tests/test_convert.py
11
11
from networkx.generators.classic import barbell_graph,cycle_graph
12
12
 
13
13
class TestConvert():
 
14
    def edgelists_equal(self,e1,e2):
 
15
        return sorted(sorted(e) for e in e1)==sorted(sorted(e) for e in e2)
 
16
    
 
17
        
 
18
 
14
19
    def test_simple_graphs(self):
15
20
        for dest, source in [(to_dict_of_dicts, from_dict_of_dicts),
16
21
                             (to_dict_of_lists, from_dict_of_lists)]:
21
26
            GG=source(dod)
22
27
            assert_equal(sorted(G.nodes()), sorted(GG.nodes()))
23
28
            assert_equal(sorted(G.edges()), sorted(GG.edges()))
24
 
            GW=from_whatever(dod)
 
29
            GW=to_networkx_graph(dod)
25
30
            assert_equal(sorted(G.nodes()), sorted(GW.nodes()))
26
31
            assert_equal(sorted(G.edges()), sorted(GW.edges()))
27
32
            GI=Graph(dod)
46
51
            GG=source(dod)
47
52
            assert_equal(sorted(G.nodes()), sorted(GG.nodes()))
48
53
            assert_equal(sorted(G.edges()), sorted(GG.edges()))
49
 
            GW=from_whatever(dod)
 
54
            GW=to_networkx_graph(dod)
50
55
            assert_equal(sorted(G.nodes()), sorted(GW.nodes()))
51
56
            assert_equal(sorted(G.edges()), sorted(GW.edges()))
52
57
            GI=Graph(dod)
58
63
            GG=source(dod, create_using=DiGraph())
59
64
            assert_equal(sorted(G.nodes()), sorted(GG.nodes()))
60
65
            assert_equal(sorted(G.edges()), sorted(GG.edges()))
61
 
            GW=from_whatever(dod, create_using=DiGraph())
 
66
            GW=to_networkx_graph(dod, create_using=DiGraph())
62
67
            assert_equal(sorted(G.nodes()), sorted(GW.nodes()))
63
68
            assert_equal(sorted(G.edges()), sorted(GW.edges()))
64
69
            GI=DiGraph(dod)
79
84
        GG=from_dict_of_dicts(dod,create_using=Graph())
80
85
        assert_equal(sorted(G.nodes()), sorted(GG.nodes()))
81
86
        assert_equal(sorted(G.edges()), sorted(GG.edges()))
82
 
        GW=from_whatever(dod,create_using=Graph())
 
87
        GW=to_networkx_graph(dod,create_using=Graph())
83
88
        assert_equal(sorted(G.nodes()), sorted(GW.nodes()))
84
89
        assert_equal(sorted(G.edges()), sorted(GW.edges()))
85
90
        GI=Graph(dod)
93
98
        enone=[(u,v,{}) for (u,v,d) in G.edges(data=True)]
94
99
        assert_equal(sorted(G.nodes()), sorted(GG.nodes()))
95
100
        assert_equal(enone, sorted(GG.edges(data=True)))
96
 
        GW=from_whatever(dol,create_using=Graph())
 
101
        GW=to_networkx_graph(dol,create_using=Graph())
97
102
        assert_equal(sorted(G.nodes()), sorted(GW.nodes()))
98
103
        assert_equal(enone, sorted(GW.edges(data=True)))
99
104
        GI=Graph(dol)
121
126
        GG=from_dict_of_dicts(dod,create_using=Graph())
122
127
        assert_equal(sorted(XGS.nodes()), sorted(GG.nodes()))
123
128
        assert_equal(sorted(XGS.edges()), sorted(GG.edges()))
124
 
        GW=from_whatever(dod,create_using=Graph())
 
129
        GW=to_networkx_graph(dod,create_using=Graph())
125
130
        assert_equal(sorted(XGS.nodes()), sorted(GW.nodes()))
126
131
        assert_equal(sorted(XGS.edges()), sorted(GW.edges()))
127
132
        GI=Graph(dod)
136
141
        enone=[(u,v,{}) for (u,v,d) in XGS.edges(data=True)]
137
142
        assert_equal(sorted(XGS.nodes()), sorted(GG.nodes()))
138
143
        assert_equal(enone, sorted(GG.edges(data=True)))
139
 
        GW=from_whatever(dol,create_using=Graph())
 
144
        GW=to_networkx_graph(dol,create_using=Graph())
140
145
        assert_equal(sorted(XGS.nodes()), sorted(GW.nodes()))
141
146
        assert_equal(enone, sorted(GW.edges(data=True)))
142
147
        GI=Graph(dol)
150
155
                              multigraph_input=True)
151
156
        assert_equal(sorted(XGM.nodes()), sorted(GG.nodes()))
152
157
        assert_equal(sorted(XGM.edges()), sorted(GG.edges()))
153
 
        GW=from_whatever(dod,create_using=MultiGraph(),multigraph_input=True)
 
158
        GW=to_networkx_graph(dod,create_using=MultiGraph(),multigraph_input=True)
154
159
        assert_equal(sorted(XGM.nodes()), sorted(GW.nodes()))
155
160
        assert_equal(sorted(XGM.edges()), sorted(GW.edges()))
156
161
        GI=MultiGraph(dod)  # convert can't tell whether to duplicate edges!
175
180
        GG=from_dict_of_lists(dol,create_using=MultiGraph())
176
181
        assert_equal(sorted(G.nodes()), sorted(GG.nodes()))
177
182
        assert_equal(sorted(G.edges()), sorted(GG.edges()))
178
 
        GW=from_whatever(dol,create_using=MultiGraph())
 
183
        GW=to_networkx_graph(dol,create_using=MultiGraph())
179
184
        assert_equal(sorted(G.nodes()), sorted(GW.nodes()))
180
185
        assert_equal(sorted(G.edges()), sorted(GW.edges()))
181
186
        GI=MultiGraph(dol)
202
207
        assert_equal(sorted(G.edges()), sorted(P.edges()))
203
208
        assert_equal(sorted(G.edges(data=True)), sorted(P.edges(data=True)))
204
209
 
205
 
    def test_convert_node_labels_to_integers(self):
206
 
        # test that empty graph converts fine for all options
207
 
        G=empty_graph()
208
 
        H=convert_node_labels_to_integers(G,100)
209
 
        assert_equal(H.name, '(empty_graph(0))_with_int_labels')
210
 
        assert_equal(H.nodes(), [])
211
 
        assert_equal(H.edges(), [])
212
 
 
213
 
        for opt in ["default", "sorted", "increasing degree",
214
 
                    "decreasing degree"]:
215
 
            G=empty_graph()
216
 
            H=convert_node_labels_to_integers(G,100, ordering=opt)
217
 
            assert_equal(H.name, '(empty_graph(0))_with_int_labels')
218
 
            assert_equal(H.nodes(), [])
219
 
            assert_equal(H.edges(), [])
220
 
 
221
 
        G=empty_graph()
222
 
        G.add_edges_from([('A','B'),('A','C'),('B','C'),('C','D')])
223
 
        G.name="paw"
224
 
        H=convert_node_labels_to_integers(G)
225
 
        degH=H.degree().values()
226
 
        degG=G.degree().values()
227
 
        assert_equal(sorted(degH), sorted(degG))
228
 
 
229
 
        H=convert_node_labels_to_integers(G,1000)
230
 
        degH=H.degree().values()
231
 
        degG=G.degree().values()
232
 
        assert_equal(sorted(degH), sorted(degG))
233
 
        assert_equal(H.nodes(), [1000, 1001, 1002, 1003])
234
 
 
235
 
        H=convert_node_labels_to_integers(G,ordering="increasing degree")
236
 
        degH=H.degree().values()
237
 
        degG=G.degree().values()
238
 
        assert_equal(sorted(degH), sorted(degG))
239
 
        assert_equal(degree(H,0), 1)
240
 
        assert_equal(degree(H,1), 2)
241
 
        assert_equal(degree(H,2), 2)
242
 
        assert_equal(degree(H,3), 3)
243
 
 
244
 
        H=convert_node_labels_to_integers(G,ordering="decreasing degree")
245
 
        degH=H.degree().values()
246
 
        degG=G.degree().values()
247
 
        assert_equal(sorted(degH), sorted(degG))
248
 
        assert_equal(degree(H,0), 3)
249
 
        assert_equal(degree(H,1), 2)
250
 
        assert_equal(degree(H,2), 2)
251
 
        assert_equal(degree(H,3), 1)
252
 
 
253
 
        H=convert_node_labels_to_integers(G,ordering="increasing degree",
254
 
                                          discard_old_labels=False)
255
 
        degH=H.degree().values()
256
 
        degG=G.degree().values()
257
 
        assert_equal(sorted(degH), sorted(degG))
258
 
        assert_equal(degree(H,0), 1)
259
 
        assert_equal(degree(H,1), 2)
260
 
        assert_equal(degree(H,2), 2)
261
 
        assert_equal(degree(H,3), 3)
262
 
        mapping=H.node_labels
263
 
        assert_equal(mapping['C'], 3)
264
 
        assert_equal(mapping['D'], 0)
265
 
        assert_true(mapping['A']==1 or mapping['A']==2)
266
 
        assert_true(mapping['B']==1 or mapping['B']==2)
267
 
 
268
 
        G=empty_graph()
269
 
        G.add_edges_from([('C','D'),('A','B'),('A','C'),('B','C')])
270
 
        G.name="paw"
271
 
        H=convert_node_labels_to_integers(G,ordering="sorted")
272
 
        degH=H.degree().values()
273
 
        degG=G.degree().values()
274
 
        assert_equal(sorted(degH), sorted(degG))
275
 
 
276
 
        H=convert_node_labels_to_integers(G,ordering="sorted",
277
 
                                          discard_old_labels=False)
278
 
        mapping=H.node_labels
279
 
        assert_equal(mapping['A'], 0)
280
 
        assert_equal(mapping['B'], 1)
281
 
        assert_equal(mapping['C'], 2)
282
 
        assert_equal(mapping['D'], 3)
283
 
 
284
 
        assert_raises(networkx.exception.NetworkXError,
285
 
                      convert_node_labels_to_integers, G, 
286
 
                      ordering="increasing age")
287
 
 
288
 
    def test_relabel(self):
289
 
        G=empty_graph()
290
 
        G.add_edges_from([('A','B'),('A','C'),('B','C'),('C','D')])
291
 
        mapping={'A':'aardvark','B':'bear','C':'cat','D':'dog'}
292
 
        H=relabel_nodes(G,mapping)
293
 
        assert_equal(sorted(H.nodes()), ['aardvark', 'bear', 'cat', 'dog'])
294
 
        
295
 
        def mapping(n):
296
 
            return ord(n)
297
 
 
298
 
        H=relabel_nodes(G,mapping)
299
 
        assert_equal(sorted(H.nodes()), [65, 66, 67, 68])
300
 
 
301
 
"""convert_data_structure
302
 
G1.has_edge('B', 'A')
303
 
False
304
 
UG=Graph(G1)
305
 
sorted(UG.edges())
306
 
[('A', 'B'), ('A', 'C'), ('A', 'D')]
307
 
UG.has_edge('B', 'A')
308
 
True
309
 
DG=DiGraph(UG)
310
 
DG.adj==UG.adj
311
 
True
312
 
DG.remove_edge('A','B')
313
 
number_of_edges(DG)
314
 
5
315
 
UG.remove_edge('A','B')
316
 
number_of_edges(UG)
317
 
2
318
 
"""
319
 
 
 
210
    def test_directed_to_undirected(self):
 
211
        edges1 = [(0, 1), (1, 2), (2, 0)]
 
212
        edges2 = [(0, 1), (1, 2), (0, 2)]
 
213
        assert_true(self.edgelists_equal(nx.Graph(nx.DiGraph(edges1)).edges(),edges1))
 
214
        assert_true(self.edgelists_equal(nx.Graph(nx.DiGraph(edges2)).edges(),edges1))
 
215
        assert_true(self.edgelists_equal(nx.MultiGraph(nx.DiGraph(edges1)).edges(),edges1))
 
216
        assert_true(self.edgelists_equal(nx.MultiGraph(nx.DiGraph(edges2)).edges(),edges1))
 
217
 
 
218
        assert_true(self.edgelists_equal(nx.MultiGraph(nx.MultiDiGraph(edges1)).edges(),
 
219
                                         edges1))
 
220
        assert_true(self.edgelists_equal(nx.MultiGraph(nx.MultiDiGraph(edges2)).edges(),
 
221
                                         edges1))
 
222
 
 
223
        assert_true(self.edgelists_equal(nx.Graph(nx.MultiDiGraph(edges1)).edges(),edges1))
 
224
        assert_true(self.edgelists_equal(nx.Graph(nx.MultiDiGraph(edges2)).edges(),edges1))