Mercurial > repos > shellac > sam_consensus_v3

comparison env/lib/python3.9/site-packages/networkx/algorithms/bipartite/tests/test_generators.py @ 0:4f3585e2f14b draft default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
"planemo upload commit 60cee0fc7c0cda8592644e1aad72851dec82c959"
author shellac
date Mon, 22 Mar 2021 18:12:50 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:4f3585e2f14b
1 import pytest
2 import networkx as nx
3 from ..generators import (
4 alternating_havel_hakimi_graph,
5 complete_bipartite_graph,
6 configuration_model,
7 gnmk_random_graph,
8 havel_hakimi_graph,
9 preferential_attachment_graph,
10 random_graph,
11 reverse_havel_hakimi_graph,
12 )
13
14 """
15 Generators - Bipartite
16 ----------------------
17 """
18
19
20 class TestGeneratorsBipartite:
21 def test_complete_bipartite_graph(self):
22 G = complete_bipartite_graph(0, 0)
23 assert nx.is_isomorphic(G, nx.null_graph())
24
25 for i in [1, 5]:
26 G = complete_bipartite_graph(i, 0)
27 assert nx.is_isomorphic(G, nx.empty_graph(i))
28 G = complete_bipartite_graph(0, i)
29 assert nx.is_isomorphic(G, nx.empty_graph(i))
30
31 G = complete_bipartite_graph(2, 2)
32 assert nx.is_isomorphic(G, nx.cycle_graph(4))
33
34 G = complete_bipartite_graph(1, 5)
35 assert nx.is_isomorphic(G, nx.star_graph(5))
36
37 G = complete_bipartite_graph(5, 1)
38 assert nx.is_isomorphic(G, nx.star_graph(5))
39
40 # complete_bipartite_graph(m1,m2) is a connected graph with
41 # m1+m2 nodes and m1*m2 edges
42 for m1, m2 in [(5, 11), (7, 3)]:
43 G = complete_bipartite_graph(m1, m2)
44 assert nx.number_of_nodes(G) == m1 + m2
45 assert nx.number_of_edges(G) == m1 * m2
46
47 pytest.raises(
48 nx.NetworkXError, complete_bipartite_graph, 7, 3, create_using=nx.DiGraph
49 )
50 pytest.raises(
51 nx.NetworkXError, complete_bipartite_graph, 7, 3, create_using=nx.DiGraph
52 )
53 pytest.raises(
54 nx.NetworkXError,
55 complete_bipartite_graph,
56 7,
57 3,
58 create_using=nx.MultiDiGraph,
59 )
60
61 mG = complete_bipartite_graph(7, 3, create_using=nx.MultiGraph)
62 assert mG.is_multigraph()
63 assert sorted(mG.edges()) == sorted(G.edges())
64
65 mG = complete_bipartite_graph(7, 3, create_using=nx.MultiGraph)
66 assert mG.is_multigraph()
67 assert sorted(mG.edges()) == sorted(G.edges())
68
69 mG = complete_bipartite_graph(7, 3) # default to Graph
70 assert sorted(mG.edges()) == sorted(G.edges())
71 assert not mG.is_multigraph()
72 assert not mG.is_directed()
73
74 # specify nodes rather than number of nodes
75 G = complete_bipartite_graph([1, 2], ["a", "b"])
76 has_edges = (
77 G.has_edge(1, "a")
78 & G.has_edge(1, "b")
79 & G.has_edge(2, "a")
80 & G.has_edge(2, "b")
81 )
82 assert has_edges
83 assert G.size() == 4
84
85 def test_configuration_model(self):
86 aseq = []
87 bseq = []
88 G = configuration_model(aseq, bseq)
89 assert len(G) == 0
90
91 aseq = [0, 0]
92 bseq = [0, 0]
93 G = configuration_model(aseq, bseq)
94 assert len(G) == 4
95 assert G.number_of_edges() == 0
96
97 aseq = [3, 3, 3, 3]
98 bseq = [2, 2, 2, 2, 2]
99 pytest.raises(nx.NetworkXError, configuration_model, aseq, bseq)
100
101 aseq = [3, 3, 3, 3]
102 bseq = [2, 2, 2, 2, 2, 2]
103 G = configuration_model(aseq, bseq)
104 assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
105
106 aseq = [2, 2, 2, 2, 2, 2]
107 bseq = [3, 3, 3, 3]
108 G = configuration_model(aseq, bseq)
109 assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
110
111 aseq = [2, 2, 2, 1, 1, 1]
112 bseq = [3, 3, 3]
113 G = configuration_model(aseq, bseq)
114 assert G.is_multigraph()
115 assert not G.is_directed()
116 assert sorted(d for n, d in G.degree()) == [1, 1, 1, 2, 2, 2, 3, 3, 3]
117
118 GU = nx.project(nx.Graph(G), range(len(aseq)))
119 assert GU.number_of_nodes() == 6
120
121 GD = nx.project(nx.Graph(G), range(len(aseq), len(aseq) + len(bseq)))
122 assert GD.number_of_nodes() == 3
123
124 G = reverse_havel_hakimi_graph(aseq, bseq, create_using=nx.Graph)
125 assert not G.is_multigraph()
126 assert not G.is_directed()
127
128 pytest.raises(
129 nx.NetworkXError, configuration_model, aseq, bseq, create_using=nx.DiGraph()
130 )
131 pytest.raises(
132 nx.NetworkXError, configuration_model, aseq, bseq, create_using=nx.DiGraph
133 )
134 pytest.raises(
135 nx.NetworkXError,
136 configuration_model,
137 aseq,
138 bseq,
139 create_using=nx.MultiDiGraph,
140 )
141
142 def test_havel_hakimi_graph(self):
143 aseq = []
144 bseq = []
145 G = havel_hakimi_graph(aseq, bseq)
146 assert len(G) == 0
147
148 aseq = [0, 0]
149 bseq = [0, 0]
150 G = havel_hakimi_graph(aseq, bseq)
151 assert len(G) == 4
152 assert G.number_of_edges() == 0
153
154 aseq = [3, 3, 3, 3]
155 bseq = [2, 2, 2, 2, 2]
156 pytest.raises(nx.NetworkXError, havel_hakimi_graph, aseq, bseq)
157
158 bseq = [2, 2, 2, 2, 2, 2]
159 G = havel_hakimi_graph(aseq, bseq)
160 assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
161
162 aseq = [2, 2, 2, 2, 2, 2]
163 bseq = [3, 3, 3, 3]
164 G = havel_hakimi_graph(aseq, bseq)
165 assert G.is_multigraph()
166 assert not G.is_directed()
167 assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
168
169 GU = nx.project(nx.Graph(G), range(len(aseq)))
170 assert GU.number_of_nodes() == 6
171
172 GD = nx.project(nx.Graph(G), range(len(aseq), len(aseq) + len(bseq)))
173 assert GD.number_of_nodes() == 4
174
175 G = reverse_havel_hakimi_graph(aseq, bseq, create_using=nx.Graph)
176 assert not G.is_multigraph()
177 assert not G.is_directed()
178
179 pytest.raises(
180 nx.NetworkXError, havel_hakimi_graph, aseq, bseq, create_using=nx.DiGraph
181 )
182 pytest.raises(
183 nx.NetworkXError, havel_hakimi_graph, aseq, bseq, create_using=nx.DiGraph
184 )
185 pytest.raises(
186 nx.NetworkXError,
187 havel_hakimi_graph,
188 aseq,
189 bseq,
190 create_using=nx.MultiDiGraph,
191 )
192
193 def test_reverse_havel_hakimi_graph(self):
194 aseq = []
195 bseq = []
196 G = reverse_havel_hakimi_graph(aseq, bseq)
197 assert len(G) == 0
198
199 aseq = [0, 0]
200 bseq = [0, 0]
201 G = reverse_havel_hakimi_graph(aseq, bseq)
202 assert len(G) == 4
203 assert G.number_of_edges() == 0
204
205 aseq = [3, 3, 3, 3]
206 bseq = [2, 2, 2, 2, 2]
207 pytest.raises(nx.NetworkXError, reverse_havel_hakimi_graph, aseq, bseq)
208
209 bseq = [2, 2, 2, 2, 2, 2]
210 G = reverse_havel_hakimi_graph(aseq, bseq)
211 assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
212
213 aseq = [2, 2, 2, 2, 2, 2]
214 bseq = [3, 3, 3, 3]
215 G = reverse_havel_hakimi_graph(aseq, bseq)
216 assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
217
218 aseq = [2, 2, 2, 1, 1, 1]
219 bseq = [3, 3, 3]
220 G = reverse_havel_hakimi_graph(aseq, bseq)
221 assert G.is_multigraph()
222 assert not G.is_directed()
223 assert sorted(d for n, d in G.degree()) == [1, 1, 1, 2, 2, 2, 3, 3, 3]
224
225 GU = nx.project(nx.Graph(G), range(len(aseq)))
226 assert GU.number_of_nodes() == 6
227
228 GD = nx.project(nx.Graph(G), range(len(aseq), len(aseq) + len(bseq)))
229 assert GD.number_of_nodes() == 3
230
231 G = reverse_havel_hakimi_graph(aseq, bseq, create_using=nx.Graph)
232 assert not G.is_multigraph()
233 assert not G.is_directed()
234
235 pytest.raises(
236 nx.NetworkXError,
237 reverse_havel_hakimi_graph,
238 aseq,
239 bseq,
240 create_using=nx.DiGraph,
241 )
242 pytest.raises(
243 nx.NetworkXError,
244 reverse_havel_hakimi_graph,
245 aseq,
246 bseq,
247 create_using=nx.DiGraph,
248 )
249 pytest.raises(
250 nx.NetworkXError,
251 reverse_havel_hakimi_graph,
252 aseq,
253 bseq,
254 create_using=nx.MultiDiGraph,
255 )
256
257 def test_alternating_havel_hakimi_graph(self):
258 aseq = []
259 bseq = []
260 G = alternating_havel_hakimi_graph(aseq, bseq)
261 assert len(G) == 0
262
263 aseq = [0, 0]
264 bseq = [0, 0]
265 G = alternating_havel_hakimi_graph(aseq, bseq)
266 assert len(G) == 4
267 assert G.number_of_edges() == 0
268
269 aseq = [3, 3, 3, 3]
270 bseq = [2, 2, 2, 2, 2]
271 pytest.raises(nx.NetworkXError, alternating_havel_hakimi_graph, aseq, bseq)
272
273 bseq = [2, 2, 2, 2, 2, 2]
274 G = alternating_havel_hakimi_graph(aseq, bseq)
275 assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
276
277 aseq = [2, 2, 2, 2, 2, 2]
278 bseq = [3, 3, 3, 3]
279 G = alternating_havel_hakimi_graph(aseq, bseq)
280 assert sorted(d for n, d in G.degree()) == [2, 2, 2, 2, 2, 2, 3, 3, 3, 3]
281
282 aseq = [2, 2, 2, 1, 1, 1]
283 bseq = [3, 3, 3]
284 G = alternating_havel_hakimi_graph(aseq, bseq)
285 assert G.is_multigraph()
286 assert not G.is_directed()
287 assert sorted(d for n, d in G.degree()) == [1, 1, 1, 2, 2, 2, 3, 3, 3]
288
289 GU = nx.project(nx.Graph(G), range(len(aseq)))
290 assert GU.number_of_nodes() == 6
291
292 GD = nx.project(nx.Graph(G), range(len(aseq), len(aseq) + len(bseq)))
293 assert GD.number_of_nodes() == 3
294
295 G = reverse_havel_hakimi_graph(aseq, bseq, create_using=nx.Graph)
296 assert not G.is_multigraph()
297 assert not G.is_directed()
298
299 pytest.raises(
300 nx.NetworkXError,
301 alternating_havel_hakimi_graph,
302 aseq,
303 bseq,
304 create_using=nx.DiGraph,
305 )
306 pytest.raises(
307 nx.NetworkXError,
308 alternating_havel_hakimi_graph,
309 aseq,
310 bseq,
311 create_using=nx.DiGraph,
312 )
313 pytest.raises(
314 nx.NetworkXError,
315 alternating_havel_hakimi_graph,
316 aseq,
317 bseq,
318 create_using=nx.MultiDiGraph,
319 )
320
321 def test_preferential_attachment(self):
322 aseq = [3, 2, 1, 1]
323 G = preferential_attachment_graph(aseq, 0.5)
324 assert G.is_multigraph()
325 assert not G.is_directed()
326
327 G = preferential_attachment_graph(aseq, 0.5, create_using=nx.Graph)
328 assert not G.is_multigraph()
329 assert not G.is_directed()
330
331 pytest.raises(
332 nx.NetworkXError,
333 preferential_attachment_graph,
334 aseq,
335 0.5,
336 create_using=nx.DiGraph(),
337 )
338 pytest.raises(
339 nx.NetworkXError,
340 preferential_attachment_graph,
341 aseq,
342 0.5,
343 create_using=nx.DiGraph(),
344 )
345 pytest.raises(
346 nx.NetworkXError,
347 preferential_attachment_graph,
348 aseq,
349 0.5,
350 create_using=nx.DiGraph(),
351 )
352
353 def test_random_graph(self):
354 n = 10
355 m = 20
356 G = random_graph(n, m, 0.9)
357 assert len(G) == 30
358 assert nx.is_bipartite(G)
359 X, Y = nx.algorithms.bipartite.sets(G)
360 assert set(range(n)) == X
361 assert set(range(n, n + m)) == Y
362
363 def test_random_digraph(self):
364 n = 10
365 m = 20
366 G = random_graph(n, m, 0.9, directed=True)
367 assert len(G) == 30
368 assert nx.is_bipartite(G)
369 X, Y = nx.algorithms.bipartite.sets(G)
370 assert set(range(n)) == X
371 assert set(range(n, n + m)) == Y
372
373 def test_gnmk_random_graph(self):
374 n = 10
375 m = 20
376 edges = 100
377 # set seed because sometimes it is not connected
378 # which raises an error in bipartite.sets(G) below.
379 G = gnmk_random_graph(n, m, edges, seed=1234)
380 assert len(G) == n + m
381 assert nx.is_bipartite(G)
382 X, Y = nx.algorithms.bipartite.sets(G)
383 # print(X)
384 assert set(range(n)) == X
385 assert set(range(n, n + m)) == Y
386 assert edges == len(list(G.edges()))
387
388 def test_gnmk_random_graph_complete(self):
389 n = 10
390 m = 20
391 edges = 200
392 G = gnmk_random_graph(n, m, edges)
393 assert len(G) == n + m
394 assert nx.is_bipartite(G)
395 X, Y = nx.algorithms.bipartite.sets(G)
396 # print(X)
397 assert set(range(n)) == X
398 assert set(range(n, n + m)) == Y
399 assert edges == len(list(G.edges()))