def draw_networkx_ex():
G = nx.dodecahedral_graph()
nx.draw(G)
plt.show()
nx.draw_networkx(G, pos=nx.spring_layout(G))
limits = plt.axis('off')
plt.show()
nodes = nx.draw_networkx_nodes(G, pos=nx.spring_layout(G))
plt.show()
edges = nx.draw_networkx_edges(G, pos=nx.spring_layout(G))
plt.show()
labels = nx.draw_networkx_labels(G, pos=nx.spring_layout(G))
plt.show()
edge_labels = nx.draw_networkx_edge_labels(G, pos=nx.spring_layout(G))
plt.show()
print("Circular layout")
nx.draw_circular(G)
plt.show()
print("Random layout")
nx.draw_random(G)
plt.show()
print("Spectral layout")
nx.draw_spectral(G)
plt.show()
print("Spring layout")
nx.draw_spring(G)
plt.show()
print("Shell layout")
nx.draw_shell(G)
plt.show()
print("Graphviz")
def test180_dodecahedralgraph(self):
""" Dodecahedral graph. """
g = nx.dodecahedral_graph()
mate1 = mv.max_cardinality_matching( g )
mate2 = nx.max_weight_matching( g, True )
td.showGraph(g, mate1, "test180_dodecahedralgraph")
self.assertEqual( len(mate1), len(mate2) )
def draw_networkx_ex():
G = nx.dodecahedral_graph()
nx.draw(G)
plt.show()
nx.draw_networkx(G, pos=nx.spring_layout(G))
limits = plt.axis('off')
plt.show()
nodes = nx.draw_networkx_nodes(G, pos=nx.spring_layout(G))
plt.show()
edges = nx.draw_networkx_edges(G, pos=nx.spring_layout(G))
plt.show()
labels = nx.draw_networkx_labels(G, pos=nx.spring_layout(G))
plt.show()
edge_labels = nx.draw_networkx_edge_labels(G, pos=nx.spring_layout(G))
plt.show()
print("Circular layout")
nx.draw_circular(G)
plt.show()
print("Random layout")
nx.draw_random(G)
plt.show()
print("Spectral layout")
nx.draw_spectral(G)
plt.show()
print("Spring layout")
nx.draw_spring(G)
plt.show()
print("Shell layout")
nx.draw_shell(G)
plt.show()
print("Graphviz")
def test_dodecahedral():
G = nx.dodecahedral_graph()
for flow_func in flow_funcs:
assert_equal(3, nx.node_connectivity(G, flow_func=flow_func),
msg=msg.format(flow_func.__name__))
assert_equal(3, nx.edge_connectivity(G, flow_func=flow_func),
msg=msg.format(flow_func.__name__))
def test_dodecahedral():
G = nx.dodecahedral_graph()
for flow_func in flow_funcs:
assert_equal(3, nx.node_connectivity(G, flow_func=flow_func),
msg=msg.format(flow_func.__name__))
assert_equal(3, nx.edge_connectivity(G, flow_func=flow_func),
msg=msg.format(flow_func.__name__))
def __init__(self):
wx.Frame.__init__(self, None, -1)
self.panel = wx.Panel(self)
self.fig = plt.figure()
self.canvas = FigCanvas(self.panel, -1, self.fig)
# G=nx.house_graph()
G=nx.dodecahedral_graph()
edges=nx.draw_networkx_edges(G,pos=nx.spring_layout(G), arrows=False)
# pos={0:(0,0),
# 1:(1,0),
# 2:(0,1),
# 3:(1,1),
# 4:(0.5,2.0)}
node4 = nx.draw_networkx_nodes(G,pos,node_size=2000,nodelist=[4], picker=5, label=['4'])
print node4
nx.draw_networkx_nodes(G,pos,node_size=3000,nodelist=[0,1,2,3],node_color='b')
nx.draw_networkx_labels(G, pos)
# nx.draw_networkx_edges(G,pos,alpha=0.5,width=6)
plt.axis('off')
self.vbox = wx.BoxSizer(wx.VERTICAL)
self.vbox.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
self.toolbar = NavigationToolbar(self.canvas)
self.vbox.Add(self.toolbar, 0, wx.EXPAND)
self.panel.SetSizer(self.vbox)
self.vbox.Fit(self)
self.fig.canvas.mpl_connect('pick_event', onpick)
#
plt.savefig("house_with_colors.png") # save as png
def create_graph():
G = nx.dodecahedral_graph()
for e in G.edges:
G.remove_edge(*e)
break
nx.draw(G)
plt.show()
return G
def test_intersection_array(self):
b, c = nx.intersection_array(nx.cycle_graph(5))
assert_equal(b, [2, 1])
assert_equal(c, [1, 1])
b, c = nx.intersection_array(nx.dodecahedral_graph())
assert_equal(b, [3, 2, 1, 1, 1])
assert_equal(c, [1, 1, 1, 2, 3])
b, c = nx.intersection_array(nx.icosahedral_graph())
assert_equal(b, [5, 2, 1])
assert_equal(c, [1, 2, 5])
def test_intersection_array(self):
b,c=nx.intersection_array(nx.cycle_graph(5))
assert_equal(b,[2, 1])
assert_equal(c,[1, 1])
b,c=nx.intersection_array(nx.dodecahedral_graph())
assert_equal(b,[3, 2, 1, 1, 1])
assert_equal(c,[1, 1, 1, 2, 3])
b,c=nx.intersection_array(nx.icosahedral_graph())
assert_equal(b,[5, 2, 1])
assert_equal(c,[1, 2, 5])
def draw_ex():
G = nx.dodecahedral_graph()
nx.draw(G,
pos=nx.spring_layout(G),
nodecolor='r',
edge_color='b',
with_labels=True,
data='weight')
plt.savefig("draw_graph.png")
plt.show()
def test_intersection_array(self):
b, c = nx.intersection_array(nx.cycle_graph(5))
assert b == [2, 1]
assert c == [1, 1]
b, c = nx.intersection_array(nx.dodecahedral_graph())
assert b == [3, 2, 1, 1, 1]
assert c == [1, 1, 1, 2, 3]
b, c = nx.intersection_array(nx.icosahedral_graph())
assert b == [5, 2, 1]
assert c == [1, 2, 5]
def networkx(request):
if request.method == "POST":
if request.session['graphname'] == 'dodecahedral_graph':
data_network = request.POST.get('dodecahedral_graph')
G = nx.dodecahedral_graph()
shells = data_network
nx.draw(G)
if request.session['graphname'] == 'lollipop_graph':
data_network = request.POST.get('lollipop_graph')
G = nx.dodecahedral_graph()
shells = data_network
nx.draw(G)
if request.session['graphname'] == 'grid_2d_graph':
data_network = request.POST.get('grid_2d_graph')
G = nx.dodecahedral_graph()
shells = data_network
nx.draw(G)
if request.session['graphname'] == 'house_graph':
data_network = request.POST.get('house_graph')
G = nx.dodecahedral_graph()
shells = data_network
nx.draw(G)
if request.session['graphname'] == 'star_graph':
data_network = request.POST.get('star_graph')
G = nx.dodecahedral_graph()
shells = data_network
nx.draw(G)
if request.session['graphname'] == 'cycle_graph':
data_network = request.POST.get('cycle_graph')
G = nx.dodecahedral_graph()
shells = data_network
nx.draw(G)
if request.session['graphname'] == 'path_graph':
data_network = request.POST.get('path_graph')
G = nx.dodecahedral_graph()
shells = data_network
nx.draw(G)
if request.session['graphname'] == 'petersen_graph':
data_network = request.POST.get('petersen_graph')
G = nx.dodecahedral_graph()
shells = data_network
nx.draw(G)
if request.session['graphname'] == 'cubical_graph':
data_network = request.POST.get('cubical_graph')
G = nx.dodecahedral_graph()
shells = data_network
nx.draw(G)
return mlt.show()
def plot_dodecahedral_graph(layout):
G = nx.dodecahedral_graph()
pos = layout(G)
nx.draw_networkx_nodes(G, pos)
nx.draw_networkx_edges(G, pos)
ham_cycle = list(zip(range(19), range(1, 20))) + [(19, 0)]
nx.draw_networkx_edges(G,
pos,
edgelist=ham_cycle,
edge_color='red',
width=2)
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 platonic(n): # n must be 4, 6, 8, 12 or 20
# returns the matrix for sp2 platonic solid, with alpha = 0 and beta = -1
n_int = int(n)
if n_int == 4:
s = nx.tetrahedral_graph()
elif n_int == 6:
s = nx.cubical_graph()
elif n_int == 8:
s = nx.octahedral_graph()
elif n_int == 12:
s = nx.dodecahedral_graph()
elif n_int == 20:
s = nx.icosahedral_graph()
else:
print("n must be equal to 4, 6, 8, 12 or 20")
M = -nx.adjacency_matrix(s)
return M.todense()
def draw2(self, network):
"""docstring"""
edges = self.create_edges(network)
nodes = self.create_nodes(network)
labels = self.create_labels(network)
G = nx.Graph()
G.add_nodes_from(nodes)
G.add_edges_from(edges)
# Draw graph
pos = nx.shell_layout(G)
nx.draw(G, node_color='w', with_labels=True)
G = nx.dodecahedral_graph()
nx.draw_networkx_labels(G, pos, labels)
plt.savefig('network.png')
plt.show()
def drawing_example():
import matplotlib.pyplot as plt
G = nx.petersen_graph()
plt.subplot(121)
nx.draw(G, with_labels=True, font_weight='bold')
plt.subplot(122)
nx.draw_shell(G, nlist=[range(5, 10), range(5)], with_labels=True, font_weight='bold')
plt.show()
options = {
'node_color': 'black',
'node_size': 100,
'width': 3,
}
plt.subplot(221)
nx.draw_random(G, **options)
plt.subplot(222)
nx.draw_circular(G, **options)
plt.subplot(223)
nx.draw_spectral(G, **options)
plt.subplot(224)
nx.draw_shell(G, nlist=[range(5,10), range(5)], **options)
plt.show()
G = nx.dodecahedral_graph()
shells = [[2, 3, 4, 5, 6], [8, 1, 0, 19, 18, 17, 16, 15, 14, 7], [9, 10, 11, 12, 13]]
nx.draw_shell(G, nlist=shells, **options)
plt.show()
# Save drawings to a file.
nx.draw(G)
plt.savefig('./path.png')
# If Graphviz and PyGraphviz or pydot are available on your system,
# you can also use nx_agraph.graphviz_layout(G) or nx_pydot.graphviz_layout(G) to get the node positions,
# or write the graph in dot format for further processing.
pos = nx.nx_agraph.graphviz_layout(G)
nx.draw(G, pos=pos)
nx.drawing.nx_pydot.write_dot(G, './file.dot')
def shapes(self, radius=10, length=100, strength=0.05, damping=0.01, center=True):
G = nx.dodecahedral_graph()
# G = nx.graph_atlas(134)
# G = nx.graph_atlas(1167)
# G = nx.truncated_cube_graph()
# G = nx.truncated_tetrahedron_graph()
# G = nx.cycle_graph(5)
# G = nx.circular_ladder_graph(10)
# G = nx.circulant_graph(10,[1,4,6])
# G = nx.frucht_graph()
# G = nx.moebius_kantor_graph()
# G = nx.random_tree(10, None)
# G = nx.sudoku_graph(2)
# G = nx.pappus_graph()
# G = nx.octahedral_graph()
G = nx.hypercube_graph(4)
# dim = (4,4,4)
# dim = (2,2,6)
# dim = (3,3,3)
# dim = (2,2,2,2)
# dim = (3,3,6)
# G = nx.grid_graph(dim=dim, periodic=False)
# G = nx.wheel_graph(40)
# G = nx.star_graph(21)
# G = nx.hexagonal_lattice_graph(4,3)
# G = nx.triangular_lattice_graph(3,4)
# G = nx.diamond_graph()
# G = nx.grid_2d_graph(3,4, periodic=False)
# G = nx.hypercube_graph(2)
# G = nx.random_geometric_graph(n=8, radius=8, dim=8, p=10)
balls = self.arrange_from_graph(G, radius, length, strength, damping, center)
return balls
# write_json_graph(nx.random_lobster(20, 0.4, 0.6, seed=0), 'random_lobster(20,0_4,0_6).json')
write_json_graph(nx.random_lobster(50, 0.6, 0.4, seed=0),
'random_lobster(50,0_6,0_4).json')
# write_json_graph(nx.random_lobster(50, 0.4, 0.6, seed=0), 'random_lobster(50,0_4,0_6).json')
write_json_graph(nx.random_lobster(100, 0.6, 0.4, seed=0),
'random_lobster(100,0_6,0_4).json')
# write_json_graph(nx.random_lobster(100, 0.4, 0.6, seed=0), 'random_lobster(100,0_4,0_6).json')
# write_json_graph(nx.lollipop_graph(5, 4), 'lollipop_graph(5,4).json')
write_json_graph(nx.lollipop_graph(10, 10), 'lollipop_graph(10,10).json')
write_json_graph(nx.lollipop_graph(20, 50), 'lollipop_graph(20,50).json')
# write_json_graph(nx.petersen_graph(), 'petersen_graph().json')
# write_json_graph(nx.octahedral_graph(), 'octahedral_graph().json')
# write_json_graph(nx.pappus_graph(), 'pappus_graph().json')
write_json_graph(nx.dodecahedral_graph(), 'dodecahedral_graph().json')
write_json_graph(nx.frucht_graph(), 'frucht_graph().json')
# write_json_graph(nx.star_graph(10), 'star_graph(50).json')
# write_json_graph(nx.star_graph(50), 'star_graph(50).json')
# write_json_graph(nx.star_graph(100), 'star_graph(50).json')
write_json_graph(nx.ring_of_cliques(5, 70), 'ring_of_cliques(5,80).json')
write_json_graph(nx.ring_of_cliques(6, 70), 'ring_of_cliques(6,70).json')
# write_json_graph(nx.barbell_graph(3, 4), 'barbell_graph(3,4).json')
# write_json_graph(nx.barbell_graph(3, 8), 'barbell_graph(3,8).json')
write_json_graph(nx.barbell_graph(5, 2), 'barbell_graph(5,2).json')
# write_json_graph(nx.barbell_graph(5, 0), 'barbell_graph(5,0).json')
write_json_graph(nx.barbell_graph(50, 20), 'barbell_graph(50,20).json')
# write_json_graph(nx.barbell_graph(50, 50), 'barbell_graph(50,50).json')
def test_dodecahedral(self):
print '\ndodecahedral:',
self.g = nx.dodecahedral_graph()
a = programming_for_tree_decomposition(self.g, True)
self.t = a.tree_decomposition()
self.assertTrue(self.__test_all_conditions())
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 test_dodecahedral():
G = nx.dodecahedral_graph()
assert_equal(3, approx.node_connectivity(G))
assert_equal(3, approx.node_connectivity(G, 0, 5))
# Step 0: # install the package networkx # !pip install networkx # Step 1: import the package import networkx as networkx #import matplotlib.pyplot as plt from matplotlib import pyplot # Step 2: open the graph from file or create one # Create an example graph: G = networkx.dodecahedral_graph() # #G = networkx.gnm_random_graph(20, 40) G.nodes G.edges # Step 3: Choose the Positions of nodes # Basic choice: random function -assigning random positions to the nodes #nodes_position=networkx.random_layout(G) # Other algorithm to position the nodes on the plane: nodes_position = networkx.spring_layout(G) #nodes_position=networkx.circular_layout(G) # see here for more layouts: https://networkx.github.io/documentation/stable/reference/drawing.html # Step 4: the plot pyplot.figure() networkx.draw(G, pos=nodes_position, node_color='r') # use spring layout
def test_dodecahedral():
# Actual coefficient is 0
G = nx.dodecahedral_graph()
assert_equal(average_clustering(G, trials=int(len(G) / 2)),
nx.average_clustering(G))
def draw(self):
# nx.draw(self.G)
G = nx.dodecahedral_graph()
nx.draw(G)
def test_dodecahedral():
G = nx.dodecahedral_graph()
assert 3 == approx.node_connectivity(G)
assert 3 == approx.node_connectivity(G, 0, 5)
def test_draw():
G = nx.dodecahedral_graph()
nx.draw(G) # networkx draw()
# P.draw() # pylab draw()
plt.show()
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_dodecahedral():
G = nx.dodecahedral_graph()
for flow_func in flow_funcs:
errmsg = f"Assertion failed in function: {flow_func.__name__}"
assert 3 == nx.node_connectivity(G, flow_func=flow_func), errmsg
assert 3 == nx.edge_connectivity(G, flow_func=flow_func), errmsg
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')
edges += generate_edges_for_complete_graphs(
[j for j in range(i * cs, (i + 1) * cs)])
edges += [(i * cs, ((i + 1) * cs) % (nc * cs))]
G.add_edges_from(edges)
return G
# Gs = [nx.cycle_graph(10), nx.grid_graph(dim=[5,5]), nx.full_rary_tree(2, 15), nx.complete_graph(20), nx.complete_bipartite_graph(5, 5), nx.dodecahedral_graph(), nx.hypercube_graph(3), block_graph(5,5), build_networkx_graph('input9.txt')]
# for G in Gs:
# networkx_to_json(G)
Gs = [
('path-5', nx.path_graph(5)),
('path-10', nx.path_graph(10)),
('cycle-10', nx.cycle_graph(10)),
('grid-5-5', nx.grid_graph(dim=[5, 5])),
('grid-10-6', nx.grid_graph(dim=[10, 6])),
('tree-2-3', nx.balanced_tree(2, 3)),
('tree-2-4', nx.balanced_tree(2, 4)),
('tree-2-5', nx.balanced_tree(2, 5)),
('k-5', nx.complete_graph(5)),
('k-20', nx.complete_graph(20)),
('bipartite-graph-5-5', nx.complete_bipartite_graph(5, 5)),
('dodecahedron', nx.dodecahedral_graph()),
('cube', nx.hypercube_graph(3)),
('block-5-5', block_graph(5, 5)),
('input-9', build_networkx_graph('input9.txt')),
]
for name, G in Gs:
print(name)
networkx_to_json_2(G, name)
def test_dodecahedral():
G = nx.dodecahedral_graph()
assert_equal(3, approx.node_connectivity(G))
assert_equal(3, approx.node_connectivity(G, 0, 5))
def test_dodecahedral():
# Actual coefficient is 0
G = nx.dodecahedral_graph()
assert (average_clustering(G, trials=int(len(G) / 2)) ==
nx.average_clustering(G))
def test_dodecahedral():
G = nx.dodecahedral_graph()
assert_equal(3, nx.node_connectivity(G))
assert_equal(3, nx.edge_connectivity(G))
def DodecahedralGraph():
"""
Returns a Dodecahedral graph (with 20 nodes)
The dodecahedral graph is cubic symmetric, so the spring-layout
algorithm will be very effective for display. It is dual to the
icosahedral graph.
PLOTTING: The Dodecahedral graph should be viewed in 3 dimensions.
We chose to use the default spring-layout algorithm here, so that
multiple iterations might yield a different point of reference for
the user. We hope to add rotatable, 3-dimensional viewing in the
future. In such a case, a string argument will be added to select
the flat spring-layout over a future implementation.
EXAMPLES: Construct and show a Dodecahedral graph
::
sage: g = graphs.DodecahedralGraph()
sage: g.show() # long time
Create several dodecahedral graphs in a Sage graphics array They
will be drawn differently due to the use of the spring-layout
algorithm
::
sage: g = []
sage: j = []
sage: for i in range(9):
... k = graphs.DodecahedralGraph()
... g.append(k)
...
sage: for i in range(3):
... n = []
... for m in range(3):
... n.append(g[3*i + m].plot(vertex_size=50, vertex_labels=False))
... j.append(n)
...
sage: G = sage.plot.graphics.GraphicsArray(j)
sage: G.show() # long time
"""
import networkx
G = networkx.dodecahedral_graph()
pos = {}
r1 = 7
r2 = 4.7
r3 = 3.8
r4 = 1.5
for i,v in enumerate([19,0,1,2,3]):
i = i + .25
pos[v] = (r1*cos(i*2*pi/5),r1*sin(i*2*pi/5))
for i,v in enumerate([18,10,8,6,4]):
i = i + .25
pos[v] = (r2*cos(i*2*pi/5),r2*sin(i*2*pi/5))
for i,v in enumerate([17,11,9,7,5]):
i = i - .25
pos[v] = (r3*cos(i*2*pi/5),r3*sin(i*2*pi/5))
for i,v in enumerate([12,13,14,15,16]):
i = i + .75
pos[v] = (r4*cos(i*2*pi/5),r4*sin(i*2*pi/5))
return graph.Graph(G, name="Dodecahedron", pos=pos)
# https://networkx.github.io/documentation/networkx-1.9.1/reference/algorithms.operators.html import networkx as nx import matplotlib.pyplot as plt import numpy numpy.random.seed(121) G = nx.dodecahedral_graph() edge_labels = nx.draw_networkx_edge_labels(G ,pos=nx.spring_layout(G)) nx.draw( G ) plt.show()
def DodecahedralGraph():
"""
Returns a Dodecahedral graph (with 20 nodes)
The dodecahedral graph is cubic symmetric, so the spring-layout
algorithm will be very effective for display. It is dual to the
icosahedral graph.
PLOTTING: The Dodecahedral graph should be viewed in 3 dimensions.
We chose to use the default spring-layout algorithm here, so that
multiple iterations might yield a different point of reference for
the user. We hope to add rotatable, 3-dimensional viewing in the
future. In such a case, a string argument will be added to select
the flat spring-layout over a future implementation.
EXAMPLES: Construct and show a Dodecahedral graph
::
sage: g = graphs.DodecahedralGraph()
sage: g.show() # long time
Create several dodecahedral graphs in a Sage graphics array They
will be drawn differently due to the use of the spring-layout
algorithm
::
sage: g = []
sage: j = []
sage: for i in range(9):
....: k = graphs.DodecahedralGraph()
....: g.append(k)
sage: for i in range(3):
....: n = []
....: for m in range(3):
....: n.append(g[3*i + m].plot(vertex_size=50, vertex_labels=False))
....: j.append(n)
sage: G = graphics_array(j)
sage: G.show() # long time
"""
import networkx
G = networkx.dodecahedral_graph()
pos = {}
r1 = 7
r2 = 4.7
r3 = 3.8
r4 = 1.5
for i, v in enumerate([19, 0, 1, 2, 3]):
i = i + .25
pos[v] = (r1 * cos(i * 2 * pi / 5), r1 * sin(i * 2 * pi / 5))
for i, v in enumerate([18, 10, 8, 6, 4]):
i = i + .25
pos[v] = (r2 * cos(i * 2 * pi / 5), r2 * sin(i * 2 * pi / 5))
for i, v in enumerate([17, 11, 9, 7, 5]):
i = i - .25
pos[v] = (r3 * cos(i * 2 * pi / 5), r3 * sin(i * 2 * pi / 5))
for i, v in enumerate([12, 13, 14, 15, 16]):
i = i + .75
pos[v] = (r4 * cos(i * 2 * pi / 5), r4 * sin(i * 2 * pi / 5))
return Graph(G, name="Dodecahedron", pos=pos)
def draw_ex():
G = nx.dodecahedral_graph()
nx.draw(G, pos=nx.spring_layout(G), nodecolor='r', edge_color='b', with_labels=True, data='weight')
plt.savefig("draw_graph.png")
plt.show()
pass
if verify_planar_necessary_condition(G):
six = True
return one, two, three, four, five, six
### DO NOT TURN IN AN ASSIGNMENT WITH ANYTHING BELOW HERE MODIFIED ###
if __name__ == '__main__':
G1 = nx.Graph()
G1.add_edges_from([(1, 2), (2, 3), (3, 4), (4, 5), (2, 6)])
G2 = nx.Graph()
G2.add_edges_from([(1, 2), (2, 3), (3, 4), (4, 5), (3, 6)])
K_5 = nx.complete_graph(5)
K_3_5 = nx.complete_bipartite_graph(3, 5)
planar_graph = nx.dodecahedral_graph()
print("#######################################")
print("Welcome to Coding 3: Graph Theory!")
print("#######################################")
print()
print("---------------------------------------")
print("PART A: Basics in Graph theory")
print("---------------------------------------")
print("Part (a)")
print("---------------------------------------")
print("Test Case 1: ")
student_ans_1 = graph_properties(G1)
print("Test Case 1 (Your Answer):", student_ans_1)
print("Test Case 1 (Correct Answer):", (6, 5, [1, 1, 1, 2, 2, 3]))
print()
'''
Created on Nov 27, 2012
@author: Nguyen Huu Hiep
'''
import pylab as P #
import networkx as nx
import matplotlib.pyplot as plt
G = nx.dodecahedral_graph()
pos = nx.spring_layout(G)
nx.draw(G, pos) # networkx draw()
#P.draw() # pylab draw()
plt.savefig("fig/dodecahedral_graph.png") # save as png
plt.show() # display
def drawing_tutorial():
import matplotlib.pyplot as plt
G = nx.petersen_graph()
plt.subplot(121)
nx.draw(G, with_labels=True, font_weight='bold')
plt.subplot(122)
nx.draw_shell(G,
nlist=[range(5, 10), range(5)],
with_labels=True,
font_weight='bold')
plt.show()
options = {
'node_color': 'black',
'node_size': 100,
'width': 3,
}
plt.subplot(221)
nx.draw_random(G, **options)
plt.subplot(222)
#nx.draw_planar(G, **options)
nx.draw_circular(G, **options)
plt.subplot(223)
nx.draw_spectral(G, **options)
#nx.draw_spring(G, **options)
#nx.draw_kamada_kawai(G, **options)
plt.subplot(224)
nx.draw_shell(G, nlist=[range(5, 10), range(5)], **options)
plt.show()
G = nx.dodecahedral_graph()
shells = [[2, 3, 4, 5, 6], [8, 1, 0, 19, 18, 17, 16, 15, 14, 7],
[9, 10, 11, 12, 13]]
nx.draw_shell(G, nlist=shells, **options)
plt.show()
# Save drawings to a file.
nx.draw(G)
plt.savefig('./path.png')
# If Graphviz and PyGraphviz or pydot are available on your system,
# you can also use nx_agraph.graphviz_layout(G) or nx_pydot.graphviz_layout(G) to get the node positions,
# or write the graph in dot format for further processing.
pos = nx.nx_agraph.graphviz_layout(
G) # e.g.) pos = {1: (10, 10), 2: (30, 20)}.
nx.draw(G, pos=pos)
nx.drawing.nx_pydot.write_dot(G, './file.dot')
#--------------------
G = nx.complete_graph(15)
#pos = nx.get_node_attributes(G, 'pos')
#pos = nx.nx_agraph.graphviz_layout(G)
#pos = nx.drawing.nx_pydot.graphviz_layout(G)
#pos = nx.drawing.nx_pydot.pydot_layout(G)
#pos = nx.random_layout(G)
#pos = nx.planar_layout(G)
#pos = nx.circular_layout(G)
pos = nx.spectral_layout(G)
#pos = nx.spiral_layout(G)
#pos = nx.spring_layout(G)
#pos = nx.shell_layout(G)
#pos = nx.kamada_kawai_layout(G)
#pos = nx.rescale_layout(G)
#pos = nx.rescale_layout_dict(G)
#pos = nx.bipartite_layout(G)
#pos = nx.multipartite_layout(G)
plt.figure(figsize=(10, 6))
nx.draw_networkx_nodes(G,
pos,
node_size=400,
alpha=1.0,
node_shape='o',
node_color='red')
nx.draw_networkx_edges(G, pos, width=5, alpha=0.8, edge_color='blue')
#nx.draw_networkx_labels(G, pos, labels=None, font_size=12, font_color='k', font_family='sans-serif', font_weight='normal')
#nx.draw_networkx_edge_labels(G, pos, edge_labels=None, label_pos=0.5, font_size=12, font_color='k', font_family='sans-serif', font_weight='normal')
plt.tight_layout()
plt.axis('off')
#plt.savefig('./graph_drawing_1.svg')
plt.figure(figsize=(10, 6))
#nx.draw(G, pos, ax=None)
#nx.draw(G, pos, labels=node_labels, **options)
#nx.draw(G, pos, labels=nx.get_node_attributes(G, 'node_labels'), **options)
nx.draw_networkx(G, pos, arrows=None, with_labels=True)
plt.tight_layout()
plt.axis('off')
#plt.savefig('./graph_drawing_2.svg')
plt.show()
def test_dodecahedral():
G = nx.dodecahedral_graph()
assert_equal(3, nx.node_connectivity(G))
assert_equal(3, nx.edge_connectivity(G))
for v in g.nodes():
if 'visited' in g.node[v]:
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
