Mercurial > repos > shellac > sam_consensus_v3

comparison env/lib/python3.9/site-packages/networkx/algorithms/operators/tests/test_binary.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 networkx.testing import assert_edges_equal
4
5
6 def test_union_attributes():
7 g = nx.Graph()
8 g.add_node(0, x=4)
9 g.add_node(1, x=5)
10 g.add_edge(0, 1, size=5)
11 g.graph["name"] = "g"
12
13 h = g.copy()
14 h.graph["name"] = "h"
15 h.graph["attr"] = "attr"
16 h.nodes[0]["x"] = 7
17
18 gh = nx.union(g, h, rename=("g", "h"))
19 assert set(gh.nodes()) == {"h0", "h1", "g0", "g1"}
20 for n in gh:
21 graph, node = n
22 assert gh.nodes[n] == eval(graph).nodes[int(node)]
23
24 assert gh.graph["attr"] == "attr"
25 assert gh.graph["name"] == "h" # h graph attributes take precendent
26
27
28 def test_intersection():
29 G = nx.Graph()
30 H = nx.Graph()
31 G.add_nodes_from([1, 2, 3, 4])
32 G.add_edge(1, 2)
33 G.add_edge(2, 3)
34 H.add_nodes_from([1, 2, 3, 4])
35 H.add_edge(2, 3)
36 H.add_edge(3, 4)
37 I = nx.intersection(G, H)
38 assert set(I.nodes()) == {1, 2, 3, 4}
39 assert sorted(I.edges()) == [(2, 3)]
40
41
42 def test_intersection_attributes():
43 g = nx.Graph()
44 g.add_node(0, x=4)
45 g.add_node(1, x=5)
46 g.add_edge(0, 1, size=5)
47 g.graph["name"] = "g"
48
49 h = g.copy()
50 h.graph["name"] = "h"
51 h.graph["attr"] = "attr"
52 h.nodes[0]["x"] = 7
53
54 gh = nx.intersection(g, h)
55 assert set(gh.nodes()) == set(g.nodes())
56 assert set(gh.nodes()) == set(h.nodes())
57 assert sorted(gh.edges()) == sorted(g.edges())
58
59 h.remove_node(0)
60 pytest.raises(nx.NetworkXError, nx.intersection, g, h)
61
62
63 def test_intersection_multigraph_attributes():
64 g = nx.MultiGraph()
65 g.add_edge(0, 1, key=0)
66 g.add_edge(0, 1, key=1)
67 g.add_edge(0, 1, key=2)
68 h = nx.MultiGraph()
69 h.add_edge(0, 1, key=0)
70 h.add_edge(0, 1, key=3)
71 gh = nx.intersection(g, h)
72 assert set(gh.nodes()) == set(g.nodes())
73 assert set(gh.nodes()) == set(h.nodes())
74 assert sorted(gh.edges()) == [(0, 1)]
75 assert sorted(gh.edges(keys=True)) == [(0, 1, 0)]
76
77
78 def test_difference():
79 G = nx.Graph()
80 H = nx.Graph()
81 G.add_nodes_from([1, 2, 3, 4])
82 G.add_edge(1, 2)
83 G.add_edge(2, 3)
84 H.add_nodes_from([1, 2, 3, 4])
85 H.add_edge(2, 3)
86 H.add_edge(3, 4)
87 D = nx.difference(G, H)
88 assert set(D.nodes()) == {1, 2, 3, 4}
89 assert sorted(D.edges()) == [(1, 2)]
90 D = nx.difference(H, G)
91 assert set(D.nodes()) == {1, 2, 3, 4}
92 assert sorted(D.edges()) == [(3, 4)]
93 D = nx.symmetric_difference(G, H)
94 assert set(D.nodes()) == {1, 2, 3, 4}
95 assert sorted(D.edges()) == [(1, 2), (3, 4)]
96
97
98 def test_difference2():
99 G = nx.Graph()
100 H = nx.Graph()
101 G.add_nodes_from([1, 2, 3, 4])
102 H.add_nodes_from([1, 2, 3, 4])
103 G.add_edge(1, 2)
104 H.add_edge(1, 2)
105 G.add_edge(2, 3)
106 D = nx.difference(G, H)
107 assert set(D.nodes()) == {1, 2, 3, 4}
108 assert sorted(D.edges()) == [(2, 3)]
109 D = nx.difference(H, G)
110 assert set(D.nodes()) == {1, 2, 3, 4}
111 assert sorted(D.edges()) == []
112 H.add_edge(3, 4)
113 D = nx.difference(H, G)
114 assert set(D.nodes()) == {1, 2, 3, 4}
115 assert sorted(D.edges()) == [(3, 4)]
116
117
118 def test_difference_attributes():
119 g = nx.Graph()
120 g.add_node(0, x=4)
121 g.add_node(1, x=5)
122 g.add_edge(0, 1, size=5)
123 g.graph["name"] = "g"
124
125 h = g.copy()
126 h.graph["name"] = "h"
127 h.graph["attr"] = "attr"
128 h.nodes[0]["x"] = 7
129
130 gh = nx.difference(g, h)
131 assert set(gh.nodes()) == set(g.nodes())
132 assert set(gh.nodes()) == set(h.nodes())
133 assert sorted(gh.edges()) == []
134
135 h.remove_node(0)
136 pytest.raises(nx.NetworkXError, nx.intersection, g, h)
137
138
139 def test_difference_multigraph_attributes():
140 g = nx.MultiGraph()
141 g.add_edge(0, 1, key=0)
142 g.add_edge(0, 1, key=1)
143 g.add_edge(0, 1, key=2)
144 h = nx.MultiGraph()
145 h.add_edge(0, 1, key=0)
146 h.add_edge(0, 1, key=3)
147 gh = nx.difference(g, h)
148 assert set(gh.nodes()) == set(g.nodes())
149 assert set(gh.nodes()) == set(h.nodes())
150 assert sorted(gh.edges()) == [(0, 1), (0, 1)]
151 assert sorted(gh.edges(keys=True)) == [(0, 1, 1), (0, 1, 2)]
152
153
154 def test_difference_raise():
155 G = nx.path_graph(4)
156 H = nx.path_graph(3)
157 pytest.raises(nx.NetworkXError, nx.difference, G, H)
158 pytest.raises(nx.NetworkXError, nx.symmetric_difference, G, H)
159
160
161 def test_symmetric_difference_multigraph():
162 g = nx.MultiGraph()
163 g.add_edge(0, 1, key=0)
164 g.add_edge(0, 1, key=1)
165 g.add_edge(0, 1, key=2)
166 h = nx.MultiGraph()
167 h.add_edge(0, 1, key=0)
168 h.add_edge(0, 1, key=3)
169 gh = nx.symmetric_difference(g, h)
170 assert set(gh.nodes()) == set(g.nodes())
171 assert set(gh.nodes()) == set(h.nodes())
172 assert sorted(gh.edges()) == 3 * [(0, 1)]
173 assert sorted(sorted(e) for e in gh.edges(keys=True)) == [
174 [0, 1, 1],
175 [0, 1, 2],
176 [0, 1, 3],
177 ]
178
179
180 def test_union_and_compose():
181 K3 = nx.complete_graph(3)
182 P3 = nx.path_graph(3)
183
184 G1 = nx.DiGraph()
185 G1.add_edge("A", "B")
186 G1.add_edge("A", "C")
187 G1.add_edge("A", "D")
188 G2 = nx.DiGraph()
189 G2.add_edge("1", "2")
190 G2.add_edge("1", "3")
191 G2.add_edge("1", "4")
192
193 G = nx.union(G1, G2)
194 H = nx.compose(G1, G2)
195 assert_edges_equal(G.edges(), H.edges())
196 assert not G.has_edge("A", 1)
197 pytest.raises(nx.NetworkXError, nx.union, K3, P3)
198 H1 = nx.union(H, G1, rename=("H", "G1"))
199 assert sorted(H1.nodes()) == [
200 "G1A",
201 "G1B",
202 "G1C",
203 "G1D",
204 "H1",
205 "H2",
206 "H3",
207 "H4",
208 "HA",
209 "HB",
210 "HC",
211 "HD",
212 ]
213
214 H2 = nx.union(H, G2, rename=("H", ""))
215 assert sorted(H2.nodes()) == [
216 "1",
217 "2",
218 "3",
219 "4",
220 "H1",
221 "H2",
222 "H3",
223 "H4",
224 "HA",
225 "HB",
226 "HC",
227 "HD",
228 ]
229
230 assert not H1.has_edge("NB", "NA")
231
232 G = nx.compose(G, G)
233 assert_edges_equal(G.edges(), H.edges())
234
235 G2 = nx.union(G2, G2, rename=("", "copy"))
236 assert sorted(G2.nodes()) == [
237 "1",
238 "2",
239 "3",
240 "4",
241 "copy1",
242 "copy2",
243 "copy3",
244 "copy4",
245 ]
246
247 assert sorted(G2.neighbors("copy4")) == []
248 assert sorted(G2.neighbors("copy1")) == ["copy2", "copy3", "copy4"]
249 assert len(G) == 8
250 assert nx.number_of_edges(G) == 6
251
252 E = nx.disjoint_union(G, G)
253 assert len(E) == 16
254 assert nx.number_of_edges(E) == 12
255
256 E = nx.disjoint_union(G1, G2)
257 assert sorted(E.nodes()) == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
258
259 G = nx.Graph()
260 H = nx.Graph()
261 G.add_nodes_from([(1, {"a1": 1})])
262 H.add_nodes_from([(1, {"b1": 1})])
263 R = nx.compose(G, H)
264 assert R.nodes == {1: {"a1": 1, "b1": 1}}
265
266
267 def test_union_multigraph():
268 G = nx.MultiGraph()
269 G.add_edge(1, 2, key=0)
270 G.add_edge(1, 2, key=1)
271 H = nx.MultiGraph()
272 H.add_edge(3, 4, key=0)
273 H.add_edge(3, 4, key=1)
274 GH = nx.union(G, H)
275 assert set(GH) == set(G) | set(H)
276 assert set(GH.edges(keys=True)) == set(G.edges(keys=True)) | set(H.edges(keys=True))
277
278
279 def test_disjoint_union_multigraph():
280 G = nx.MultiGraph()
281 G.add_edge(0, 1, key=0)
282 G.add_edge(0, 1, key=1)
283 H = nx.MultiGraph()
284 H.add_edge(2, 3, key=0)
285 H.add_edge(2, 3, key=1)
286 GH = nx.disjoint_union(G, H)
287 assert set(GH) == set(G) | set(H)
288 assert set(GH.edges(keys=True)) == set(G.edges(keys=True)) | set(H.edges(keys=True))
289
290
291 def test_compose_multigraph():
292 G = nx.MultiGraph()
293 G.add_edge(1, 2, key=0)
294 G.add_edge(1, 2, key=1)
295 H = nx.MultiGraph()
296 H.add_edge(3, 4, key=0)
297 H.add_edge(3, 4, key=1)
298 GH = nx.compose(G, H)
299 assert set(GH) == set(G) | set(H)
300 assert set(GH.edges(keys=True)) == set(G.edges(keys=True)) | set(H.edges(keys=True))
301 H.add_edge(1, 2, key=2)
302 GH = nx.compose(G, H)
303 assert set(GH) == set(G) | set(H)
304 assert set(GH.edges(keys=True)) == set(G.edges(keys=True)) | set(H.edges(keys=True))
305
306
307 def test_full_join_graph():
308 # Simple Graphs
309 G = nx.Graph()
310 G.add_node(0)
311 G.add_edge(1, 2)
312 H = nx.Graph()
313 H.add_edge(3, 4)
314
315 U = nx.full_join(G, H)
316 assert set(U) == set(G) | set(H)
317 assert len(U) == len(G) + len(H)
318 assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H)
319
320 # Rename
321 U = nx.full_join(G, H, rename=("g", "h"))
322 assert set(U) == {"g0", "g1", "g2", "h3", "h4"}
323 assert len(U) == len(G) + len(H)
324 assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H)
325
326 # Rename graphs with string-like nodes
327 G = nx.Graph()
328 G.add_node("a")
329 G.add_edge("b", "c")
330 H = nx.Graph()
331 H.add_edge("d", "e")
332
333 U = nx.full_join(G, H, rename=("g", "h"))
334 assert set(U) == {"ga", "gb", "gc", "hd", "he"}
335 assert len(U) == len(G) + len(H)
336 assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H)
337
338 # DiGraphs
339 G = nx.DiGraph()
340 G.add_node(0)
341 G.add_edge(1, 2)
342 H = nx.DiGraph()
343 H.add_edge(3, 4)
344
345 U = nx.full_join(G, H)
346 assert set(U) == set(G) | set(H)
347 assert len(U) == len(G) + len(H)
348 assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H) * 2
349
350 # DiGraphs Rename
351 U = nx.full_join(G, H, rename=("g", "h"))
352 assert set(U) == {"g0", "g1", "g2", "h3", "h4"}
353 assert len(U) == len(G) + len(H)
354 assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H) * 2
355
356
357 def test_full_join_multigraph():
358 # MultiGraphs
359 G = nx.MultiGraph()
360 G.add_node(0)
361 G.add_edge(1, 2)
362 H = nx.MultiGraph()
363 H.add_edge(3, 4)
364
365 U = nx.full_join(G, H)
366 assert set(U) == set(G) | set(H)
367 assert len(U) == len(G) + len(H)
368 assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H)
369
370 # MultiGraphs rename
371 U = nx.full_join(G, H, rename=("g", "h"))
372 assert set(U) == {"g0", "g1", "g2", "h3", "h4"}
373 assert len(U) == len(G) + len(H)
374 assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H)
375
376 # MultiDiGraphs
377 G = nx.MultiDiGraph()
378 G.add_node(0)
379 G.add_edge(1, 2)
380 H = nx.MultiDiGraph()
381 H.add_edge(3, 4)
382
383 U = nx.full_join(G, H)
384 assert set(U) == set(G) | set(H)
385 assert len(U) == len(G) + len(H)
386 assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H) * 2
387
388 # MultiDiGraphs rename
389 U = nx.full_join(G, H, rename=("g", "h"))
390 assert set(U) == {"g0", "g1", "g2", "h3", "h4"}
391 assert len(U) == len(G) + len(H)
392 assert len(U.edges()) == len(G.edges()) + len(H.edges()) + len(G) * len(H) * 2
393
394
395 def test_mixed_type_union():
396 G = nx.Graph()
397 H = nx.MultiGraph()
398 pytest.raises(nx.NetworkXError, nx.union, G, H)
399 pytest.raises(nx.NetworkXError, nx.disjoint_union, G, H)
400 pytest.raises(nx.NetworkXError, nx.intersection, G, H)
401 pytest.raises(nx.NetworkXError, nx.difference, G, H)
402 pytest.raises(nx.NetworkXError, nx.symmetric_difference, G, H)
403 pytest.raises(nx.NetworkXError, nx.compose, G, H)