← Back to branch summary

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

« back to all changes in this revision

Viewing changes to networkx/algorithms/operators/tests/test_binary.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/algorithms/operators/tests/test_binary.py
 
1
from nose.tools import *
 
2
import networkx as nx
 
3
from networkx import *
 
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.node[0]['x'] = 7
 
17
 
 
18
    gh = nx.union(g, h, rename=('g', 'h'))
 
19
    assert_equal( set(gh.nodes()) , set(['h0', 'h1', 'g0', 'g1']) )
 
20
    for n in gh:
 
21
        graph, node = n
 
22
        assert_equal( gh.node[n], eval(graph).node[int(node)] )
 
23
 
 
24
    assert_equal(gh.graph['attr'],'attr')
 
25
    assert_equal(gh.graph['name'],'h') # h graph attributes take precendent
 
26
 
 
27
def test_intersection():
 
28
    G=nx.Graph()
 
29
    H=nx.Graph()
 
30
    G.add_nodes_from([1,2,3,4])
 
31
    G.add_edge(1,2)
 
32
    G.add_edge(2,3)
 
33
    H.add_nodes_from([1,2,3,4])
 
34
    H.add_edge(2,3)
 
35
    H.add_edge(3,4)
 
36
    I=nx.intersection(G,H)
 
37
    assert_equal( set(I.nodes()) , set([1,2,3,4]) )    
 
38
    assert_equal( sorted(I.edges()) , [(2,3)] )    
 
39
 
 
40
 
 
41
def test_intersection_attributes():
 
42
    g = nx.Graph()
 
43
    g.add_node(0, x=4)
 
44
    g.add_node(1, x=5)
 
45
    g.add_edge(0, 1, size=5)
 
46
    g.graph['name'] = 'g'
 
47
 
 
48
    h = g.copy()
 
49
    h.graph['name'] = 'h'
 
50
    h.graph['attr'] = 'attr'
 
51
    h.node[0]['x'] = 7
 
52
 
 
53
    gh = nx.intersection(g, h)
 
54
    assert_equal( set(gh.nodes()) , set(g.nodes()) )
 
55
    assert_equal( set(gh.nodes()) , set(h.nodes()) )
 
56
    assert_equal( sorted(gh.edges()) , sorted(g.edges()) )
 
57
 
 
58
    h.remove_node(0)
 
59
    assert_raises(nx.NetworkXError, nx.intersection, g, h)
 
60
 
 
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_equal( set(gh.nodes()) , set(g.nodes()) )
 
73
    assert_equal( set(gh.nodes()) , set(h.nodes()) )
 
74
    assert_equal( sorted(gh.edges()) , [(0,1)] )
 
