def test_embeddedness(self):
assert_equal(cb.cmty_embeddedness(gb),
{0:(3*4/float(3*4+1)), 1:2*3/float(2*3+1)})
g = networkx.complete_graph(5)
c = cmty.Communities({0:set(range(5))})
assert_equal(c.cmty_embeddedness(g)[0],
1.0)
g = networkx.path_graph(5)
c = cmty.Communities({0:set(range(5))})
assert_equal(c.cmty_embeddedness(g)[0],
1.0)
# Singleton comm
g = networkx.complete_graph(1)
c = cmty.Communities({0:set(range(1))})
assert_equal(c.cmty_embeddedness(g)[0],
0.0)
# Empty comm
g = networkx.complete_graph(0)
c = cmty.Communities({0:set(range(0))})
assert_equal(c.cmty_embeddedness(g)[0],
0.0)
# Total embeddednesses
ce = (4*3/(4*3+1.) * 4 + 3*2/(3*2+1.) * 3) / (4+3)
assert_equal(cb.tot_embeddedness(gb), ce)
def test_cmty_graph():
# Test cmty_graph:
g = networkx.complete_graph(7)
g.remove_edge(3, 5)
g.remove_edge(1, 2)
cmtys = cmty.Communities({0:set((0,1,2)), 1:set((3,4)), 'a':set((5,6))})
cmty_graph = cmtys.cmty_graph(g)
assert cmty_graph.node[0]['size'] == 3 # number of nodes
assert cmty_graph.node[0]['weight'] == 2 # edges within cmty
assert cmty_graph.node['a']['size'] == 2
assert cmty_graph.node['a']['weight'] == 1
assert cmty_graph[0][1]['weight'] == 6 # edges between
assert cmty_graph[1]['a']['weight'] == 3
assert cmty_graph['a'][0]['weight'] == 6
# Test cmty_graph on directed graph:
g = networkx.complete_graph(7, create_using=networkx.DiGraph())
g.remove_edge(3, 5)
g.remove_edge(1, 2)
cmtys = cmty.Communities({0:set((0,1,2)), 1:set((3,4)), 'a':set((5,6))})
cmty_graph = cmtys.cmty_graph(g)
assert cmty_graph.node[0]['size'] == 3 # number of nodes
assert cmty_graph.node[0]['weight'] == 5 # edges within cmty
assert cmty_graph.node['a']['size'] == 2
assert cmty_graph.node['a']['weight'] == 2
assert cmty_graph[0][1]['weight'] == 6 # edges between
assert cmty_graph[1][0]['weight'] == 6
assert cmty_graph[1]['a']['weight'] == 3
assert cmty_graph['a'][1]['weight'] == 4
assert cmty_graph['a'][0]['weight'] == 6
assert cmty_graph[0]['a']['weight'] == 6
def test_complete_subgraph(self):
# Subgraph of a complete graph is a complete graph
K1 = nx.complete_graph(1)
K3 = nx.complete_graph(3)
K5 = nx.complete_graph(5)
H = K5.subgraph([1, 2, 3])
assert_true(nx.is_isomorphic(H, K3))
def test_white_harary_paper():
# Figure 1b white and harary (2001)
# http://eclectic.ss.uci.edu/~drwhite/sm-w23.PDF
# A graph with high adhesion (edge connectivity) and low cohesion
# (node connectivity)
G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4))
G.remove_node(7)
for i in range(4, 7):
G.add_edge(0, i)
G = nx.disjoint_union(G, nx.complete_graph(4))
G.remove_node(G.order() - 1)
for i in range(7, 10):
G.add_edge(0, i)
for flow_func in flow_funcs:
kwargs = dict(flow_func=flow_func)
# edge cuts
edge_cut = nx.minimum_edge_cut(G, **kwargs)
assert_equal(3, len(edge_cut), msg=msg.format(flow_func.__name__))
H = G.copy()
H.remove_edges_from(edge_cut)
assert_false(nx.is_connected(H), msg=msg.format(flow_func.__name__))
# node cuts
node_cut = nx.minimum_node_cut(G, **kwargs)
assert_equal(set([0]), node_cut, msg=msg.format(flow_func.__name__))
H = G.copy()
H.remove_nodes_from(node_cut)
assert_false(nx.is_connected(H), msg=msg.format(flow_func.__name__))
def test_cartesian_product_null():
null=nx.null_graph()
empty10=nx.empty_graph(10)
K3=nx.complete_graph(3)
K10=nx.complete_graph(10)
P3=nx.path_graph(3)
P10=nx.path_graph(10)
# null graph
G=cartesian_product(null,null)
assert_true(nx.is_isomorphic(G,null))
# null_graph X anything = null_graph and v.v.
G=cartesian_product(null,empty10)
assert_true(nx.is_isomorphic(G,null))
G=cartesian_product(null,K3)
assert_true(nx.is_isomorphic(G,null))
G=cartesian_product(null,K10)
assert_true(nx.is_isomorphic(G,null))
G=cartesian_product(null,P3)
assert_true(nx.is_isomorphic(G,null))
G=cartesian_product(null,P10)
assert_true(nx.is_isomorphic(G,null))
G=cartesian_product(empty10,null)
assert_true(nx.is_isomorphic(G,null))
G=cartesian_product(K3,null)
assert_true(nx.is_isomorphic(G,null))
G=cartesian_product(K10,null)
assert_true(nx.is_isomorphic(G,null))
G=cartesian_product(P3,null)
assert_true(nx.is_isomorphic(G,null))
G=cartesian_product(P10,null)
assert_true(nx.is_isomorphic(G,null))
def Type2AlmostCompleteGraph(n, m):
if (BinomialCoefficient(n - 2, 2) + 4 <= m) and (m <= BinomialCoefficient(n - 1, 2) + 1):
first_candidate = nx.complete_graph(n - 2)
remaining_edges = m - BinomialCoefficient(n - 2, 2)
first_candidate.add_edge(n - 2, 0)
first_candidate.add_edge(n - 2, 1)
for vertex_index in range(remaining_edges - 2):
first_candidate.add_edge(n - 1, vertex_index)
first_coefficient = nx.average_clustering(first_candidate)
second_candidate = nx.complete_graph(n - 2)
second_candidate.add_edge(n - 2, n - 1)
remaining_edges = m - BinomialCoefficient(n - 2, 2) - 1
number_of_common_neighbors = remaining_edges / 2
for vertex_index in range(number_of_common_neighbors):
second_candidate.add_edge(vertex_index, n - 2)
second_candidate.add_edge(vertex_index, n - 1)
if (remaining_edges - 2 * number_of_common_neighbors) == 1:
second_candidate.add_edge(vertex_index + 1, n - 2)
second_coefficient = nx.average_clustering(second_candidate)
if first_coefficient > second_coefficient:
G = first_candidate.copy()
else:
G = second_candidate.copy()
return G
def test_holme():
for N in (5, 10, 15):
for m in (1, 2, 3, 4):
m0 = max(3, m+1) # must reproduce logic of the model.
g = HolmeGraph.get(N=N, m=m, Pt=1, m0=m0)
assert_equal(g.number_of_edges(), (N-m0)*m)
for N in (5, 10, 15):
for m in (1, 2, 3, 4):
m0 = max(3, m+1) # must reproduce logic of the model.
g = HolmeGraph.get(N=N, m=m, Pt=.5, m0=m0)
assert_equal(g.number_of_edges(), (N-m0)*m)
# Should return itself
g0 = networkx.complete_graph(5)
g = HolmeGraph.get(N=5, m=3, Pt=1, g0=g0)
assert_equal(networkx.triangles(g), dict((i,4*3/2) for i in range(5)))
# Test number of triangles created for new nodes.
g0 = networkx.complete_graph(5)
g = HolmeGraph.get(N=6, m=3, Pt=1, g0=g0)
assert_equal(networkx.triangles(g)[5], 3)
g0 = networkx.complete_graph(6)
g = HolmeGraph.get(N=7, m=3, Pt=1, g0=g0)
assert_equal(networkx.triangles(g)[6], 3)
# Test number of triangles created for new nodes.
def _make():
g = HolmeGraph.get(N=6, m=3, m0=5, Pt=0)
return networkx.triangles(g)
sizes = [_make() for _ in range(10)]
assert_true(any(_[5]==0 for _ in sizes))
def test_sld(self):
assert_equal(cb.cmty_scaledlinkdensities(gb),
{0:4, 1:3})
g = networkx.complete_graph(5)
c = cmty.Communities({0:set(range(5))})
assert_equal(c.cmty_scaledlinkdensities(g)[0], 5)
g = networkx.path_graph(5)
c = cmty.Communities({0:set(range(5))})
assert_equal(c.cmty_scaledlinkdensities(g)[0], 2)
# Singleton comm
g = networkx.complete_graph(1)
c = cmty.Communities({0:set(range(1))})
assert_equal(c.cmty_scaledlinkdensities(g)[0], 0.0)
# Empty comm
g = networkx.complete_graph(0)
c = cmty.Communities({0:set(range(0))})
assert_equal(c.cmty_scaledlinkdensities(g)[0], 0.0)
# Total SLD
ce = (4 * 4 + 3 * 3) / float(4+3)
assert_equal(cb.tot_scaledlinkdensity(gb), ce)
def test_merge_graphs_adding_special_attributes():
mother_dag = nx.complete_graph(4)
new_dag = add_subgraph_specific_attributes_to_graph(
mother_graph=mother_dag,
children_graphs_with_attrs=[(nx.complete_graph(2), {'pair': True}),
(nx.complete_graph(3), {'triple': True})]
)
for n in new_dag.nodes():
print(n, new_dag.node[n])
for s, t in new_dag.edges():
print(s, t, new_dag[s][t])
assert_true(new_dag.node[0]['pair'])
assert_true(new_dag.node[0]['triple'])
assert_true(new_dag.node[1]['pair'])
assert_true(new_dag.node[1]['triple'])
assert_true(new_dag[0][1]['pair'])
assert_true(new_dag[0][1]['triple'])
assert_true('triple' in new_dag[0][1])
assert_false('pair' in new_dag[1][2])
assert_false('pair' in new_dag[3])
assert_false('triple' in new_dag[3])
def torrents_and_ferraro_graph():
G = nx.convert_node_labels_to_integers(nx.grid_graph([5, 5]),
label_attribute='labels')
rlabels = nx.get_node_attributes(G, 'labels')
labels = {v: k for k, v in rlabels.items()}
for nodes in [(labels[(0, 4)], labels[(1, 4)]),
(labels[(3, 4)], labels[(4, 4)])]:
new_node = G.order() + 1
# Petersen graph is triconnected
P = nx.petersen_graph()
G = nx.disjoint_union(G, P)
# Add two edges between the grid and P
G.add_edge(new_node + 1, nodes[0])
G.add_edge(new_node, nodes[1])
# K5 is 4-connected
K = nx.complete_graph(5)
G = nx.disjoint_union(G, K)
# Add three edges between P and K5
G.add_edge(new_node + 2, new_node + 11)
G.add_edge(new_node + 3, new_node + 12)
G.add_edge(new_node + 4, new_node + 13)
# Add another K5 sharing a node
G = nx.disjoint_union(G, K)
nbrs = G[new_node + 10]
G.remove_node(new_node + 10)
for nbr in nbrs:
G.add_edge(new_node + 17, nbr)
# Commenting this makes the graph not biconnected !!
# This stupid mistake make one reviewer very angry :P
G.add_edge(new_node + 16, new_node + 8)
for nodes in [(labels[(0, 0)], labels[(1, 0)]),
(labels[(3, 0)], labels[(4, 0)])]:
new_node = G.order() + 1
# Petersen graph is triconnected
P = nx.petersen_graph()
G = nx.disjoint_union(G, P)
# Add two edges between the grid and P
G.add_edge(new_node + 1, nodes[0])
G.add_edge(new_node, nodes[1])
# K5 is 4-connected
K = nx.complete_graph(5)
G = nx.disjoint_union(G, K)
# Add three edges between P and K5
G.add_edge(new_node + 2, new_node + 11)
G.add_edge(new_node + 3, new_node + 12)
G.add_edge(new_node + 4, new_node + 13)
# Add another K5 sharing two nodes
G = nx.disjoint_union(G, K)
nbrs = G[new_node + 10]
G.remove_node(new_node + 10)
for nbr in nbrs:
G.add_edge(new_node + 17, nbr)
nbrs2 = G[new_node + 9]
G.remove_node(new_node + 9)
for nbr in nbrs2:
G.add_edge(new_node + 18, nbr)
return G
def test_bellman_ford(self):
# single node graph
G = nx.DiGraph()
G.add_node(0)
assert_equal(nx.bellman_ford(G, 0), ({0: None}, {0: 0}))
assert_raises(KeyError, nx.bellman_ford, G, 1)
# negative weight cycle
G = nx.cycle_graph(5, create_using=nx.DiGraph())
G.add_edge(1, 2, weight=-7)
for i in range(5):
assert_raises(nx.NetworkXUnbounded, nx.bellman_ford, G, i)
G = nx.cycle_graph(5) # undirected Graph
G.add_edge(1, 2, weight=-3)
for i in range(5):
assert_raises(nx.NetworkXUnbounded, nx.bellman_ford, G, i)
# no negative cycle but negative weight
G = nx.cycle_graph(5, create_using=nx.DiGraph())
G.add_edge(1, 2, weight=-3)
assert_equal(nx.bellman_ford(G, 0), ({0: None, 1: 0, 2: 1, 3: 2, 4: 3}, {0: 0, 1: 1, 2: -2, 3: -1, 4: 0}))
# not connected
G = nx.complete_graph(6)
G.add_edge(10, 11)
G.add_edge(10, 12)
assert_equal(
nx.bellman_ford(G, 0), ({0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0}, {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1})
)
# not connected, with a component not containing the source that
# contains a negative cost cycle.
G = nx.complete_graph(6)
G.add_edges_from([("A", "B", {"load": 3}), ("B", "C", {"load": -10}), ("C", "A", {"load": 2})])
assert_equal(
nx.bellman_ford(G, 0, weight="load"),
({0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0}, {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}),
)
# multigraph
P, D = nx.bellman_ford(self.MXG, "s")
assert_equal(P["v"], "u")
assert_equal(D["v"], 9)
P, D = nx.bellman_ford(self.MXG4, 0)
assert_equal(P[2], 1)
assert_equal(D[2], 4)
# other tests
(P, D) = nx.bellman_ford(self.XG, "s")
assert_equal(P["v"], "u")
assert_equal(D["v"], 9)
G = nx.path_graph(4)
assert_equal(nx.bellman_ford(G, 0), ({0: None, 1: 0, 2: 1, 3: 2}, {0: 0, 1: 1, 2: 2, 3: 3}))
assert_equal(nx.bellman_ford(G, 3), ({0: 1, 1: 2, 2: 3, 3: None}, {0: 3, 1: 2, 2: 1, 3: 0}))
G = nx.grid_2d_graph(2, 2)
pred, dist = nx.bellman_ford(G, (0, 0))
assert_equal(sorted(pred.items()), [((0, 0), None), ((0, 1), (0, 0)), ((1, 0), (0, 0)), ((1, 1), (0, 1))])
assert_equal(sorted(dist.items()), [((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 2)])
def test_strong_product_size():
K5=nx.complete_graph(5)
P5=nx.path_graph(5)
K3 = nx.complete_graph(3)
G=strong_product(P5,K3)
assert_equal(nx.number_of_nodes(G),5*3)
G=strong_product(K3,K5)
assert_equal(nx.number_of_nodes(G),3*5)
def original_graph():
romeos_family = nx.complete_graph(5)
julias_family = nx.complete_graph(5)
# The families clash <- aw, not good!
family_fight = nx.disjoint_union(romeos_family, julias_family)
# ... but Romeo and Julia make love nevertheless
family_fight.add_edge(0, 9)
return family_fight
def test_complete():
""" In complete graphs each node is a dominating set.
Thus the dominating set has to be of cardinality 1.
"""
K4 = nx.complete_graph(4)
assert_equal(len(nx.dominating_set(K4)), 1)
K5 = nx.complete_graph(5)
assert_equal(len(nx.dominating_set(K5)), 1)
def test_subgraph_centrality_big_graph(self):
g199 = nx.complete_graph(199)
g200 = nx.complete_graph(200)
comm199 = nx.subgraph_centrality(g199)
comm199_exp = nx.subgraph_centrality_exp(g199)
comm200 = nx.subgraph_centrality(g200)
comm200_exp = nx.subgraph_centrality_exp(g200)
def test_white_harary_2():
# Figure 8 white and harary (2001)
# # http://eclectic.ss.uci.edu/~drwhite/sm-w23.PDF
G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4))
G.add_edge(0,4)
# kappa <= lambda <= delta
assert_equal(3, min(nx.core_number(G).values()))
assert_equal(1, nx.node_connectivity(G))
assert_equal(1, nx.edge_connectivity(G))
def test_tensor_product_size():
P5 = nx.path_graph(5)
K3 = nx.complete_graph(3)
K5 = nx.complete_graph(5)
G = nx.tensor_product(P5, K3)
assert_equal(nx.number_of_nodes(G), 5 * 3)
G = nx.tensor_product(K3, K5)
assert_equal(nx.number_of_nodes(G), 3 * 5)
def test_spanner_unweighted_disconnected_graph():
"""Test spanner construction on a disconnected graph."""
G = nx.disjoint_union(nx.complete_graph(10), nx.complete_graph(10))
spanner = nx.spanner(G, 4, seed=_seed)
_test_spanner(G, spanner, 4)
spanner = nx.spanner(G, 10, seed=_seed)
_test_spanner(G, spanner, 10)
def build_cnf(args):
"""Build a formula to check that a graph is a ramsey number lower bound
Arguments:
- `args`: command line options
"""
G=_SimpleGraphHelper.obtain_graph(args)
return SubgraphFormula(G,[networkx.complete_graph(args.k),
networkx.complete_graph(args.s)])
def test_strong_product():
null=nx.null_graph()
empty1=nx.empty_graph(1)
empty10=nx.empty_graph(10)
K2=nx.complete_graph(2)
K3=nx.complete_graph(3)
K5=nx.complete_graph(5)
K10=nx.complete_graph(10)
P2=nx.path_graph(2)
P3=nx.path_graph(3)
P5=nx.path_graph(5)
P10=nx.path_graph(10)
# null graph
G=strong_product(null,null)
assert_true(nx.is_isomorphic(G,null))
# null_graph X anything = null_graph and v.v.
G=strong_product(null,empty10)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(null,K3)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(null,K10)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(null,P3)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(null,P10)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(empty10,null)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(K3,null)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(K10,null)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(P3,null)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(P10,null)
assert_true(nx.is_isomorphic(G,null))
G=strong_product(P5,K3)
assert_equal(nx.number_of_nodes(G),5*3)
G=strong_product(K3,K5)
assert_equal(nx.number_of_nodes(G),3*5)
#No classic easily found classic results for strong product
G = nx.erdos_renyi_graph(10,2/10.)
H = nx.erdos_renyi_graph(10,2/10.)
GH = strong_product(G,H)
for (u_G,u_H) in GH.nodes_iter():
for (v_G,v_H) in GH.nodes_iter():
if (u_G==v_G and H.has_edge(u_H,v_H)) or \
(u_H==v_H and G.has_edge(u_G,v_G)) or \
(G.has_edge(u_G,v_G) and H.has_edge(u_H,v_H)):
assert_true(GH.has_edge((u_G,u_H),(v_G,v_H)))
else:
assert_true(not GH.has_edge((u_G,u_H),(v_G,v_H)))
def test_bellman_ford(self):
# single node graph
G = nx.DiGraph()
G.add_node(0)
assert_equal(nx.bellman_ford(G, 0), ({0: None}, {0: 0}))
# negative weight cycle
G = nx.cycle_graph(5, create_using = nx.DiGraph())
G.add_edge(1, 2, weight = -7)
assert_raises(nx.NetworkXUnbounded, nx.bellman_ford, G, 0)
G = nx.cycle_graph(5)
G.add_edge(1, 2, weight = -7)
assert_raises(nx.NetworkXUnbounded, nx.bellman_ford, G, 0)
# not connected
G = nx.complete_graph(6)
G.add_edge(10, 11)
G.add_edge(10, 12)
assert_equal(nx.bellman_ford(G, 0),
({0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0},
{0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}))
# not connected, with a component not containing the source that
# contains a negative cost cycle.
G = nx.complete_graph(6)
G.add_edges_from([('A', 'B', {'load': 3}),
('B', 'C', {'load': -10}),
('C', 'A', {'load': 2})])
assert_equal(nx.bellman_ford(G, 0, weight = 'load'),
({0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0},
{0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1}))
# multigraph
P, D = nx.bellman_ford(self.MXG,'s')
assert_equal(P['v'], 'u')
assert_equal(D['v'], 9)
P, D = nx.bellman_ford(self.MXG4, 0)
assert_equal(P[2], 1)
assert_equal(D[2], 4)
# other tests
(P,D)= nx.bellman_ford(self.XG,'s')
assert_equal(P['v'], 'u')
assert_equal(D['v'], 9)
G=nx.path_graph(4)
assert_equal(nx.bellman_ford(G,0),
({0: None, 1: 0, 2: 1, 3: 2}, {0: 0, 1: 1, 2: 2, 3: 3}))
G=nx.grid_2d_graph(2,2)
pred,dist=nx.bellman_ford(G,(0,0))
assert_equal(sorted(pred.items()),
[((0, 0), None), ((0, 1), (0, 0)),
((1, 0), (0, 0)), ((1, 1), (0, 1))])
assert_equal(sorted(dist.items()),
[((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 2)])
def setUp(self):
self.null = nx.null_graph()
self.P1 = cnlti(nx.path_graph(1), first_label=1)
self.P3 = cnlti(nx.path_graph(3), first_label=1)
self.P10 = cnlti(nx.path_graph(10), first_label=1)
self.K1 = cnlti(nx.complete_graph(1), first_label=1)
self.K3 = cnlti(nx.complete_graph(3), first_label=1)
self.K4 = cnlti(nx.complete_graph(4), first_label=1)
self.K5 = cnlti(nx.complete_graph(5), first_label=1)
self.K10 = cnlti(nx.complete_graph(10), first_label=1)
self.G = nx.Graph
def test_inter_community_edges_with_digraphs():
G = nx.complete_graph(2, create_using = nx.DiGraph())
partition = [{0}, {1}]
assert_equal(inter_community_edges(G, partition), 2)
G = nx.complete_graph(10, create_using = nx.DiGraph())
partition = [{0}, {1, 2}, {3, 4, 5}, {6, 7, 8, 9}]
assert_equal(inter_community_edges(G, partition), 70)
G = nx.cycle_graph(4, create_using = nx.DiGraph())
partition = [{0, 1}, {2, 3}]
assert_equal(inter_community_edges(G, partition), 2)
def test_is_eulerian(self):
assert_true(is_eulerian(nx.complete_graph(5)))
assert_true(is_eulerian(nx.complete_graph(7)))
assert_true(is_eulerian(nx.hypercube_graph(4)))
assert_true(is_eulerian(nx.hypercube_graph(6)))
assert_false(is_eulerian(nx.complete_graph(4)))
assert_false(is_eulerian(nx.complete_graph(6)))
assert_false(is_eulerian(nx.hypercube_graph(3)))
assert_false(is_eulerian(nx.hypercube_graph(5)))
assert_false(is_eulerian(nx.petersen_graph()))
assert_false(is_eulerian(nx.path_graph(4)))
def setUp(self):
try:
global nx
import networkx as nx
except ImportError:
raise SkipTest('networkx not available.')
self.planar=[]
self.planar.extend([nx.path_graph(5),
nx.complete_graph(4)])
self.non_planar=[]
self.non_planar.extend([nx.complete_graph(5),
nx.complete_bipartite_graph(3,3)])
def setUp(self):
self.path = nx.path_graph(7)
self.directed_path = nx.path_graph(7, create_using=nx.DiGraph())
self.cycle = nx.cycle_graph(7)
self.directed_cycle = nx.cycle_graph(7, create_using=nx.DiGraph())
self.gnp = nx.gnp_random_graph(30, 0.1)
self.directed_gnp = nx.gnp_random_graph(30, 0.1, directed=True)
self.K20 = nx.complete_graph(20)
self.K10 = nx.complete_graph(10)
self.K5 = nx.complete_graph(5)
self.G_list = [self.path, self.directed_path, self.cycle,
self.directed_cycle, self.gnp, self.directed_gnp, self.K10,
self.K5, self.K20]
def test_white_harary1():
# Figure 1b white and harary (2001)
# A graph with high adhesion (edge connectivity) and low cohesion
# (node connectivity)
G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4))
G.remove_node(7)
for i in range(4,7):
G.add_edge(0,i)
G = nx.disjoint_union(G, nx.complete_graph(4))
G.remove_node(G.order()-1)
for i in range(7,10):
G.add_edge(0,i)
assert_equal(1, approx.node_connectivity(G))
def test_contract_selfloop_graph(self):
"""Tests for node contraction when nodes have selfloops."""
G = nx.cycle_graph(4)
G.add_edge(0, 0)
actual = nx.contracted_nodes(G, 0, 1)
expected = nx.complete_graph([0, 2, 3])
expected.add_edge(0, 0)
expected.add_edge(0, 0)
assert_edges_equal(actual.edges, expected.edges)
actual = nx.contracted_nodes(G, 1, 0)
expected = nx.complete_graph([1, 2, 3])
expected.add_edge(1, 1)
expected.add_edge(1, 1)
assert_edges_equal(actual.edges, expected.edges)
def test_parameters(self):
for base in range(2, 5):
for template in range(2, 5):
parameters = ["cnfgen", "-q", "subgraph", "--complete", base, "--completeT", template]
G = nx.complete_graph(base)
T = nx.complete_graph(template)
F = SubgraphFormula(G, [T])
self.checkFormula(sys.stdin, F, parameters)
parameters = ["cnfgen", "-q", "subgraph", "--complete", base, "--emptyT", template]
G = nx.complete_graph(base)
T = nx.empty_graph(template)
F = SubgraphFormula(G, [T])
self.checkFormula(sys.stdin, F, parameters)
def test_white_harary_1():
# Figure 1b white and harary (2001)
# # http://eclectic.ss.uci.edu/~drwhite/sm-w23.PDF
# A graph with high adhesion (edge connectivity) and low cohesion
# (vertex connectivity)
G = nx.disjoint_union(nx.complete_graph(4), nx.complete_graph(4))
G.remove_node(7)
for i in range(4,7):
G.add_edge(0,i)
G = nx.disjoint_union(G, nx.complete_graph(4))
G.remove_node(G.order()-1)
for i in range(7,10):
G.add_edge(0,i)
assert_equal(1, nx.node_connectivity(G))
assert_equal(3, nx.edge_connectivity(G))
from parse import write_input_file, validate_file
import networkx as nx
import random
if __name__ == '__main__':
G_small = nx.complete_graph(24)
for (u, v) in G_small.edges():
G_small.edges[u,v]['weight'] = round(random.uniform(0.0, 100.0), 3)
G_medium = nx.complete_graph(48)
for (u, v) in G_medium.edges():
G_medium.edges[u,v]['weight'] = round(random.uniform(0.0, 100.0), 3)
G_large = nx.complete_graph(99)
for (u, v) in G_large.edges():
G_large.edges[u,v]['weight'] = round(random.uniform(0.0, 100.0), 3)
write_input_file(G_small, "/Users/narenyenuganti/Desktop/170Proj/25.in")
write_input_file(G_medium, "/Users/narenyenuganti/Desktop/170Proj/50.in")
write_input_file(G_large, "/Users/narenyenuganti/Desktop/170Proj/100.in")
if (validate_file("/Users/narenyenuganti/Desktop/170Proj/25.in") == False):
raise Exception("incorrect format for 25.in")
if (validate_file("/Users/narenyenuganti/Desktop/170Proj/50.in") == False):
raise Exception("incorrect format for 50.in")
if (validate_file("/Users/narenyenuganti/Desktop/170Proj/100.in") == False):
raise Exception("incorrect format for 100.in")
def dummy_graph_data():
return networkx.complete_graph(3)
def test_hamiltonian_path():
from itertools import permutations
G = nx.complete_graph(4)
paths = [list(p) for p in hamiltonian_path(G, 0)]
exact = [[0] + list(p) for p in permutations([1, 2, 3], 3)]
assert_equal(sorted(paths), sorted(exact))
def test_complete_graph(self):
graph = nx.complete_graph(30)
# this should return the entire graph
mc = max_clique(graph)
assert 30 == len(mc)
m = 22002
print "Creating Gnm Graph..."
gnm = nx.gnm_random_graph(n, m)
print len(gnm.nodes())
print len(gnm.edges())
#Real World Autonomous System Network
print "Reading Real-World graph..."
rw = nx.read_adjlist("oregon1_010331.txt.gz")
print len(rw.nodes())
print len(rw.edges())
#Graph with preferential attachment
print 'Creating preferential attachment graph...'
pag = nx.complete_graph(40)
new_node = 40 #labeling for first node to be added
num_edges = len(pag.edges())
edges = pag.edges()
while (len(pag.nodes()) < 10670):
if len(pag.nodes()) % 100 == 0: print len(pag.nodes())
for i in range(2): #creating two new edges
#get random edge from graph
rand_edge = edges[randint(0, len(edges) - 1)]
#get random endpoint from the selected edge
node = rand_edge[randint(0, 1)]
#make edge between node and endpoint
pag.add_edge(new_node, node)
# Daniel Hammer
# Import the necessary package
import networkx as nx
n = 4
#def graph_caller(self, graph_name):
switcher = {
"path": nx.path_graph(n),
"complete": nx.complete_graph(n),
"binomial tree": nx.binomial_tree(n),
"circular ladder": nx.circular_ladder_graph(n),
"cycle": nx.cycle_graph(n),
"dorogovtsev": nx.dorogovtsev_goltsev_mendes_graph(n),
"ladder": nx.ladder_graph(n),
"star": nx.star_graph(n),
"wheel": nx.wheel_graph(n),
"margulis gabber galil": nx.margulis_gabber_galil_graph(n),
"chordal cycle": nx.chordal_cycle_graph(n),
"hypercube": nx.hypercube_graph(n),
"mycielski": nx.mycielski_graph(n)
}
# return switcher.get(graph_name,"Invalid choice")
graph_name = input("Enter a graph name to generate\n")
print(graph_name)
#G = graph_caller(graph_name)
def test_complete_graph(self):
cg = nx.complete_graph(5)
mcb = minimum_cycle_basis(cg)
assert all([len(cycle) == 3 for cycle in mcb])
def test_interface_only_target():
G = nx.complete_graph(5)
for interface_func in [nx.minimum_node_cut, nx.minimum_edge_cut]:
assert_raises(nx.NetworkXError, interface_func, G, t=3)
def test_all_simple_paths_cutoff():
G = nx.complete_graph(4)
paths = nx.all_simple_paths(G, 0, 1, cutoff=1)
assert_equal(set(tuple(p) for p in paths), {(0, 1)})
paths = nx.all_simple_paths(G, 0, 1, cutoff=2)
assert_equal(set(tuple(p) for p in paths), {(0, 1), (0, 2, 1), (0, 3, 1)})
def test_hamiltonian__edge_path():
from itertools import permutations
G = nx.complete_graph(4)
paths = hamiltonian_edge_path(G, 0)
exact = [list(pairwise([0] + list(p))) for p in permutations([1, 2, 3], 3)]
assert sorted(exact) == [p for p in sorted(paths)]
def barabasi_albert(nodos, m):
m0 = m + 1
t = nodos - m0
G = nx.complete_graph(
m0
) #Creamos el grafo con una distribucion inicial de m0 nodos con al menos un enlace cada nodo
'''
--------------------------------------------------------------------------------------------------------------------------------------------------
PREPROCESAMIENTO
--------------------------------------------------------------------------------------------------------------------------------------------------
'''
for i in range(m0, nodos): #añadimos los N - n0 nodos restantes
G.add_node(i) # añadimos el nodo nuevo queremos conecar
sumaGradosNodos = 0
for nodo in range(0, i):
sumaGradosNodos += G.degree(nodo)
#Sumamos los grados de todos los nodos que forman la red en este momento, para posteriormente calcular formula de la probablidad de conexion
probConexion = {
} #Creamos un diccionario donde guardar la probabilidad de cada nodo para crear una nueva conexion con el nodo i
#Esto metodo es conocido como Conexion preferencial ya que se conectara con nodos que tenga mas conexiones
#probConexion -> clave: id del nodo, valor: probalid
gradosNodos = nx.degree(
G) #Sacamos la lista con los grados de cada nodo
#Llenamos el diccionario con las probabilidades de cada nodos que hay hasta este momento con la formula:
#Pi = ki / SUM kj
#Pi es la probabilidad de que uno de los enlaces se conecte al nodo nuevo
# donde ki es el grado del nodo existente
#denominador suma de los grados de la red hasta este momento
for j in range(0, i):
probConexion[j] = (float)(gradosNodos[j]) / sumaGradosNodos
'''
PARA AGRERAR ARISTAS AL NUEVO NODO USAREMOS EL METODO DE PROBABILIDADES ACUMULADAS
Implementaremos la idea de conexion preferencial mediante este metodo.
Se genera un numero aleatorio [0.0, 1)
Usaremos una nueva metrica llamada probabilidad acumulada que es la suma de las probabilidades anteriores
Con estos dos valores podremos implementar la conexion preferencial ya que cuato mayor sea la probabilidad
acumulada mas conexiones tendrá. Con una probabilidad acumulada alta la ventana de posibulidades para ser escogida es mayor, en caso
contrario si la probabilidad acumulada es baja la venta de posibilidades es mas pequeña haciendo que sea menos probable que se escoja ese
nodo.
Ejemplo:
probabilidades = [0.2, 0.3, 0.5]
probabilidadAcumulada = [0.2, 0.5, 1.0]
Numero aleatorio de [0.0, 1.0)
n = 0.4
ventanas:
0.2: [0.0, 0.2]
0.5: [0.0, 0,5]
1.0: [0.0, 1.0]
Cuanto mas grande sea la ventana, mas probable es que el numero aleatorio caiga dentro de esa ventana
'''
#Vamos a crear una lista de probabilidades acumuladas, la cual contendrá tuplas.
#Cada tupla, tendra id del nodo y la probabilidad acumulada (id,probAcumulada)
probAcumulada = [] #lista vacia
aux = 0
for idNodo, probabilidad in probConexion.items():
nodo = (
idNodo, aux + probabilidad
) #creamos un elemento de la lista con la informacion necesaria
probAcumulada.append(nodo)
aux += probabilidad #actualizamos lo anterior con lo actaul para la siguiente iteracion
#--------------------------------------------------------------------------------------------------------------------------------------------------
# CREACION DE CONEXIONES
#--------------------------------------------------------------------------------------------------------------------------------------------------
#Ahora hay que hacer m conexiones, m aristas, con m nodos. Basandonos en los datos extraidos anteriormente
conexiones = 0
nodosAdded = [
] #Lista de nodos selccionados para conectarlos con el nuevo nodo
while (conexiones < m):
n = random.random()
actual = 0
while (
actual < i and probAcumulada[actual][1] < n
): # No nos pasamos del nuevo nodo y la probabilidad acumulado es menor que la n, entonces pasamos al suiente nodo candidato
actual += 1
idDestino = probAcumulada[actual][
0] # extreamos el id del nodo seleccionado para formar la conexion
#Vamos a comprobar si idDestino no tiene conexion con el nodo nuevo
if idDestino not in nodosAdded:
nodosAdded.append(
idDestino) # lo metemos en la lista de nodos selecionados
G.add_edge(i, idDestino) #añadimos la conexional grafo
conexiones += 1
return G
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
from sys import exit
from utils import *
DISCLAIMER = -1
rg = np.random.default_rng()
nvars = 2 # number of choice variants
# ----------------------------------------------------------
# community specification
# ----------------------------------------------------------
# specify community net
net = nx.complete_graph(200)
setattr(net, 'nvars', nvars) # associte 'nvars' with 'net'
# set parameters of community actors
for n in net:
net.nodes[n]['rho'] = 20
if n == 0:
net.nodes[n]['choice'] = 0
else:
net.nodes[n]['choice'] = DISCLAIMER
# set parameters of community channels
for channel in net.edges:
alice = min(channel)
if alice == 0:
net.edges[channel]['a'] = 1.0
def test_ignore_selfloops(self):
G = nx.complete_graph(5)
G.add_edge(3, 3)
cycle = nx_app.greedy_tsp(G)
assert len(cycle) - 1 == len(G) == len(set(cycle))
def test_random_graph(self):
seed = 42
G = nx.gnm_random_graph(100, 20, seed)
G = nx.gnm_random_graph(100, 20, seed, directed=True)
G = nx.dense_gnm_random_graph(100, 20, seed)
G = nx.watts_strogatz_graph(10, 2, 0.25, seed)
assert len(G) == 10
assert G.number_of_edges() == 10
G = nx.connected_watts_strogatz_graph(10, 2, 0.1, tries=10, seed=seed)
assert len(G) == 10
assert G.number_of_edges() == 10
pytest.raises(nx.NetworkXError,
nx.connected_watts_strogatz_graph,
10,
2,
0.1,
tries=0)
G = nx.watts_strogatz_graph(10, 4, 0.25, seed)
assert len(G) == 10
assert G.number_of_edges() == 20
G = nx.newman_watts_strogatz_graph(10, 2, 0.0, seed)
assert len(G) == 10
assert G.number_of_edges() == 10
G = nx.newman_watts_strogatz_graph(10, 4, 0.25, seed)
assert len(G) == 10
assert G.number_of_edges() >= 20
G = nx.barabasi_albert_graph(100, 1, seed)
G = nx.barabasi_albert_graph(100, 3, seed)
assert G.number_of_edges() == (97 * 3)
G = nx.barabasi_albert_graph(100, 3, seed, nx.complete_graph(5))
assert G.number_of_edges() == (10 + 95 * 3)
G = nx.extended_barabasi_albert_graph(100, 1, 0, 0, seed)
assert G.number_of_edges() == 99
G = nx.extended_barabasi_albert_graph(100, 3, 0, 0, seed)
assert G.number_of_edges() == 97 * 3
G = nx.extended_barabasi_albert_graph(100, 1, 0, 0.5, seed)
assert G.number_of_edges() == 99
G = nx.extended_barabasi_albert_graph(100, 2, 0.5, 0, seed)
assert G.number_of_edges() > 100 * 3
assert G.number_of_edges() < 100 * 4
G = nx.extended_barabasi_albert_graph(100, 2, 0.3, 0.3, seed)
assert G.number_of_edges() > 100 * 2
assert G.number_of_edges() < 100 * 4
G = nx.powerlaw_cluster_graph(100, 1, 1.0, seed)
G = nx.powerlaw_cluster_graph(100, 3, 0.0, seed)
assert G.number_of_edges() == (97 * 3)
G = nx.random_regular_graph(10, 20, seed)
pytest.raises(nx.NetworkXError, nx.random_regular_graph, 3, 21)
pytest.raises(nx.NetworkXError, nx.random_regular_graph, 33, 21)
constructor = [(10, 20, 0.8), (20, 40, 0.8)]
G = nx.random_shell_graph(constructor, seed)
def is_caterpillar(g):
"""
A tree is a caterpillar iff all nodes of degree >=3 are surrounded
by at most two nodes of degree two or greater.
ref: http://mathworld.wolfram.com/CaterpillarGraph.html
"""
deg_over_3 = [n for n in g if g.degree(n) >= 3]
for n in deg_over_3:
nbh_deg_over_2 = [
nbh for nbh in g.neighbors(n) if g.degree(nbh) >= 2
]
if not len(nbh_deg_over_2) <= 2:
return False
return True
def is_lobster(g):
"""
A tree is a lobster if it has the property that the removal of leaf
nodes leaves a caterpillar graph (Gallian 2007)
ref: http://mathworld.wolfram.com/LobsterGraph.html
"""
non_leafs = [n for n in g if g.degree(n) > 1]
return is_caterpillar(g.subgraph(non_leafs))
G = nx.random_lobster(10, 0.1, 0.5, seed)
assert max(G.degree(n) for n in G.nodes()) > 3
assert is_lobster(G)
pytest.raises(nx.NetworkXError, nx.random_lobster, 10, 0.1, 1, seed)
pytest.raises(nx.NetworkXError, nx.random_lobster, 10, 1, 1, seed)
pytest.raises(nx.NetworkXError, nx.random_lobster, 10, 1, 0.5, seed)
# docstring says this should be a caterpillar
G = nx.random_lobster(10, 0.1, 0.0, seed)
assert is_caterpillar(G)
# difficult to find seed that requires few tries
seq = nx.random_powerlaw_tree_sequence(10, 3, seed=14, tries=1)
G = nx.random_powerlaw_tree(10, 3, seed=14, tries=1)
def complete_graph(n):
return nx.complete_graph(n)
def test_cutoff_zero():
G = nx.complete_graph(4)
paths = nx.all_simple_paths(G, 0, 3, cutoff=0)
assert_equal(list(list(p) for p in paths), [])
paths = nx.all_simple_paths(nx.MultiGraph(G), 0, 3, cutoff=0)
assert_equal(list(list(p) for p in paths), [])
def test_reverse(self):
G = nx.complete_graph(10)
H = G.to_directed()
HR = H.reverse()
assert nx.is_isomorphic(H, HR)
assert sorted(H.edges()) == sorted(HR.edges())
def test_complete_graph(self):
G = nx.complete_graph(10)
independent_set, cliques = clique_removal(G)
assert is_independent_set(G, independent_set)
assert all(is_clique(G, clique) for clique in cliques)
def test_complete_directed_graph(self):
# see table 2 in Johnson's paper
ncircuits = [1, 5, 20, 84, 409, 2365, 16064]
for n, c in zip(range(2, 9), ncircuits):
G = nx.DiGraph(nx.complete_graph(n))
assert len(list(nx.simple_cycles(G))) == c
def gen(self):
#G.graph = nx.barabasi_albert_graph(G.NUM_NODES,5)
G.graph = nx.complete_graph(G.NUM_NODES)
for i in G.graph.edges_iter():
channel = Store(name=i)
G.edges.append(channel)
def create_pspace_network(number_of_node):
net = nx.complete_graph(number_of_node)
return net
import networkx as nx import matplotlib.pyplot as plt G = nx.Graph() l = [1, 2, 3] G.add_nodes_from(l) G = nx.complete_graph(10) nx.draw(G) plt.show()
def test_all_simple_edge_paths_cutoff():
G = nx.complete_graph(4)
paths = nx.all_simple_edge_paths(G, 0, 1, cutoff=1)
assert {tuple(p) for p in paths} == {((0, 1),)}
paths = nx.all_simple_edge_paths(G, 0, 1, cutoff=2)
assert {tuple(p) for p in paths} == {((0, 1),), ((0, 2), (2, 1)), ((0, 3), (3, 1))}
def test_not_connected(self):
G = nx.complete_graph(6)
G.add_edge(10, 11)
G.add_edge(10, 12)
assert_equal(nx.single_source_bellman_ford_path(G, 0), {
0: [0],
1: [0, 1],
2: [0, 2],
3: [0, 3],
4: [0, 4],
5: [0, 5]
})
assert_equal(dict(nx.single_source_bellman_ford_path_length(G, 0)), {
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
})
assert_equal(nx.single_source_bellman_ford(G, 0), ({
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
}, {
0: [0],
1: [0, 1],
2: [0, 2],
3: [0, 3],
4: [0, 4],
5: [0, 5]
}))
assert_equal(nx.bellman_ford_predecessor_and_distance(G, 0), ({
0: [None],
1: [0],
2: [0],
3: [0],
4: [0],
5: [0]
}, {
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
}))
assert_equal(nx.goldberg_radzik(G, 0), ({
0: None,
1: 0,
2: 0,
3: 0,
4: 0,
5: 0
}, {
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
}))
# not connected, with a component not containing the source that
# contains a negative cost cycle.
G = nx.complete_graph(6)
G.add_edges_from([('A', 'B', {
'load': 3
}), ('B', 'C', {
'load': -10
}), ('C', 'A', {
'load': 2
})])
assert_equal(nx.single_source_bellman_ford_path(G, 0, weight='load'), {
0: [0],
1: [0, 1],
2: [0, 2],
3: [0, 3],
4: [0, 4],
5: [0, 5]
})
assert_equal(
dict(nx.single_source_bellman_ford_path_length(G, 0,
weight='load')), {
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
})
assert_equal(nx.single_source_bellman_ford(G, 0, weight='load'), ({
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
}, {
0: [0],
1: [0, 1],
2: [0, 2],
3: [0, 3],
4: [0, 4],
5: [0, 5]
}))
assert_equal(
nx.bellman_ford_predecessor_and_distance(G, 0, weight='load'),
({
0: [None],
1: [0],
2: [0],
3: [0],
4: [0],
5: [0]
}, {
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
}))
assert_equal(nx.goldberg_radzik(G, 0, weight='load'), ({
0: None,
1: 0,
2: 0,
3: 0,
4: 0,
5: 0
}, {
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
}))
def test_invalid_auxiliary():
G = nx.complete_graph(5)
assert_raises(nx.NetworkXError, minimum_st_node_cut, G, 0, 3,
auxiliary=G)
def test_reverse(self):
G = nx.complete_graph(10)
H = G.to_directed()
HR = H.reverse()
assert_true(nx.is_isomorphic(H, HR))
assert_equal(sorted(H.edges()), sorted(HR.edges()))
import networkx as nx
import community
import matplotlib as plt
"""
G = nx.random_graphs.powerlaw_cluster_graph(300, 1, .4)
part = community.best_partition(G)
values = [part.get(node) for node in G.nodes()]
nx.draw_spring(G, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=False)
"""
degree_sum_dict = {}
community_dict = {0:{0,1},1:{2,3}}
data_graph = nx.complete_graph(4)
for key in community_dict:
list = community_dict[key]
sum = 0;
for i in list:
sum += data_graph.degree(i);
degree_sum_dict[key] = sum
print degree_sum_dict
def test_star(self):
G = nx.star_graph(5)
L = nx.line_graph(G)
assert_true(nx.is_isomorphic(L, nx.complete_graph(5)))
# flake8: noqa: C501
for i in range(len(test_item[1])):
device_name = test_set["test_devices"][i][0]
device = test_set["test_devices"][i][1]
type(device).properties = PropertyMock(return_value=Expando())
type(device).properties.service = PropertyMock(
return_value=Expando())
device.properties.service.executionWindows = (
device._properties.service.executionWindows)
expected = bool(test_item[1][i])
actual = device.is_available
assert (
expected == actual
), f"device_name: {device_name}, test_date: {test_date}, expected: {expected}, actual: {actual}"
@pytest.mark.parametrize(
"get_device_data, expected_graph",
[
(MOCK_GATE_MODEL_QPU_1, nx.DiGraph([(1, 2), (1, 3)])),
(MOCK_GATE_MODEL_QPU_2, nx.complete_graph(30, nx.DiGraph())),
(MOCK_DWAVE_QPU, nx.DiGraph([(1, 2), (2, 3)])),
],
)
def test_device_topology_graph_data(get_device_data, expected_graph, arn):
mock_session = Mock()
mock_session.get_device.return_value = get_device_data
mock_session.region = RIGETTI_REGION
device = AwsDevice(arn, mock_session)
assert nx.is_isomorphic(device.topology_graph, expected_graph)
def test_bellman_ford(self):
# single node graph
G = nx.DiGraph()
G.add_node(0)
assert_equal(nx.bellman_ford(G, 0), ({0: None}, {0: 0}))
# negative weight cycle
G = nx.cycle_graph(5, create_using=nx.DiGraph())
G.add_edge(1, 2, weight=-7)
assert_raises(nx.NetworkXError, nx.bellman_ford, G, 0)
G = nx.cycle_graph(5)
G.add_edge(1, 2, weight=-7)
assert_raises(nx.NetworkXError, nx.bellman_ford, G, 0)
# not connected
G = nx.complete_graph(6)
G.add_edge(10, 11)
G.add_edge(10, 12)
assert_equal(nx.bellman_ford(G, 0), ({
0: None,
1: 0,
2: 0,
3: 0,
4: 0,
5: 0
}, {
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
}))
# not connected, with a component not containing the source that
# contains a negative cost cycle.
G = nx.complete_graph(6)
G.add_edges_from([('A', 'B', {
'load': 3
}), ('B', 'C', {
'load': -10
}), ('C', 'A', {
'load': 2
})])
assert_equal(nx.bellman_ford(G, 0, weight='load'), ({
0: None,
1: 0,
2: 0,
3: 0,
4: 0,
5: 0
}, {
0: 0,
1: 1,
2: 1,
3: 1,
4: 1,
5: 1
}))
# multigraph
P, D = nx.bellman_ford(self.MXG, 's')
assert_equal(P['v'], 'u')
assert_equal(D['v'], 9)
P, D = nx.bellman_ford(self.MXG4, 0)
assert_equal(P[2], 1)
assert_equal(D[2], 4)
# other tests
(P, D) = nx.bellman_ford(self.XG, 's')
assert_equal(P['v'], 'u')
assert_equal(D['v'], 9)
G = nx.path_graph(4)
assert_equal(nx.bellman_ford(G, 0), ({
0: None,
1: 0,
2: 1,
3: 2
}, {
0: 0,
1: 1,
2: 2,
3: 3
}))
G = nx.grid_2d_graph(2, 2)
pred, dist = nx.bellman_ford(G, (0, 0))
assert_equal(sorted(pred.items()), [((0, 0), None), ((0, 1), (0, 0)),
((1, 0), (0, 0)),
((1, 1), (0, 1))])
assert_equal(sorted(dist.items()), [((0, 0), 0), ((0, 1), 1),
((1, 0), 1), ((1, 1), 2)])
