def setUp(self):
G=nx.Graph();
G.add_edge(0,1,weight=3)
G.add_edge(0,2,weight=2)
G.add_edge(0,3,weight=6)
G.add_edge(0,4,weight=4)
G.add_edge(1,3,weight=5)
G.add_edge(1,5,weight=5)
G.add_edge(2,4,weight=1)
G.add_edge(3,4,weight=2)
G.add_edge(3,5,weight=1)
G.add_edge(4,5,weight=4)
self.G=G
self.exact_weighted={0: 4.0, 1: 0.0, 2: 8.0, 3: 6.0, 4: 8.0, 5: 0.0}
self.K = nx.krackhardt_kite_graph()
self.P3 = nx.path_graph(3)
self.P4 = nx.path_graph(4)
self.K5 = nx.complete_graph(5)
self.C4=nx.cycle_graph(4)
self.T=nx.balanced_tree(r=2, h=2)
self.Gb = nx.Graph()
self.Gb.add_edges_from([(0,1), (0,2), (1,3), (2,3),
(2,4), (4,5), (3,5)])
F = nx.florentine_families_graph()
self.F = F
def test_generate_sparse6(self):
# Checked against sage encoder
assert_equal(nx.generate_sparse6(nx.empty_graph(0)), '>>sparse6<<:?')
assert_equal(nx.generate_sparse6(nx.empty_graph(1)), '>>sparse6<<:@')
assert_equal(nx.generate_sparse6(nx.empty_graph(5)), '>>sparse6<<:D')
assert_equal(nx.generate_sparse6(nx.empty_graph(68)),
'>>sparse6<<:~?@C')
assert_equal(nx.generate_sparse6(nx.empty_graph(258049)),
'>>sparse6<<:~~???~?@')
G1 = nx.complete_graph(4)
assert_equal(nx.generate_sparse6(G1, header=True),
'>>sparse6<<:CcKI')
assert_equal(nx.generate_sparse6(G1, header=False), ':CcKI')
# Padding testing
assert_equal(nx.generate_sparse6(nx.path_graph(4), header=False),
':Cdv')
assert_equal(nx.generate_sparse6(nx.path_graph(5), header=False),
':DaYn')
assert_equal(nx.generate_sparse6(nx.path_graph(6), header=False),
':EaYnN')
assert_equal(nx.generate_sparse6(nx.path_graph(7), header=False),
':FaYnL')
assert_equal(nx.generate_sparse6(nx.path_graph(8), header=False),
':GaYnLz')
def test_single_nodes(self):
G = nx.path_graph(1)
vpos = nx.shell_layout(G)
assert(vpos[0].any() == False)
G = nx.path_graph(3)
vpos = nx.shell_layout(G, [[0], [1,2]])
assert(vpos[0].any() == False)
def test_set_edge_attributes_multi():
graphs = [nx.MultiGraph(), nx.MultiDiGraph()]
for G in graphs:
# Test single value
G = nx.path_graph(3, create_using=G)
attr = 'hello'
vals = 3
nx.set_edge_attributes(G, vals, attr)
assert_equal(G[0][1][0][attr], vals)
assert_equal(G[1][2][0][attr], vals)
# Test multiple values
G = nx.path_graph(3, create_using=G)
attr = 'hi'
edges = [(0, 1, 0), (1, 2, 0)]
vals = dict(zip(edges, range(len(edges))))
nx.set_edge_attributes(G, vals, attr)
assert_equal(G[0][1][0][attr], 0)
assert_equal(G[1][2][0][attr], 1)
# Test dictionary of dictionaries
G = nx.path_graph(3, create_using=G)
d = {'hi': 0, 'hello': 200}
edges = [(0, 1, 0)]
vals = dict.fromkeys(edges, d)
nx.set_edge_attributes(G, vals)
assert_equal(G[0][1][0]['hi'], 0)
assert_equal(G[0][1][0]['hello'], 200)
assert_equal(G[1][2][0], {})
def test_set_node_attributes():
graphs = [nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()]
for G in graphs:
# Test single value
G = nx.path_graph(3, create_using=G)
vals = 100
attr = 'hello'
nx.set_node_attributes(G, vals, attr)
assert_equal(G.nodes[0][attr], vals)
assert_equal(G.nodes[1][attr], vals)
assert_equal(G.nodes[2][attr], vals)
# Test dictionary
G = nx.path_graph(3, create_using=G)
vals = dict(zip(sorted(G.nodes()), range(len(G))))
attr = 'hi'
nx.set_node_attributes(G, vals, attr)
assert_equal(G.nodes[0][attr], 0)
assert_equal(G.nodes[1][attr], 1)
assert_equal(G.nodes[2][attr], 2)
# Test dictionary of dictionaries
G = nx.path_graph(3, create_using=G)
d = {'hi': 0, 'hello': 200}
vals = dict.fromkeys(G.nodes(), d)
vals.pop(0)
nx.set_node_attributes(G, vals)
assert_equal(G.nodes[0], {})
assert_equal(G.nodes[1]["hi"], 0)
assert_equal(G.nodes[2]["hello"], 200)
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 setup(self):
self.G = nx.path_graph(9)
self.DG = nx.path_graph(9, create_using=nx.DiGraph())
self.eview = nx.EdgeView
def modify_edge(G, e, **kwds):
G._adj[e[0]][e[1]].update(kwds)
self.modify_edge = modify_edge
def test_average_shortest_path(self):
l=nx.average_shortest_path_length(self.cycle)
assert_almost_equal(l,2)
l=nx.average_shortest_path_length(self.cycle,weighted=True)
assert_almost_equal(l,2)
l=nx.average_shortest_path_length(nx.path_graph(5))
assert_almost_equal(l,2)
l=nx.average_shortest_path_length(nx.path_graph(5),weighted=True)
assert_almost_equal(l,2)
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 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 CreateGraph(data):
n = len(data)
G = nx.Graph()
nx.path_graph(n, G)
for row in range(n):
for column in range(n):
weight = data[row][column]
if(weight != 0):
G.add_edge(row, column, weight= weight)
return G
def test_degree_graph(self):
P3 = nx.path_graph(3)
P5 = nx.path_graph(5)
# silently ignore nodes not in P3
assert_equal(dict(d for n, d in P3.degree(['A', 'B'])), {})
# nbunch can be a graph
assert_equal(sorted(d for n, d in P5.degree(P3)), [1, 2, 2])
# nbunch can be a graph thats way to big
assert_equal(sorted(d for n, d in P3.degree(P5)), [1, 1, 2])
assert_equal(list(P5.degree([])), [])
assert_equal(dict(P5.degree([])), {})
def test_cartesian_product_classic():
# test some classic product graphs
P2 = nx.path_graph(2)
P3 = nx.path_graph(3)
# cube = 2-path X 2-path
G=cartesian_product(P2,P2)
G=cartesian_product(P2,G)
assert_true(nx.is_isomorphic(G,nx.cubical_graph()))
# 3x3 grid
G=cartesian_product(P3,P3)
assert_true(nx.is_isomorphic(G,nx.grid_2d_graph(3,3)))
def test_average_connectivity():
# figure 1 from:
# Beineke, L., O. Oellermann, and R. Pippert (2002). The average
# connectivity of a graph. Discrete mathematics 252(1-3), 31-45
# http://www.sciencedirect.com/science/article/pii/S0012365X01001807
G1 = nx.path_graph(3)
G1.add_edges_from([(1,3),(1,4)])
assert_equal(nx.average_node_connectivity(G1),1)
G2 = nx.path_graph(3)
G2.add_edges_from([(1,3),(1,4),(0,3),(0,4),(3,4)])
assert_equal(nx.average_node_connectivity(G2),2.2)
G3 = nx.Graph()
assert_equal(nx.average_node_connectivity(G3),0)
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 setUp(self):
self.P3 = nx.path_graph(3)
self.P4 = nx.path_graph(4)
self.K5 = nx.complete_graph(5)
self.C4 = nx.cycle_graph(4)
self.C5 = nx.cycle_graph(5)
self.T = nx.balanced_tree(r=2, h=2)
self.Gb = nx.DiGraph()
self.Gb.add_edges_from([(0, 1), (0, 2), (0, 4), (2, 1),
(2, 3), (4, 3)])
def test_sample_step():
from score import SimpleDistanceEstimator as SDE
import networkx as nx
import choose
import graphlearn3.test.transformutil as transformutil
lsgg = util.test_get_grammar()
graph = util._edenize_for_testing(nx.path_graph(4))
graph.node[3]['label'] = '5'
score_estimator = SDE().fit(util._edenize_for_testing(nx.path_graph(4)))
graph,score= sample(graph, transformutil.no_transform(), lsgg, score_estimator, choose.Chooser(), n_steps=2, return_score=True)
assert (0.000001 > abs(0.319274373045 - score)), score
print("sambledestdone")
def setUp(self):
G=nx.Graph();
G.add_edge(0,1,weight=3)
G.add_edge(0,2,weight=2)
G.add_edge(0,3,weight=6)
G.add_edge(0,4,weight=4)
G.add_edge(1,3,weight=5)
G.add_edge(1,5,weight=5)
G.add_edge(2,4,weight=1)
G.add_edge(3,4,weight=2)
G.add_edge(3,5,weight=1)
G.add_edge(4,5,weight=4)
self.G=G
self.exact_weighted={0: 4.0, 1: 0.0, 2: 8.0, 3: 6.0, 4: 8.0, 5: 0.0}
self.K = nx.krackhardt_kite_graph()
self.P3 = nx.path_graph(3)
self.P4 = nx.path_graph(4)
self.K5 = nx.complete_graph(5)
self.C4=nx.cycle_graph(4)
self.T=nx.balanced_tree(r=2, h=2)
self.Gb = nx.Graph()
self.Gb.add_edges_from([(0,1), (0,2), (1,3), (2,3),
(2,4), (4,5), (3,5)])
F = nx.Graph() # Florentine families
F.add_edge('Acciaiuoli','Medici')
F.add_edge('Castellani','Peruzzi')
F.add_edge('Castellani','Strozzi')
F.add_edge('Castellani','Barbadori')
F.add_edge('Medici','Barbadori')
F.add_edge('Medici','Ridolfi')
F.add_edge('Medici','Tornabuoni')
F.add_edge('Medici','Albizzi')
F.add_edge('Medici','Salviati')
F.add_edge('Salviati','Pazzi')
F.add_edge('Peruzzi','Strozzi')
F.add_edge('Peruzzi','Bischeri')
F.add_edge('Strozzi','Ridolfi')
F.add_edge('Strozzi','Bischeri')
F.add_edge('Ridolfi','Tornabuoni')
F.add_edge('Tornabuoni','Guadagni')
F.add_edge('Albizzi','Ginori')
F.add_edge('Albizzi','Guadagni')
F.add_edge('Bischeri','Guadagni')
F.add_edge('Guadagni','Lamberteschi')
self.F = F
def test_shortest_path_target(self):
answer = {0: [0, 1], 1: [1], 2: [2, 1]}
sp = nx.shortest_path(nx.path_graph(3), target=1)
assert_equal(sp, answer)
# with weights
sp = nx.shortest_path(nx.path_graph(3), target=1, weight='weight')
assert_equal(sp, answer)
# weights and method specified
sp = nx.shortest_path(nx.path_graph(3), target=1, weight='weight',
method='dijkstra')
assert_equal(sp, answer)
sp = nx.shortest_path(nx.path_graph(3), target=1, weight='weight',
method='bellman-ford')
assert_equal(sp, answer)
def setUp(self):
self.K = nx.krackhardt_kite_graph()
self.P3 = nx.path_graph(3)
self.P4 = nx.path_graph(4)
self.K5 = nx.complete_graph(5)
self.C4 = nx.cycle_graph(4)
self.T = nx.balanced_tree(r=2, h=2)
self.Gb = nx.Graph()
self.Gb.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (4, 5), (3, 5)])
F = nx.florentine_families_graph()
self.F = F
def test_shortest_path_length_target(self):
answer = {0: 1, 1: 0, 2: 1}
sp = dict(nx.shortest_path_length(nx.path_graph(3), target=1))
assert_equal(sp, answer)
# with weights
sp = nx.shortest_path_length(nx.path_graph(3), target=1,
weight='weight')
assert_equal(sp, answer)
# weights and method specified
sp = nx.shortest_path_length(nx.path_graph(3), target=1,
weight='weight', method='dijkstra')
assert_equal(sp, answer)
sp = nx.shortest_path_length(nx.path_graph(3), target=1,
weight='weight', method='bellman-ford')
assert_equal(sp, answer)
def test_dijkstra_predecessor(self):
G = nx.path_graph(4)
assert_equal(
nx.dijkstra_predecessor_and_distance(G, 0), ({0: [], 1: [0], 2: [1], 3: [2]}, {0: 0, 1: 1, 2: 2, 3: 3})
)
G = nx.grid_2d_graph(2, 2)
pred, dist = nx.dijkstra_predecessor_and_distance(G, (0, 0))
assert_equal(
sorted(pred.items()), [((0, 0), []), ((0, 1), [(0, 0)]), ((1, 0), [(0, 0)]), ((1, 1), [(0, 1), (1, 0)])]
)
assert_equal(sorted(dist.items()), [((0, 0), 0), ((0, 1), 1), ((1, 0), 1), ((1, 1), 2)])
XG = nx.DiGraph()
XG.add_weighted_edges_from(
[
("s", "u", 10),
("s", "x", 5),
("u", "v", 1),
("u", "x", 2),
("v", "y", 1),
("x", "u", 3),
("x", "v", 5),
("x", "y", 2),
("y", "s", 7),
("y", "v", 6),
]
)
(P, D) = nx.dijkstra_predecessor_and_distance(XG, "s")
assert_equal(P["v"], ["u"])
assert_equal(D["v"], 9)
def test_P4(self):
"""Edge betweenness centrality: P4"""
G=nx.path_graph(4)
b=nx.edge_betweenness_centrality(G, weight='weight', normalized=False)
b_answer={(0, 1):3,(1, 2):4, (2, 3):3}
for n in sorted(G.edges()):
assert_almost_equal(b[n],b_answer[n])
def test_relatives_to_distance_dict():
G = nx.DiGraph()
G = nx.path_graph(10, create_using=G)
x = G.relatives_to_distance_dict(5, 3)
assert len(x) == 7
assert x == {
2: 3,
3: 2,
4: 1,
5: 0,
6: 1,
7: 2,
8: 3,
}
x = G.relatives_to_distance_dict([3, 4], 2)
assert len(x) == 6
assert x == {
1: 2,
2: 1,
3: 0,
4: 0,
5: 1,
6: 2,
}
def test_path(self):
G = nx.path_graph(10)
assert_equal(list(nx.clustering(G).values()),
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
assert_equal(nx.clustering(G),
{0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0,
5: 0.0, 6: 0.0, 7: 0.0, 8: 0.0, 9: 0.0})
def degree_sequence_tree(deg_sequence):
"""
Make a tree for the given degree sequence.
A tree has #nodes-#edges=1 so
the degree sequence must have
len(deg_sequence)-sum(deg_sequence)/2=1
"""
if not len(deg_sequence)-sum(deg_sequence)/2.0 == 1.0:
raise networkx.NetworkXError,"Degree sequence invalid"
G=empty_graph(0)
# single node tree
if len(deg_sequence)==1:
return G
deg=[s for s in deg_sequence if s>1] # all degrees greater than 1
deg.sort(reverse=True)
# make path graph as backbone
n=len(deg)+2
G=networkx.path_graph(n)
last=n
# add the leaves
for source in range(1,n-1):
nedges=deg.pop()-2
for target in range(last,last+nedges):
G.add_edge(source, target)
last+=nedges
# in case we added one too many
if len(G.degree())>len(deg_sequence):
G.remove_node(0)
return G
def complete_lobster(n, edges, seed=None):
if seed is not None:
random.seed(seed)
p1 = p2 = 1.0
llen=n
L=nx.path_graph(llen)
L.name="random_lobster(%d,%s,%s)"%(n,p1,p2)
# build caterpillar: add edges to path graph with probability p1
current_node=llen-1
for n in xrange(llen):
if npr.random()<p1: # add fuzzy caterpillar parts
current_node+=1
L.add_edge(n,current_node)
if random.random()<p2: # add crunchy lobster bits
current_node+=1
L.add_edge(current_node-1,current_node)
g = nx.MultiDiGraph(L) # voila, un lobster!
for node in g:
# if it's a leaf node, add a self edge and an edge back to the spine
if len(g.out_edges(node)) == 1:
knee = g.in_edges(node)[0][0]
knee_edges = sorted(g.in_edges(knee))
spine = knee_edges[0][0]
g.add_edge(node, spine)
if len(g.out_edges(node)) == 2:
g.add_edge(node, node)
return g
def test_disconnecting_graph(self):
"""Tests that the closeness vitality of a node whose removal
disconnects the graph is negative infinity.
"""
G = nx.path_graph(3)
assert_equal(nx.closeness_vitality(G, node=1), -float('inf'))
def test_path(self):
G = nx.path_graph(10)
assert_equal(list(nx.triangles(G).values()),
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
assert_equal(nx.triangles(G),
{0: 0, 1: 0, 2: 0, 3: 0, 4: 0,
5: 0, 6: 0, 7: 0, 8: 0, 9: 0})
def test_missing_source_edge_paths():
with pytest.raises(nx.NetworkXError):
G = nx.path_graph(4)
list(nx.edge_disjoint_paths(G, 10, 1))
def test_missing_target_node_paths():
with pytest.raises(nx.NetworkXError):
G = nx.path_graph(4)
list(nx.node_disjoint_paths(G, 1, 10))
def test_bipartite_sets(self):
G=nx.path_graph(4)
X,Y=nx.bipartite_sets(G)
assert_equal(X,set([0,2]))
assert_equal(Y,set([1,3]))
import networkx as nx G = nx.Graph() G.add_node(1) H = nx.path_graph(10) G.add_nodes_from(H) G.add_edges_from([(1, 2), (1, 3)]) nx.draw(G, with_labels=True, font_weight='bold') FG = nx.Graph() FG.add_weighted_edges_from([(1, 2, 0.125), (1, 3, 0.75), (2, 4, 1.2), (3, 4, 0.375)])
def makeDirectedPath(num_nodes):
pdg = nx.path_graph(num_nodes, create_using=nx.DiGraph())
for i in pdg.edges():
pdg.edges[i[0], i[1]]['weight'] = weight = random.uniform(0, 1)
return pdg
def makeDirectedPathOne(num_nodes):
pdg = nx.path_graph(num_nodes, create_using=nx.DiGraph())
for i in pdg.edges():
pdg.edges[i[0], i[1]]['weight'] = 1
return pdg
def test_is_bipartite(self):
G=nx.path_graph(4)
assert_true(nx.is_bipartite(G))
def test_digraph_all_simple_paths_with_two_targets_cutoff():
G = nx.path_graph(4, create_using=nx.DiGraph())
G.add_edge(2, 4)
paths = nx.all_simple_paths(G, 0, [3, 4], cutoff=3)
assert {tuple(p) for p in paths} == {(0, 1, 2, 3), (0, 1, 2, 4)}
def setup(self):
self.G = nx.path_graph(9)
self.dv = nx.to_directed(self.G)
self.MG = nx.path_graph(9, create_using=nx.MultiGraph())
self.Mdv = nx.to_directed(self.MG)
def setup(self):
self.G = nx.path_graph(9, create_using=nx.MultiDiGraph())
self.G.add_edge(4, 5)
self.rv = nx.reverse_view(self.G)
def test_all_simple_edge_paths_with_two_targets_in_line_emits_two_paths():
G = nx.path_graph(4)
paths = nx.all_simple_edge_paths(G, 0, [2, 3])
assert {tuple(p)
for p in paths} == {((0, 1), (1, 2)), ((0, 1), (1, 2), (2, 3))}
def test_all_simple_edge_paths():
G = nx.path_graph(4)
paths = nx.all_simple_edge_paths(G, 0, 3)
assert {tuple(p) for p in paths} == {((0, 1), (1, 2), (2, 3))}
def test_full_rary_tree_path(self):
t = nx.full_rary_tree(1, 10)
assert is_isomorphic(t, nx.path_graph(10))
def test_all_simple_paths_empty():
G = nx.path_graph(4)
paths = nx.all_simple_paths(G, 0, 3, cutoff=2)
assert list(paths) == []
def test_all_simple_paths_source_target():
G = nx.path_graph(4)
paths = nx.all_simple_paths(G, 1, 1)
assert list(paths) == []
def setup(self):
self.DG = nx.path_graph(9, create_using=nx.DiGraph())
self.uv = nx.to_undirected(self.DG)
self.MDG = nx.path_graph(9, create_using=nx.MultiDiGraph())
self.Muv = nx.to_undirected(self.MDG)
def test_difference_raise():
G = nx.path_graph(4)
H = nx.path_graph(3)
pytest.raises(nx.NetworkXError, nx.difference, G, H)
pytest.raises(nx.NetworkXError, nx.symmetric_difference, G, H)
def __init__(self,
n_sample,
n,
k=2,
mode='invariant',
type_graph='normal',
type_label='shortest_path',
transform_data=True):
"""
Input:
n_sample : number of samples
n : number of nodes
k : tensorization inside networks, 2 or 3
mode : 'invariant' or 'equivariant'
type_graphs:
'normal': normal edge weights (symmetrized, with absolute value)
'SBM': stochastic block model with K=sqrt(log(n))+1 communities
type_label:
'shortest_path': diameter (longest shortest path) if invariant, longest shortest path from each node if equivariant
'eigen': second largest eigenvalue is invariant, second eigenvector if equivariant
Data:
self.equi (n_sample * n^k * b(k+2)): data, equivariant basis form
self.label (n_sample if invariant, n_sample * n if equivariant)
"""
self.n = n
self.n_sample = n_sample
self.mode = mode
self.k = k
if type_graph == 'normal':
self.Ws = torch.randn(n_sample, n, n)
for i in range(n_sample):
self.Ws[i, :, :] = torch.abs(self.Ws[i, :, :] +
self.Ws[i, :, :].t())
elif type_graph == 'SBM':
self.Ws, _ = torch.tensor(
SBM(n_sample,
n,
K=int(np.sqrt(np.log(n))) + 1,
connectivity=(0.85, 4 * np.log(n) / n)))
elif type_graph == 'special':
choice = np.random.randint(5, size=n_sample)
weights = torch.abs(
torch.randn(n_sample, n,
n)) + 0.01 #*(torch.randn(n_sample))[:,None,None])
self.Ws = torch.zeros(n_sample, n, n)
for i in range(n_sample):
weight = weights[i, :, :] + weights[i, :, :].t()
if choice[i] == 0:
A = nx.complete_graph(n)
elif choice[i] == 1:
A = nx.cycle_graph(n)
elif choice[i] == 2:
A = nx.path_graph(n)
elif choice[i] == 3:
A = nx.star_graph(n - 1)
elif choice[i] == 4:
A = nx.wheel_graph(n)
self.Ws[i, :, :] = torch.tensor(
nx.to_numpy_matrix(A)).float() * weight
if mode == 'equivariant':
self.label = torch.zeros(n_sample, n)
else:
self.label = torch.zeros(n_sample)
for i in range(n_sample):
if type_label == 'shortest_path':
if mode == 'equivariant':
self.label[i, :] = torch.tensor(
np.max(dijkstra(self.Ws[i, :, :], directed=False),
axis=0))
else:
self.label[i] = np.max(
dijkstra(self.Ws[i, :, :], directed=False))
elif type_label == 'eigen':
A = self.Ws[i, :, :].numpy()
eig_values, eig_vec = eigh(A.dot(A), eigvals=[n - 1, n - 1])
if mode == 'equivariant':
self.label[i, :] = torch.tensor(eig_vec).t()
else:
self.label[i] = torch.tensor(eig_values)
print('Create equivariant basis...')
self.equi = transforminput(self.Ws, k)
print('Done.')
def test_P3(self):
G = nx.path_graph(3)
self.test(G, 0, 2, [1])
def setup(self):
self.G = nx.path_graph(9, create_using=nx.DiGraph())
self.rv = nx.reverse_view(self.G)
def test_bipartite_density(self):
G=nx.path_graph(5)
X,Y=nx.bipartite_sets(G)
density=float(len(G.edges()))/(len(X)*len(Y))
assert_equal(nx.bipartite_density(G,X),density)
def setUp(self):
self.null = nx.null_graph()
self.P10 = cnlti(nx.path_graph(10), first_label=1)
self.K10 = cnlti(nx.complete_graph(10), first_label=1)
import networkx as nx
import matplotlib.pyplot as plt
G = nx.path_graph(5)
print(nx.dijkstra_path(G, 0, 4))
nx.draw(G, with_labels=True)
plt.savefig('DijkstraPath.png')
plt.show()
def get_connectivity_graph(qubits, topology='grid', param=None):
attempt = 0
while attempt < 10:
if topology == 'grid':
# assume square grid
side = int(np.sqrt(qubits))
G = nx.grid_2d_graph(side, side)
elif topology == 'erdosrenyi':
if param == None:
print("Erdos Renyi graph needs parameter p.")
G = nx.fast_gnp_random_graph(qubits, param)
elif topology == 'turan':
if param == None:
print("Turan graph needs parameter r.")
G = nx.turan_graph(qubits, param)
elif topology == 'regular':
if param == None:
print("d-regular graph needs parameter d.")
G = nx.random_regular_graph(param, qubits)
elif topology == 'cycle':
G = nx.cycle_graph(qubits)
elif topology == 'wheel':
G = nx.wheel_graph(qubits)
elif topology == 'complete':
G = nx.complete_graph(qubits)
elif topology == 'hexagonal':
# assume square hexagonal grid, node = 2(m+1)**2-2
side = int(np.sqrt((qubits + 2) / 2)) - 1
G = nx.hexagonal_lattice_graph(side, side)
elif topology == 'path':
G = nx.path_graph(qubits)
elif topology == 'ibm_falcon':
# https://www.ibm.com/blogs/research/2020/07/qv32-performance/
# 27 qubits
G = nx.empty_graph(27)
G.name = "ibm_falcon"
G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 4), (3, 5), (5, 6),
(6, 7), (7, 8), (8, 9), (8, 10), (10, 11),
(1, 12), (6, 13), (11, 14), (12, 15), (15, 16),
(16, 17), (17, 18), (17, 19), (19, 20), (13, 20),
(20, 21), (21, 22), (22, 23), (22, 24), (24, 25),
(14, 25), (25, 26)])
elif topology == 'ibm_penguin':
# 20 qubits
G = nx.empty_graph(20)
G.name = "ibm_penguin"
G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 4), (0, 5), (5, 6),
(6, 7), (7, 8), (8, 9), (4, 9), (5, 10),
(10, 11), (11, 12), (7, 12), (12, 13), (13, 14),
(9, 14), (10, 15), (15, 16), (16, 17), (17, 18),
(18, 19), (14, 19)])
elif topology == '1express': # path with express channels
G = nx.convert_node_labels_to_integers(nx.path_graph(qubits))
G.add_edges_from([(s, s + param)
for s in range(0, qubits - param, param // 2)])
elif topology == '2express': # grid with express channels
side = int(np.sqrt(qubits))
G = nx.convert_node_labels_to_integers(nx.grid_2d_graph(
side, side))
G.add_edges_from([
(s, s + param) for x in range(side)
for s in range(x * side, x * side + side - param, param // 2)
]) # rows
G.add_edges_from([
(s, s + param * side) for y in range(side)
for s in range(y, y + side * (side - param), param // 2 * side)
]) # cols
else:
print("Topology %s not recognized; use empty graph instead." %
topology)
G = nx.empty_graph(qubits)
if nx.is_connected(G) or nx.is_empty(G):
break
else:
attempt += 1
return nx.convert_node_labels_to_integers(G)
def test_spring_fixed_without_pos(self):
G = nx.path_graph(4)
pytest.raises(ValueError, nx.spring_layout, G, fixed=[0])
pos = {0: (1, 1), 2: (0, 0)}
pytest.raises(ValueError, nx.spring_layout, G, fixed=[0, 1], pos=pos)
nx.spring_layout(G, fixed=[0, 2], pos=pos) # No ValueError
def test_unrecognized_method(self):
G = nx.path_graph(4)
pytest.raises(nx.NetworkXError,
nx.spectral_ordering,
G,
method="unknown")
def test_graph(self):
G = nx.path_graph(4)
H = loads(dumps(G))
nx.is_isomorphic(G, H)
def test_all_simple_paths_corner_cases():
assert list(nx.all_simple_paths(nx.empty_graph(2), 0, 0)) == []
assert list(nx.all_simple_paths(nx.empty_graph(2), 0, 1)) == []
assert list(nx.all_simple_paths(nx.path_graph(9), 0, 8, 0)) == []
def test_others(self):
(P, D) = nx.bellman_ford(self.XG, 's')
assert_equal(P['v'], 'u')
assert_equal(D['v'], 9)
(P, D) = nx.goldberg_radzik(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.goldberg_radzik(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
}))
assert_equal(nx.goldberg_radzik(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)])
pred, dist = nx.goldberg_radzik(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_bipartite_color(self):
G=nx.path_graph(4)
c=nx.bipartite_color(G)
assert_equal(c,{0: 1, 1: 0, 2: 1, 3: 0})
def setUp(self):
self.P4 = nx.path_graph(4)
self.K3 = nx.complete_bipartite_graph(3,3)
self.C4 = nx.cycle_graph(4)
self.davis = nx.davis_southern_women_graph()
self.top_nodes = [n for n,d in self.davis.nodes(data=True)
if d['bipartite']==0]
