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) )
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)