def instance8_1000():
"""
Returns a 3-element tuple (G,T,leaves) where G is the graph
T is the optimal solution and leaves is the number of leaves
in the optimal solution.
The graph is constructed by creating 4 stars with 90 nodes and
adding 10 random nodes.
"""
#create a star of 4 stars
starList = []
for _ in range(0, 6):
starList.append(nx.heawood_graph())
T = nx.Graph()
for star in starList:
T = nx.disjoint_union(T, star)
T.add_node(84)
T.add_edges_from([(84, 0), (84, 14), (84, 28), (84, 42), (84, 56),
(84, 70)])
#add 10 more nodes with random edges
T.add_nodes_from(range(85, 100))
for i in range(85, 100):
x = int(random() * 5371) % 90
T.add_edge(i, x)
#count the number of leaves
leaves = list(T.degree(T.nodes()).values()).count(1)
#randomize the label of nodes
n = range(100)
new = range(100)
r.shuffle(new)
T = nx.relabel_nodes(T, dict(zip(n, new)))
G = nx.Graph()
G.add_nodes_from(T.nodes())
G.add_edges_from(T.edges())
# add random edges
for i in range(1000):
x = int(random() * 15897) % 100
y = int(random() * 17691) % 100
G.add_edge(G.nodes()[x], G.nodes()[y])
for e in G.edges():
if e[0] == e[1]:
G.remove_edge(e[0], e[1])
G = G.to_undirected()
#T = mlst.one_edge_swap(G)
T = nx.Graph()
return (G, T)
def instance8_1000():
"""
Returns a 3-element tuple (G,T,leaves) where G is the graph
T is the optimal solution and leaves is the number of leaves
in the optimal solution.
The graph is constructed by creating 4 stars with 90 nodes and
adding 10 random nodes.
"""
#create a star of 4 stars
starList = []
for _ in range(0,6):
starList.append(nx.heawood_graph())
T = nx.Graph()
for star in starList:
T = nx.disjoint_union(T,star)
T.add_node(84)
T.add_edges_from([(84,0),(84,14),(84,28),(84,42),(84,56),(84,70)])
#add 10 more nodes with random edges
T.add_nodes_from(range(85,100))
for i in range(85,100):
x = int(random()*5371)%90
T.add_edge(i,x)
#count the number of leaves
leaves = list(T.degree(T.nodes()).values()).count(1)
#randomize the label of nodes
n = range(100)
new = range(100)
r.shuffle(new)
T = nx.relabel_nodes(T,dict(zip(n,new)))
G = nx.Graph()
G.add_nodes_from(T.nodes())
G.add_edges_from(T.edges())
# add random edges
for i in range(1000):
x = int(random()*15897)%100
y = int(random()*17691)%100
G.add_edge(G.nodes()[x],G.nodes()[y])
for e in G.edges():
if e[0] == e[1]:
G.remove_edge(e[0],e[1])
G = G.to_undirected()
#T = mlst.one_edge_swap(G)
T = nx.Graph()
return (G,T)
def test_is_distance_regular(self):
assert_true(nx.is_distance_regular(nx.icosahedral_graph()))
assert_true(nx.is_distance_regular(nx.petersen_graph()))
assert_true(nx.is_distance_regular(nx.cubical_graph()))
assert_true(nx.is_distance_regular(nx.complete_bipartite_graph(3,3)))
assert_true(nx.is_distance_regular(nx.tetrahedral_graph()))
assert_true(nx.is_distance_regular(nx.dodecahedral_graph()))
assert_true(nx.is_distance_regular(nx.pappus_graph()))
assert_true(nx.is_distance_regular(nx.heawood_graph()))
assert_true(nx.is_distance_regular(nx.cycle_graph(3)))
# no distance regular
assert_false(nx.is_distance_regular(nx.path_graph(4)))
def test_is_distance_regular(self):
assert_true(nx.is_distance_regular(nx.icosahedral_graph()))
assert_true(nx.is_distance_regular(nx.petersen_graph()))
assert_true(nx.is_distance_regular(nx.cubical_graph()))
assert_true(nx.is_distance_regular(nx.complete_bipartite_graph(3, 3)))
assert_true(nx.is_distance_regular(nx.tetrahedral_graph()))
assert_true(nx.is_distance_regular(nx.dodecahedral_graph()))
assert_true(nx.is_distance_regular(nx.pappus_graph()))
assert_true(nx.is_distance_regular(nx.heawood_graph()))
assert_true(nx.is_distance_regular(nx.cycle_graph(3)))
# no distance regular
assert_false(nx.is_distance_regular(nx.path_graph(4)))
def instance8_2000():
"""
Returns a 3-element tuple (G,T,leaves) where G is the graph
T is the optimal solution and leaves is the number of leaves
in the optimal solution.
The graph is constructed by creating 4 stars with 90 nodes and
adding 10 random nodes.
"""
#create a star of 4 stars
starList = []
for _ in range(0, 6):
starList.append(nx.heawood_graph())
T = nx.Graph()
for star in starList:
T = nx.disjoint_union(T, star)
T.add_node(84)
T.add_edges_from([(84, 0), (84, 14), (84, 28), (84, 42), (84, 56),
(84, 70)])
#add 10 more nodes with random edges
T.add_nodes_from(range(85, 101))
for i in range(85, 101):
x = int(random() * 5371) % 90
T.add_edge(i, x)
#count the number of leaves
leaves = list(T.degree(T.nodes()).values()).count(1)
#randomize the label of nodes
for n in T.nodes():
new = n + int(random() * 2000)
while (new in T.nodes()):
new = n + int(random() * 2000)
T = nx.relabel_nodes(T, {n: new})
G = nx.Graph()
G.add_nodes_from(T.nodes())
G.add_edges_from(T.edges())
# add random edges
while (G.number_of_edges() < 2000):
x = int(random() * 15897) % 100
y = int(random() * 17691) % 100
G.add_edge(G.nodes()[x], G.nodes()[y])
T = mlst.one_edge_swap(G)
return (G, T)
def instance8_2000():
"""
Returns a 3-element tuple (G,T,leaves) where G is the graph
T is the optimal solution and leaves is the number of leaves
in the optimal solution.
The graph is constructed by creating 4 stars with 90 nodes and
adding 10 random nodes.
"""
#create a star of 4 stars
starList = []
for _ in range(0,6):
starList.append(nx.heawood_graph())
T = nx.Graph()
for star in starList:
T = nx.disjoint_union(T,star)
T.add_node(84)
T.add_edges_from([(84,0),(84,14),(84,28),(84,42),(84,56),(84,70)])
#add 10 more nodes with random edges
T.add_nodes_from(range(85,101))
for i in range(85,101):
x = int(random()*5371)%90
T.add_edge(i,x)
#count the number of leaves
leaves = list(T.degree(T.nodes()).values()).count(1)
#randomize the label of nodes
for n in T.nodes():
new = n + int(random()*2000)
while(new in T.nodes()):
new = n + int(random()*2000)
T = nx.relabel_nodes(T,{n:new})
G = nx.Graph()
G.add_nodes_from(T.nodes())
G.add_edges_from(T.edges())
# add random edges
while(G.number_of_edges() < 2000):
x = int(random()*15897)%100
y = int(random()*17691)%100
G.add_edge(G.nodes()[x],G.nodes()[y])
T = mlst.one_edge_swap(G)
return (G,T)
def test_properties_named_small_graphs(self):
G = nx.bull_graph()
assert G.number_of_nodes() == 5
assert G.number_of_edges() == 5
assert sorted(d for n, d in G.degree()) == [1, 1, 2, 3, 3]
assert nx.diameter(G) == 3
assert nx.radius(G) == 2
G = nx.chvatal_graph()
assert G.number_of_nodes() == 12
assert G.number_of_edges() == 24
assert list(d for n, d in G.degree()) == 12 * [4]
assert nx.diameter(G) == 2
assert nx.radius(G) == 2
G = nx.cubical_graph()
assert G.number_of_nodes() == 8
assert G.number_of_edges() == 12
assert list(d for n, d in G.degree()) == 8 * [3]
assert nx.diameter(G) == 3
assert nx.radius(G) == 3
G = nx.desargues_graph()
assert G.number_of_nodes() == 20
assert G.number_of_edges() == 30
assert list(d for n, d in G.degree()) == 20 * [3]
G = nx.diamond_graph()
assert G.number_of_nodes() == 4
assert sorted(d for n, d in G.degree()) == [2, 2, 3, 3]
assert nx.diameter(G) == 2
assert nx.radius(G) == 1
G = nx.dodecahedral_graph()
assert G.number_of_nodes() == 20
assert G.number_of_edges() == 30
assert list(d for n, d in G.degree()) == 20 * [3]
assert nx.diameter(G) == 5
assert nx.radius(G) == 5
G = nx.frucht_graph()
assert G.number_of_nodes() == 12
assert G.number_of_edges() == 18
assert list(d for n, d in G.degree()) == 12 * [3]
assert nx.diameter(G) == 4
assert nx.radius(G) == 3
G = nx.heawood_graph()
assert G.number_of_nodes() == 14
assert G.number_of_edges() == 21
assert list(d for n, d in G.degree()) == 14 * [3]
assert nx.diameter(G) == 3
assert nx.radius(G) == 3
G = nx.hoffman_singleton_graph()
assert G.number_of_nodes() == 50
assert G.number_of_edges() == 175
assert list(d for n, d in G.degree()) == 50 * [7]
assert nx.diameter(G) == 2
assert nx.radius(G) == 2
G = nx.house_graph()
assert G.number_of_nodes() == 5
assert G.number_of_edges() == 6
assert sorted(d for n, d in G.degree()) == [2, 2, 2, 3, 3]
assert nx.diameter(G) == 2
assert nx.radius(G) == 2
G = nx.house_x_graph()
assert G.number_of_nodes() == 5
assert G.number_of_edges() == 8
assert sorted(d for n, d in G.degree()) == [2, 3, 3, 4, 4]
assert nx.diameter(G) == 2
assert nx.radius(G) == 1
G = nx.icosahedral_graph()
assert G.number_of_nodes() == 12
assert G.number_of_edges() == 30
assert (list(
d for n, d in G.degree()) == [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5])
assert nx.diameter(G) == 3
assert nx.radius(G) == 3
G = nx.krackhardt_kite_graph()
assert G.number_of_nodes() == 10
assert G.number_of_edges() == 18
assert (sorted(
d for n, d in G.degree()) == [1, 2, 3, 3, 3, 4, 4, 5, 5, 6])
G = nx.moebius_kantor_graph()
assert G.number_of_nodes() == 16
assert G.number_of_edges() == 24
assert list(d for n, d in G.degree()) == 16 * [3]
assert nx.diameter(G) == 4
G = nx.octahedral_graph()
assert G.number_of_nodes() == 6
assert G.number_of_edges() == 12
assert list(d for n, d in G.degree()) == 6 * [4]
assert nx.diameter(G) == 2
assert nx.radius(G) == 2
G = nx.pappus_graph()
assert G.number_of_nodes() == 18
assert G.number_of_edges() == 27
assert list(d for n, d in G.degree()) == 18 * [3]
assert nx.diameter(G) == 4
G = nx.petersen_graph()
assert G.number_of_nodes() == 10
assert G.number_of_edges() == 15
assert list(d for n, d in G.degree()) == 10 * [3]
assert nx.diameter(G) == 2
assert nx.radius(G) == 2
G = nx.sedgewick_maze_graph()
assert G.number_of_nodes() == 8
assert G.number_of_edges() == 10
assert sorted(d for n, d in G.degree()) == [1, 2, 2, 2, 3, 3, 3, 4]
G = nx.tetrahedral_graph()
assert G.number_of_nodes() == 4
assert G.number_of_edges() == 6
assert list(d for n, d in G.degree()) == [3, 3, 3, 3]
assert nx.diameter(G) == 1
assert nx.radius(G) == 1
G = nx.truncated_cube_graph()
assert G.number_of_nodes() == 24
assert G.number_of_edges() == 36
assert list(d for n, d in G.degree()) == 24 * [3]
G = nx.truncated_tetrahedron_graph()
assert G.number_of_nodes() == 12
assert G.number_of_edges() == 18
assert list(d for n, d in G.degree()) == 12 * [3]
G = nx.tutte_graph()
assert G.number_of_nodes() == 46
assert G.number_of_edges() == 69
assert list(d for n, d in G.degree()) == 46 * [3]
# Test create_using with directed or multigraphs on small graphs
pytest.raises(nx.NetworkXError,
nx.tutte_graph,
create_using=nx.DiGraph)
MG = nx.tutte_graph(create_using=nx.MultiGraph)
assert sorted(MG.edges()) == sorted(G.edges())
def detect_communities(g):
global resultList
resultList = []
global Q
Q = 0
recursive(g, g.nodes())
return Q, resultList
################################################################################
## Test code
################################################################################
if __name__ == '__main__':
def draw_nodes(g, fileName):
colorList = [0] * len(g.nodes())
for nbunch in resultList:
for n in nbunch:
colorList[g.nodes().index(n)] = resultList.index(nbunch)
import matplotlib.pyplot as plt
plt.figure(figsize=(8, 8))
pos = nx.graphviz_layout(g, prog='neato')
nx.draw(g, pos, node_color=colorList, with_labels=False)
plt.savefig(fileName)
g = nx.heawood_graph()
myQ = detect_communities(g)
print "Q = ", myQ[0]
draw_nodes(g, "heawood.png")
import networkx as nx
import matplotlib.pylab as plt
from plot_multigraph import plot_multigraph
graphs = [
("bull", nx.bull_graph()),
("chvatal", nx.chvatal_graph()),
("cubical", nx.cubical_graph()),
("desargues", nx.desargues_graph()),
("diamond", nx.diamond_graph()),
("dodecahedral", nx.dodecahedral_graph()),
("frucht", nx.frucht_graph()),
("heawood", nx.heawood_graph()),
("house", nx.house_graph()),
("house_x", nx.house_x_graph()),
("icosahedral", nx.icosahedral_graph()),
("krackhardt_kite", nx.krackhardt_kite_graph()),
("moebius_kantor", nx.moebius_kantor_graph()),
("octahedral", nx.octahedral_graph()),
("pappus", nx.pappus_graph()),
("petersen", nx.petersen_graph()),
("sedgewick_maze", nx.sedgewick_maze_graph()),
("tetrahedral", nx.tetrahedral_graph()),
("truncated_cube", nx.truncated_cube_graph()),
("truncated_tetrahedron", nx.truncated_tetrahedron_graph()),
]
plot_multigraph(graphs, 4, 5, node_size=50)
plt.savefig('graphs/small.png')
del g.node[v]['visited']
for u, v in g.edges():
if 'visited' in g[u][v]:
del g[u][v]['visited']
if __name__ == '__main__':
targets = {
'bull': nx.bull_graph(), # 1-connected planar
'chvatal': nx.chvatal_graph(), # 4-connected non-planar
'cubical': nx.cubical_graph(), # 3-connected planar
'desargues': nx.desargues_graph(), # 3-connected non-planar
'diamond': nx.diamond_graph(), # 2-connected planar
'dodecahedral': nx.dodecahedral_graph(), # 3-connected planar
'frucht': nx.frucht_graph(), # 3-connected planar
'heawood': nx.heawood_graph(), # 3-connected non-planar
'house': nx.house_graph(), # 2-connected planar
'house_x': nx.house_x_graph(), # 2-connected planar
'icosahedral': nx.icosahedral_graph(), # 5-connected planar
'krackhardt': nx.krackhardt_kite_graph(), # 1-connected planar
'moebius': nx.moebius_kantor_graph(), # non-planar
'octahedral': nx.octahedral_graph(), # 4-connected planar
'pappus': nx.pappus_graph(), # 3-connected non-planar
'petersen': nx.petersen_graph(), # 3-connected non-planar
'sedgewick': nx.sedgewick_maze_graph(), # 1-connected planar
'tetrahedral': nx.tetrahedral_graph(), # 3-connected planar
'truncated_cube': nx.truncated_cube_graph(), # 3-conn. planar
'truncated_tetrahedron': nx.truncated_tetrahedron_graph(),
# 3-connected planar
'tutte': nx.tutte_graph()
} # 3-connected planar
import networkx as nx
import matplotlib.pylab as plt
from plot_multigraph import plot_multigraph
graphs = [
("bull", nx.bull_graph()),
("chvatal", nx.chvatal_graph()),
("cubical", nx.cubical_graph()),
("desargues", nx.desargues_graph()),
("diamond", nx.diamond_graph()),
("dodecahedral", nx.dodecahedral_graph()),
("frucht", nx.frucht_graph()),
("heawood", nx.heawood_graph()),
("house", nx.house_graph()),
("house_x", nx.house_x_graph()),
("icosahedral", nx.icosahedral_graph()),
("krackhardt_kite", nx.krackhardt_kite_graph()),
("moebius_kantor", nx.moebius_kantor_graph()),
("octahedral", nx.octahedral_graph()),
("pappus", nx.pappus_graph()),
("petersen", nx.petersen_graph()),
("sedgewick_maze", nx.sedgewick_maze_graph()),
("tetrahedral", nx.tetrahedral_graph()),
("truncated_cube", nx.truncated_cube_graph()),
("truncated_tetrahedron", nx.truncated_tetrahedron_graph()),
]
plot_multigraph(graphs, 4, 5, node_size=50)
plt.savefig('graphs/small.png')
def test_heawood(self):
expected = False
actual = is_planar(nx.heawood_graph())
self.assertEqual(expected, actual)
Q = 0
recursive(g,g.nodes())
return Q,resultList
################################################################################
## Test code
################################################################################
if __name__ == '__main__':
def draw_nodes(g,fileName):
colorList = [0]*len(g.nodes())
for nbunch in resultList:
for n in nbunch:
colorList[g.nodes().index(n)] = resultList.index(nbunch)
import matplotlib.pyplot as plt
plt.figure(figsize=(8,8))
pos = nx.graphviz_layout(g,prog='neato')
nx.draw(g,pos,node_color=colorList,with_labels=False)
plt.savefig(fileName)
g = nx.heawood_graph()
myQ = detect_communities(g)
print "Q = ",myQ[0]
draw_nodes(g,"heawood.png")
def small_graphs():
print("Make small graph")
G = nx.make_small_graph(
["adjacencylist", "C_4", 4, [[2, 4], [1, 3], [2, 4], [1, 3]]])
draw_graph(G)
G = nx.make_small_graph(
["adjacencylist", "C_4", 4, [[2, 4], [3], [4], []]])
draw_graph(G)
G = nx.make_small_graph(
["edgelist", "C_4", 4, [[1, 2], [3, 4], [2, 3], [4, 1]]])
draw_graph(G)
print("LCF graph")
G = nx.LCF_graph(6, [3, -3], 3)
draw_graph(G)
G = nx.LCF_graph(14, [5, -5], 7)
draw_graph(G)
print("Bull graph")
G = nx.bull_graph()
draw_graph(G)
print("Chvátal graph")
G = nx.chvatal_graph()
draw_graph(G)
print("Cubical graph")
G = nx.cubical_graph()
draw_graph(G)
print("Desargues graph")
G = nx.desargues_graph()
draw_graph(G)
print("Diamond graph")
G = nx.diamond_graph()
draw_graph(G)
print("Dodechaedral graph")
G = nx.dodecahedral_graph()
draw_graph(G)
print("Frucht graph")
G = nx.frucht_graph()
draw_graph(G)
print("Heawood graph")
G = nx.heawood_graph()
draw_graph(G)
print("House graph")
G = nx.house_graph()
draw_graph(G)
print("House X graph")
G = nx.house_x_graph()
draw_graph(G)
print("Icosahedral graph")
G = nx.icosahedral_graph()
draw_graph(G)
print("Krackhardt kite graph")
G = nx.krackhardt_kite_graph()
draw_graph(G)
print("Moebius kantor graph")
G = nx.moebius_kantor_graph()
draw_graph(G)
print("Octahedral graph")
G = nx.octahedral_graph()
draw_graph(G)
print("Pappus graph")
G = nx.pappus_graph()
draw_graph(G)
print("Petersen graph")
G = nx.petersen_graph()
draw_graph(G)
print("Sedgewick maze graph")
G = nx.sedgewick_maze_graph()
draw_graph(G)
print("Tetrahedral graph")
G = nx.tetrahedral_graph()
draw_graph(G)
print("Truncated cube graph")
G = nx.truncated_cube_graph()
draw_graph(G)
print("Truncated tetrahedron graph")
G = nx.truncated_tetrahedron_graph()
draw_graph(G)
print("Tutte graph")
G = nx.tutte_graph()
draw_graph(G)