75
    assert_equal( 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_equal( set(D.nodes()) , set([1,2,3,4]) )    
 
89
    assert_equal( sorted(D.edges()) , [(1,2)] )    
 
90
    D=nx.difference(H,G)
 
91
    assert_equal( set(D.nodes()) , set([1,2,3,4]) )    
 
92
    assert_equal( sorted(D.edges()) , [(3,4)] )    
 
93
    D=nx.symmetric_difference(G,H)
 
94
    assert_equal( set(D.nodes()) , set([1,2,3,4]) )    
 
95
    assert_equal( 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_equal( set(D.nodes()) , set([1,2,3,4]) )    
 
108
    assert_equal( sorted(D.edges()) , [(2,3)] )    
 
109
    D=nx.difference(H,G)
 
110
    assert_equal( set(D.nodes()) , set([1,2,3,4]) )    
 
111
    assert_equal( sorted(D.edges()) , [] )    
 
112
    H.add_edge(3,4)
 
113
    D=nx.difference(H,G)
 
114
    assert_equal( set(D.nodes()) , set([1,2,3,4]) )    
 
115
    assert_equal( 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.node[0]['x'] = 7
 
129
 
 
130
    gh = nx.difference(g, h)
 
131
    assert_equal( set(gh.nodes()) , set(g.nodes()) )
 
132
    assert_equal( set(gh.nodes()) , set(h.nodes()) )
 
133
    assert_equal( sorted(gh.edges()) , [])
 
134
 
 
135
    h.remove_node(0)
 
136
    assert_raises(nx.NetworkXError, nx.intersection, g, h)
 
137
 
 
138
def test_difference_multigraph_attributes():
 
139
    g = nx.MultiGraph()
 
140
    g.add_edge(0, 1, key=0)
 
141
    g.add_edge(0, 1, key=1)
 
142
    g.add_edge(0, 1, key=2)
 
143
    h = nx.MultiGraph()
 
144
    h.add_edge(0, 1, key=0)
 
145
    h.add_edge(0, 1, key=3)
 
146
    gh = nx.difference(g, h)
 
147
    assert_equal( set(gh.nodes()) , set(g.nodes()) )
 
148
    assert_equal( set(gh.nodes()) , set(h.nodes()) )
 
149
    assert_equal( sorted(gh.edges()) , [(0,1),(0,1)] )
 
150
    assert_equal( sorted(gh.edges(keys=True)) , [(0,1,1),(0,1,2)] )
 
151
 
 
152
 
 
153
@raises(nx.NetworkXError)
 
154
def test_difference_raise():
 
155
    G = nx.path_graph(4)
 
156
    H = nx.path_graph(3)
 
157
    GH = nx.difference(G, H)
 
158
 
 
159
def test_symmetric_difference_multigraph():
 
160
    g = nx.MultiGraph()
 
161
    g.add_edge(0, 1, key=0)
 
162
    g.add_edge(0, 1, key=1)
 
163
    g.add_edge(0, 1, key=2)
 
164
    h = nx.MultiGraph()
 
165
    h.add_edge(0, 1, key=0)
 
166
    h.add_edge(0, 1, key=3)
 
167
    gh = nx.symmetric_difference(g, h)
 
168
    assert_equal( set(gh.nodes()) , set(g.nodes()) )
 
169
    assert_equal( set(gh.nodes()) , set(h.nodes()) )
 
170
    assert_equal( sorted(gh.edges()) , 3*[(0,1)] )
 
171
    assert_equal( sorted(sorted(e) for e in gh.edges(keys=True)), 
 
172
                  [[0,1,1],[0,1,2],[0,1,3]] )
 
173
 
 
174
@raises(nx.NetworkXError)
 
175
def test_symmetric_difference_raise():
 
176
    G = nx.path_graph(4)
 
177
    H = nx.path_graph(3)
 
178
    GH = nx.symmetric_difference(G, H)
 
179
 
 
180
def test_union_and_compose():
 
181
    K3=complete_graph(3)
 
182
    P3=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=union(G1,G2)
 
194
    H=compose(G1,G2)
 
195
    assert_true(G.edges()==H.edges())
 
196
    assert_false(G.has_edge('A',1))
 
197
    assert_raises(nx.NetworkXError, nx.union, K3, P3)
 
198
    H1=union(H,G1,rename=('H','G1'))
 
199
    assert_equal(sorted(H1.nodes()),
 
200
                 ['G1A', 'G1B', 'G1C', 'G1D', 
 
201
                  'H1', 'H2', 'H3', 'H4', 'HA', 'HB', 'HC', 'HD'])
 
202
 
 
203
    H2=union(H,G2,rename=("H",""))
 
204
    assert_equal(sorted(H2.nodes()),
 
205
                 ['1', '2', '3', '4', 
 
206
                  'H1', 'H2', 'H3', 'H4', 'HA', 'HB', 'HC', 'HD'])
 
207
 
 
208
    assert_false(H1.has_edge('NB','NA'))
 
209
 
 
210
    G=compose(G,G)
 
211
    assert_equal(G.edges(),H.edges())
 
212
 
 
213
    G2=union(G2,G2,rename=('','copy'))
 
214
    assert_equal(sorted(G2.nodes()),
 
215
                 ['1', '2', '3', '4', 'copy1', 'copy2', 'copy3', 'copy4'])
 
216
 
 
217
    assert_equal(G2.neighbors('copy4'),[])
 
218
    assert_equal(sorted(G2.neighbors('copy1')),['copy2', 'copy3', 'copy4'])
 
219
    assert_equal(len(G),8)
 
220
    assert_equal(number_of_edges(G),6)
 
221
 
 
222
    E=disjoint_union(G,G)
 
223
    assert_equal(len(E),16)
 
224
    assert_equal(number_of_edges(E),12)
 
225
 
 
226
    E=disjoint_union(G1,G2)
 
227
    assert_equal(sorted(E.nodes()),[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
 
228
 
 
229
 
 
230
def test_union_multigraph():
 
231
    G=nx.MultiGraph()
 
232
    G.add_edge(1,2,key=0)
 
233
    G.add_edge(1,2,key=1)
 
234
    H=nx.MultiGraph()
 
235
    H.add_edge(3,4,key=0)
 
236
    H.add_edge(3,4,key=1)
 
237
    GH=nx.union(G,H)
 
238
    assert_equal( set(GH) , set(G)|set(H))
 
239
    assert_equal( set(GH.edges(keys=True)) , 
 
240
                  set(G.edges(keys=True))|set(H.edges(keys=True)))
 
241
 
 
242
def test_disjoint_union_multigraph():
 
243
    G=nx.MultiGraph()
 
244
    G.add_edge(0,1,key=0)
 
245
    G.add_edge(0,1,key=1)
 
246
    H=nx.MultiGraph()
 
247
    H.add_edge(2,3,key=0)
 
248
    H.add_edge(2,3,key=1)
 
249
    GH=nx.disjoint_union(G,H)
 
250
    assert_equal( set(GH) , set(G)|set(H))
 
251
    assert_equal( set(GH.edges(keys=True)) , 
 
252
                  set(G.edges(keys=True))|set(H.edges(keys=True)))
 
253
 
 
254
 
 
255
def test_compose_multigraph():
 
256
    G=nx.MultiGraph()
 
257
    G.add_edge(1,2,key=0)
 
258
    G.add_edge(1,2,key=1)
 
259
    H=nx.MultiGraph()
 
260
    H.add_edge(3,4,key=0)
 
261
    H.add_edge(3,4,key=1)
 
262
    GH=nx.compose(G,H)
 
263
    assert_equal( set(GH) , set(G)|set(H))
 
264
    assert_equal( set(GH.edges(keys=True)) , 
 
265
                  set(G.edges(keys=True))|set(H.edges(keys=True)))
 
266
    H.add_edge(1,2,key=2)
 
267
    GH=nx.compose(G,H)
 
268
    assert_equal( set(GH) , set(G)|set(H))
 
269
    assert_equal( set(GH.edges(keys=True)) , 
 
270
                  set(G.edges(keys=True))|set(H.edges(keys=True)))