def test_dorogovtsev_goltsev_mendes_graph(self):
G = nx.dorogovtsev_goltsev_mendes_graph(0)
assert_edges_equal(G.edges(), [(0, 1)])
assert_nodes_equal(list(G), [0, 1])
G = nx.dorogovtsev_goltsev_mendes_graph(1)
assert_edges_equal(G.edges(), [(0, 1), (0, 2), (1, 2)])
assert nx.average_clustering(G) == 1.0
assert sorted(nx.triangles(G).values()) == [1, 1, 1]
G = nx.dorogovtsev_goltsev_mendes_graph(10)
assert nx.number_of_nodes(G) == 29526
assert nx.number_of_edges(G) == 59049
assert G.degree(0) == 1024
assert G.degree(1) == 1024
assert G.degree(2) == 1024
pytest.raises(
nx.NetworkXError,
nx.dorogovtsev_goltsev_mendes_graph,
7,
create_using=nx.DiGraph,
)
pytest.raises(
nx.NetworkXError,
nx.dorogovtsev_goltsev_mendes_graph,
7,
create_using=nx.MultiGraph,
)
def classic_graphs():
print("Balanced Tree")
BG = nx.balanced_tree(3, 2)
draw_graph(BG)
print("Barbell Graph")
BBG = nx.barbell_graph(3, 2)
draw_graph(BBG)
print("Complete Graph")
CG = nx.complete_graph(10)
draw_graph(CG)
print("Complete Multipartite Graph")
CMG = nx.complete_multipartite_graph(1, 2, 10)
print([CMG.node[u]['block'] for u in CMG])
print(CMG.edges(0))
print(CMG.edges(2))
print(CMG.edges(4))
draw_graph(CMG)
print("Circular Ladder Graph")
CLG = nx.circular_ladder_graph(5)
draw_graph(CLG)
print("Dorogovtsev Goltsev Mendes Graph")
DGMG = nx.dorogovtsev_goltsev_mendes_graph(3)
draw_graph(DGMG)
print("Empty Graph")
EG = nx.empty_graph(5, create_using=nx.DiGraph())
draw_graph(EG)
print("Grid 2D Graph")
G2DG = nx.grid_2d_graph(5, 6)
draw_graph(G2DG)
print("Grid Graph")
GDG = nx.grid_graph(dim=[5, 2])
draw_graph(GDG)
print("Hypercube Graph")
HG = nx.hypercube_graph(3)
draw_graph(HG)
print("Ladder Graph")
LG = nx.ladder_graph(8)
draw_graph(LG)
print("Ladder Graph")
LG = nx.ladder_graph(8)
draw_graph(LG)
print("Lollipop Graph")
LPG = nx.lollipop_graph(n=6, m=4)
draw_graph(LPG)
print("Null Graph")
NG = nx.null_graph()
draw_graph(NG)
print("Path Graph")
PG = nx.path_graph(16)
draw_graph(PG)
print("Star Graph")
SG = nx.star_graph(16)
draw_graph(SG)
print("Trivial Graph")
TG = nx.trivial_graph()
draw_graph(TG)
print("Wheel Graph")
WG = nx.wheel_graph(n=18)
draw_graph(WG)
def build(self) -> nx.Graph:
if self.generation is None:
raise nx.NetworkXError("graph builder not properly configured.")
G = nx.dorogovtsev_goltsev_mendes_graph(self.generation)
if self.attribute_factory is not None:
for node, data in G.nodes(data=True):
for k, factory in self.attribute_factory.items():
data[k] = factory()
return G
def doro_network(generation, weighted):
#Generate Network:
doro_network = nx.dorogovtsev_goltsev_mendes_graph(generation)
#Give the nodes an initial position:
node_position = position_nodes(doro_network)
#If the network is weighted, add edge weights:
#if weighted:
# weight_edges(erdo_network)
return doro_network, node_position
def make_graph(g_name, n):
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(g_name)
def generator(n):
'''Generator for our social graph.
Our graph will have n nodes, it will be a Dorogovtsev-Mendes's Graph, and
it will handle reputation (for nodes) and affect (for edges).'''
G = nx.dorogovtsev_goltsev_mendes_graph(1)
'''In this loop we generate a raw network'''
for i in range(n-3):
r = random.choice(range(nx.number_of_edges(G)))
e = nx.edges(G)
e = e[r] #e is the selected edge
nn = G.number_of_nodes() #nn is the new node number
G.add_node(nn)
G.add_edge(nn, e[0])
G.add_edge(nn, e[1])
'''In this bloc we set reputations'''
reput = {}
md = graphlib.max_degree(G)
for i in range(G.number_of_nodes()):
reput[i] = random.random() #float(G.degree(i))/float(md)
nx.set_node_attributes(G,'reput',reput)
'''And then we set affect'''
affect = {}
e = nx.edges(G)
for i in range(G.number_of_edges()):
affect[e[i]] = random.random()
nx.set_edge_attributes(G,'affect',affect)
return G
# 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')
# write_json_graph(nx.dorogovtsev_goltsev_mendes_graph(2), 'dorogovtsev_goltsev_mendes_graph(2).json')
# write_json_graph(nx.dorogovtsev_goltsev_mendes_graph(3), 'dorogovtsev_goltsev_mendes_graph(3).json')
write_json_graph(nx.dorogovtsev_goltsev_mendes_graph(4),
'dorogovtsev_goltsev_mendes_graph(4).json')
write_json_graph(nx.dorogovtsev_goltsev_mendes_graph(5),
'dorogovtsev_goltsev_mendes_graph(5).json')
# write_json_graph(nx.navigable_small_world_graph(8), 'navigable_small_world_graph(8).json')
# write_json_graph(nx.navigable_small_world_graph(20), 'navigable_small_world_graph(20).json')
write_json_graph(nx.circular_ladder_graph(5), 'circular_ladder_graph(5).json')
write_json_graph(nx.circular_ladder_graph(100),
'circular_ladder_graph(100).json')
write_json_graph(nx.duplication_divergence_graph(50, 0.5, seed=0),
'duplication_divergence_graph(50,0_5).json')
write_json_graph(nx.watts_strogatz_graph(100, 3, 0.05),
def test_line_inverse_line_dgm(self):
G = nx.dorogovtsev_goltsev_mendes_graph(4)
H = nx.line_graph(G)
J = nx.inverse_line_graph(H)
assert nx.is_isomorphic(G, J)
def gen_laplacian(data_num=DATA_NUM, opt=27, cache=False):
label = None
if cache:
print('Loading cached graph')
graph = pk.load(open('tmp/g.pk', 'rb'))
else:
print('Generating graph opt {}'.format(opt))
if 1 == opt:
graph = gen_rand_graph(data_num=data_num)
if 2 == opt:
top_num = random.randint(1, data_num)
bottom_num = data_num - top_num
graph = nx.bipartite.random_graph(top_num, bottom_num, 0.9)
label = [d['bipartite'] for n, d in graph.nodes(data=True)]
elif 3 == opt:
graph = nx.balanced_tree(4, 5)
elif 4 == opt:
graph = nx.complete_graph(data_num)
elif 5 == opt:
no1 = random.randint(1, data_num)
no2 = random.randint(1, int(data_num / no1))
no3 = data_num / no1 / no2
graph = nx.complete_multipartite_graph(no1, no2, no3)
elif 6 == opt:
graph = nx.circular_ladder_graph(data_num)
elif 7 == opt:
graph = nx.cycle_graph(data_num)
elif 8 == opt:
graph = nx.dorogovtsev_goltsev_mendes_graph(5)
elif 9 == opt:
top_num = int(random.random() * data_num)
bottom_num = data_num / top_num
graph = nx.grid_2d_graph(top_num, bottom_num)
elif 10 == opt:
no1 = random.randint(1, data_num)
no2 = random.randint(1, int(data_num / no1))
no3 = data_num / no1 / no2
graph = nx.grid_graph([no1, no2, no3])
elif 11 == opt:
graph = nx.hypercube_graph(10)
elif 12 == opt:
graph = nx.ladder_graph(data_num)
elif 13 == opt:
top_num = int(random.random() * data_num)
bottom_num = data_num - top_num
graph = nx.lollipop_graph(top_num, bottom_num)
elif 14 == opt:
graph = nx.path_graph(data_num)
elif 15 == opt:
graph = nx.star_graph(data_num)
elif 16 == opt:
graph = nx.wheel_graph(data_num)
elif 17 == opt:
graph = nx.margulis_gabber_galil_graph(35)
elif 18 == opt:
graph = nx.chordal_cycle_graph(data_num)
elif 19 == opt:
graph = nx.fast_gnp_random_graph(data_num, random.random())
elif 20 == opt: # jump eigen value
graph = nx.gnp_random_graph(data_num, random.random())
elif 21 == opt: # disconnected graph
graph = nx.dense_gnm_random_graph(data_num, data_num / 2)
elif 22 == opt: # disconnected graph
graph = nx.gnm_random_graph(data_num, data_num / 2)
elif 23 == opt:
graph = nx.erdos_renyi_graph(data_num, data_num / 2)
elif 24 == opt:
graph = nx.binomial_graph(data_num, data_num / 2)
elif 25 == opt:
graph = nx.newman_watts_strogatz_graph(data_num, 5,
random.random())
elif 26 == opt:
graph = nx.watts_strogatz_graph(data_num, 5, random.random())
elif 26 == opt: # smooth eigen
graph = nx.connected_watts_strogatz_graph(data_num, 5,
random.random())
elif 27 == opt: # smooth eigen
graph = nx.random_regular_graph(5, data_num)
elif 28 == opt: # smooth eigen
graph = nx.barabasi_albert_graph(data_num, 5)
elif 29 == opt: # smooth eigen
graph = nx.powerlaw_cluster_graph(data_num, 5, random.random())
elif 30 == opt: # smooth eigen
graph = nx.duplication_divergence_graph(data_num, random.random())
elif 31 == opt:
p = random.random()
q = random.random()
graph = nx.random_lobster(data_num, p, q)
elif 32 == opt:
p = random.random()
q = random.random()
k = random.random()
graph = nx.random_shell_graph([(data_num / 3, 50, p),
(data_num / 3, 40, q),
(data_num / 3, 30, k)])
elif 33 == opt: # smooth eigen
top_num = int(random.random() * data_num)
bottom_num = data_num - top_num
graph = nx.k_random_intersection_graph(top_num, bottom_num, 3)
elif 34 == opt:
graph = nx.random_geometric_graph(data_num, .1)
elif 35 == opt:
graph = nx.waxman_graph(data_num)
elif 36 == opt:
graph = nx.geographical_threshold_graph(data_num, .5)
elif 37 == opt:
top_num = int(random.random() * data_num)
bottom_num = data_num - top_num
graph = nx.uniform_random_intersection_graph(
top_num, bottom_num, .5)
elif 39 == opt:
graph = nx.navigable_small_world_graph(data_num)
elif 40 == opt:
graph = nx.random_powerlaw_tree(data_num, tries=200)
elif 41 == opt:
graph = nx.karate_club_graph()
elif 42 == opt:
graph = nx.davis_southern_women_graph()
elif 43 == opt:
graph = nx.florentine_families_graph()
elif 44 == opt:
graph = nx.complete_multipartite_graph(data_num, data_num,
data_num)
# OPT 1
# norm_lap = nx.normalized_laplacian_matrix(graph).toarray()
# OPT 2: renormalized
# pk.dump(graph, open('tmp/g.pk', 'wb'))
# plot_graph(graph, label)
# note difference: normalized laplacian and normalzation by eigenvalue
norm_lap, eigval, eigvec = normalize_lap(graph)
return graph, norm_lap, eigval, eigvec
def test_line_inverse_line_dgm(self):
G = nx.dorogovtsev_goltsev_mendes_graph(4)
H = nx.line_graph(G)
J = nx.inverse_line_graph(H)
assert_true(nx.is_isomorphic(G, J))
g = nx.barabasi_albert_graph(num_n, 4)
g_name = 'NETWORKX.BARABASI_ALBERT_4'
elif graph_type == 7:
g = nx.barabasi_albert_graph(num_n, 6)
g_name = 'NETWORKX.BARABASI_ALBERT_6'
elif graph_type == 8:
g = nx.barabasi_albert_graph(num_n, 7)
g_name = 'NETWORKX.BARABASI_ALBERT_7'
elif graph_type == 9:
g = nx.barabasi_albert_graph(num_n, 2)
g_name = 'NETWORKX.BARABASI_ALBERT_2'
elif graph_type == 10:
g = nx.path_graph(num_n)
g_name = 'NETWORKX.PATH_GRAPH'
elif graph_type == 11:
g = nx.dorogovtsev_goltsev_mendes_graph(num_n)
g_name = 'NETWORKX.DOROGOVTSEV_GOLTSEV_MENDES'
print "Analyzing graph features"
graph_insert = "INSERT INTO graphs values " + str(
get_graph_features(g) + (g_name, ))
graph_insert = graph_insert.replace("values (", "values (NULL, ")
print "Inserting new graph into database."
#print graph_insert
print "Running trial on", g_name, "graph."
dba.query_insert(graph_insert)
result = dba.query("SELECT MAX(graph_id) as id FROM graphs")
if result:
graph_id = result[0][0]
#print graph_insert
print "Running trial on", g_name, "graph."
sys.stdout.flush()
import networkx as nx
import random
import numpy
dgm = nx.dorogovtsev_goltsev_mendes_graph(9)
print("Nodes:", nx.number_of_nodes(dgm), " Edges:", nx.number_of_edges(dgm),
"Diameter:", nx.diameter(dgm))
periphery = nx.periphery(dgm)
pmax = 0
smax = 0
tmax = 0
for source in periphery:
for target in periphery:
spath = nx.shortest_path_length(dgm, source, target)
if pmax < spath:
pmax = spath
smax = source
tmax = target
label_attr = {smax: {'source': 'A'}, tmax: {'target': 'B'}}
nx.set_node_attributes(dgm, label_attr)
for e in nx.edges(dgm):
dgm[e[0]][e[1]]['weight'] = random.randint(1, 100)
print("Path from A to B: ",
nx.single_source_dijkstra(dgm, source=smax, target=tmax))
def dgmhierarchy():
G = nx.dorogovtsev_goltsev_mendes_graph(6)
nx.write_edgelist(G, args.type + '.txt')
nodesR = int(input("Number of nodes for connections: "))
G = nx.barbell_graph(nodesL, nodesR)
pos = nx.spring_layout(G, k=1, iterations=100)
break
elif mode == 3:
rows = int(input("Number of rows: "))
cols = int(input("Number of cols: "))
G = nx.grid_2d_graph(rows, cols)
pos = nx.spectral_layout(G)
break
elif mode == 4:
nodes = int(input("Number of generations (<= 5): "))
if nodes > 5:
print("Invalid input! Please execute script again.")
sys.exit()
G = nx.dorogovtsev_goltsev_mendes_graph(nodes)
pos = nx.spring_layout(G, k=1, iterations=100)
break
elif mode == 5:
nodes = int(input("Number of nodes: "))
G = nx.cycle_graph(nodes)
pos = nx.circular_layout(G)
break
elif mode == 6:
nodes = int(input("Number of nodes: "))
G = nx.circular_ladder_graph(nodes)
pos = nx.spring_layout(G, k=1, iterations=100)
break
elif mode == 7:
nodesK = int(input("Number of nodes in candy: "))
nodesP = int(input("Number of nodes in stick: "))
def test_homomorphic():
k4 = nx.complete_graph(4) # is 4-colorable?
for n in range(2, 9):
g = nx.dorogovtsev_goltsev_mendes_graph(n) # generate a planar graph
assert is_isomorphic(g, k4, problem='h**o')
#star_graph = nx.star_graph(n1)
#outpath = 'star_graph_' + str(n1) + '.txt'
#nx.write_edgelist(star_graph, outpath, data=False)
#convert_edgelist_to_graphviz(outpath)
#print('Generating [Lollipop Graph]')
#k_m = 4
#p_n = 3
#lollipop_graph = nx.lollipop_graph(k_m, p_n)
#outpath = 'lollipop_graph_' + str(k_m) + '_' + str(p_n) + '.txt'
#nx.write_edgelist(lollipop_graph, outpath, data=False)
#convert_edgelist_to_graphviz(outpath)
print('Generating [Dorogovtsev-Goltsev-Mendes Graph]')
n = 20
dgm_graph = nx.dorogovtsev_goltsev_mendes_graph(n)
outpath = 'dgm_graph_' + str(n) + '.txt'
nx.write_edgelist(dgm_graph, outpath, data=False)
convert_edgelist_to_graphviz(outpath)
sys.exit(0)
print('Generating [Erdos-Renyi Graph]')
n = 100
p = 0.7
erdos_renyi_graph = nx.erdos_renyi_graph(n, p)
outpath = 'erdos_renyi_graph_' + str(n) + '.txt'
nx.write_edgelist(erdos_renyi_graph, outpath, data=False)
convert_edgelist_to_graphviz(outpath)
print('Generating [Preferential Attachment Model Graph]')
n = 100
m = 5
'args': ('n', ),
'argtypes': (int, ),
'argvals': (3, ),
'gen': lambda n: nx.cycle_graph(n),
'description_fn': 'cycle_graph(n)',
'description':
'Returns the cycle graph Cn of cyclically connected nodes.',
},
'dorogovtsev_goltsev_mendes_graph': {
'name':
'Dorogovtsev Goltsev Mendes Graph',
'args': ('n', ),
'argtypes': (int, ),
'argvals': (3, ),
'gen':
lambda n: nx.dorogovtsev_goltsev_mendes_graph(n),
'description_fn':
'dorogovtsev_goltsev_mendes_graph(n)',
'description':
'Returns the hierarchically constructed Dorogovtsev-Goltsev-Mendes graph.',
},
'dorogovtsev_goltsev_mendes_graph': {
'name':
'Dorogovtsev Goltsev Mendes Graph',
'args': ('n', ),
'argtypes': (int, ),
'argvals': (3, ),
'gen':
lambda n: nx.dorogovtsev_goltsev_mendes_graph(n),
'description_fn':
'dorogovtsev_goltsev_mendes_graph(n)',
nx.set_node_attributes(G,'reput',reput)
'''And then we set affect'''
affect = {}
e = nx.edges(G)
for i in range(G.number_of_edges()):
affect[e[i]] = random.random()
nx.set_edge_attributes(G,'affect',affect)
return G
if __name__ == "__main__":
G1 = nx.dorogovtsev_goltsev_mendes_graph(1)
G2 = G1.copy()
r = random.choice(range(nx.number_of_edges(G2)))
e = nx.edges(G2)
e = e[r] #e is the selected edge
nn = G2.number_of_nodes() #nn is the new node number
G2.add_node(nn)
G2.add_edge(nn, e[0])
G2.add_edge(nn, e[1])
G3 = G2.copy()
def test070_dorogovtsev_goltsev_mendes_graph(self):
""" Large dorogovtsev goltsev mendes graph. """
g = nx.dorogovtsev_goltsev_mendes_graph(9)
mate1 = mv.max_cardinality_matching( g )
mate2 = nx.max_weight_matching( g, True )
self.assertEqual( len(mate1), len(mate2) )
#star_graph = nx.star_graph(n1)
#outpath = 'star_graph_' + str(n1) + '.txt'
#nx.write_edgelist(star_graph, outpath, data=False)
#convert_edgelist_to_graphviz(outpath)
#print('Generating [Lollipop Graph]')
#k_m = 4
#p_n = 3
#lollipop_graph = nx.lollipop_graph(k_m, p_n)
#outpath = 'lollipop_graph_' + str(k_m) + '_' + str(p_n) + '.txt'
#nx.write_edgelist(lollipop_graph, outpath, data=False)
#convert_edgelist_to_graphviz(outpath)
print('Generating [Dorogovtsev-Goltsev-Mendes Graph]')
n = 20
dgm_graph = nx.dorogovtsev_goltsev_mendes_graph(n)
outpath = 'dgm_graph_' + str(n) + '.txt'
nx.write_edgelist(dgm_graph, outpath, data=False)
convert_edgelist_to_graphviz(outpath)
sys.exit(0)
print('Generating [Erdos-Renyi Graph]')
n = 100
p = 0.7
erdos_renyi_graph = nx.erdos_renyi_graph(n, p)
outpath = 'erdos_renyi_graph_' + str(n) + '.txt'
nx.write_edgelist(erdos_renyi_graph, outpath, data=False)
convert_edgelist_to_graphviz(outpath)
print('Generating [Preferential Attachment Model Graph]')
n = 100
m = 5
benchmark(output, graph, graphname, strategy, False)
benchmark(output, graph, graphname, strategy, True)
except nx.exception.NetworkXPointlessConcept:
print ""
if not os.path.exists(args.output):
os.makedirs(args.output)
with open(args.output + '/output.csv', 'w') as output:
helper(output, nx.balanced_tree(2, 5), "balanced_tree") # branching factor, height
helper(output, nx.barbell_graph(50, 50), "barbell_graph")
helper(output, nx.complete_graph(50), "complete_graph")
helper(output, nx.complete_bipartite_graph(50, 50), "complete_bipartite_graph")
helper(output, nx.circular_ladder_graph(50), "circular_ladder_graph")
helper(output, nx.cycle_graph(50), "cycle_graph")
helper(output, nx.dorogovtsev_goltsev_mendes_graph(5), "dorogovtsev_goltsev_mendes_graph")
helper(output, nx.empty_graph(50), "empty_graph")
helper(output, nx.grid_2d_graph(5, 20), "grid_2d_graph")
helper(output, nx.grid_graph([2, 3]), "grid_graph")
helper(output, nx.hypercube_graph(3), "hypercube_graph")
helper(output, nx.ladder_graph(50), "ladder_graph")
helper(output, nx.lollipop_graph(5, 20), "lollipop_graph")
helper(output, nx.path_graph(50), "path_graph")
helper(output, nx.star_graph(50), "star_graph")
helper(output, nx.trivial_graph(), "trivial_graph")
helper(output, nx.wheel_graph(50), "wheel_graph")
helper(output, nx.random_regular_graph(1, 50, 678995), "random_regular_graph_1")
helper(output, nx.random_regular_graph(3, 50, 683559), "random_regular_graph_3")
helper(output, nx.random_regular_graph(5, 50, 515871), "random_regular_graph_5")
helper(output, nx.random_regular_graph(8, 50, 243579), "random_regular_graph_8")
PhysicalNode(translate(x, y), rand_complex(),
config["node"]["intensity"]) for (x, y) in nx_graph.nodes
]
edges = [[translate(a, b), translate(c, d)]
for ((a, b), (c, d)) in nx_graph.edges]
return (nodes, edges)
# -------------------- bg ----------------------
# bg = nx.complete_graph(20)
# bg = nx.balanced_tree(2, 7)
# bg = nx.cycle_graph(125)
# bg = nx.sedgewick_maze_graph()
# bg = nx.tetrahedral_graph()
# bg = nx.petersen_graph()
bg = nx.dorogovtsev_goltsev_mendes_graph(4)
NODES, EDGES = build_from_nx(bg, fr_config)
print(" Simulating %s nodes and %s edges..." % (len(NODES), len(EDGES)))
graph = Graph(NODES, bg.edges, False)
def add_force_receivers_to(simulator):
for node in graph.nodes:
simulator.register_receiver(node)
def add_center_gravity(simulator):
center_gravity = Attractor(config["gravity"]["intensity"])
simulator.register_emitter(center_gravity)
# 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_result_dgm_200(self):
assert (calc_and_compare(NX.dorogovtsev_goltsev_mendes_graph(10)))
def test_dorogovtsev(self):
""" (reference) Pseudofractal Scale-free Web: planar """
expected = True
actual = is_planar(nx.dorogovtsev_goltsev_mendes_graph(7))
self.assertEqual(expected, actual)
