def smoke_test_random_graph(self): seed = 42 G=gnp_random_graph(100,0.25,seed) G=binomial_graph(100,0.25,seed) G=erdos_renyi_graph(100,0.25,seed) G=fast_gnp_random_graph(100,0.25,seed) G=gnm_random_graph(100,20,seed) G=dense_gnm_random_graph(100,20,seed) G=watts_strogatz_graph(10,2,0.25,seed) assert_equal(len(G), 10) assert_equal(G.number_of_edges(), 10) G=connected_watts_strogatz_graph(10,2,0.1,seed) assert_equal(len(G), 10) assert_equal(G.number_of_edges(), 10) G=watts_strogatz_graph(10,4,0.25,seed) assert_equal(len(G), 10) assert_equal(G.number_of_edges(), 20) G=newman_watts_strogatz_graph(10,2,0.0,seed) assert_equal(len(G), 10) assert_equal(G.number_of_edges(), 10) G=newman_watts_strogatz_graph(10,4,0.25,seed) assert_equal(len(G), 10) assert_true(G.number_of_edges() >= 20) G=barabasi_albert_graph(100,1,seed) G=barabasi_albert_graph(100,3,seed) assert_equal(G.number_of_edges(),(97*3)) G = extended_barabasi_albert_graph(100, 1, 0, 0, seed) assert_equal(G.number_of_edges(), 99) G = extended_barabasi_albert_graph(100, 3, 0, 0, seed) assert_equal(G.number_of_edges(), 97 * 3) G = extended_barabasi_albert_graph(100, 1, 0, 0.5, seed) assert_equal(G.number_of_edges(), 99) G = extended_barabasi_albert_graph(100, 2, 0.5, 0, seed) assert_greater(G.number_of_edges(), 100 * 3) assert_less(G.number_of_edges(), 100 * 4) G=extended_barabasi_albert_graph(100, 2, 0.3, 0.3, seed) assert_greater(G.number_of_edges(), 100 * 2) assert_less(G.number_of_edges(), 100 * 4) G=powerlaw_cluster_graph(100,1,1.0,seed) G=powerlaw_cluster_graph(100,3,0.0,seed) assert_equal(G.number_of_edges(),(97*3)) G=random_regular_graph(10,20,seed) assert_raises(NetworkXError, random_regular_graph, 3, 21) constructor=[(10,20,0.8),(20,40,0.8)] G=random_shell_graph(constructor,seed) G=random_lobster(10,0.1,0.5,seed)
def test_random_zero_regular_graph(self): """Tests that a 0-regular graph has the correct number of nodes and edges. """ G = random_regular_graph(0, 10) assert_equal(len(G), 10) assert_equal(sum(1 for _ in G.edges()), 0)
def test_random_zero_regular_graph(self): """Tests that a 0-regular graph has the correct number of nodes and edges. """ seed = 42 G = random_regular_graph(0, 10, seed) assert len(G) == 10 assert sum(1 for _ in G.edges()) == 0
def run_analysis_n_nodes(n, d, cap, n_runs=3): print(f"Running analysis for {n} nodes and {d} regularity...") graphs = [lambda: random_regular_graph(d, n)] results_gr = {} results_dinitz = {} for graph, name in zip(graphs, names): # Initialize both graphs G_dinitz = graph() G_gr = G_dinitz.copy() total_time_gr = 0 total_time_dinitz = 0 for _ in range(n_runs): # Set random capacities of graph edges for u, v in G_dinitz.edges: G_dinitz.edges[u, v]["capacity"] = cap G_gr.edges[u, v]["capacity"] = cap # Pick random start and end node start_node = randint(0, len(G_dinitz.nodes) - 1) end_node = randint(0, len(G_dinitz.nodes) - 1) while start_node == end_node: end_node = randint(0, len(G_dinitz.nodes) - 1) # Run max-flow init_time = time.time() R_dinitz = dinitz(G_dinitz, start_node, end_node) total_time_dinitz += time.time() - init_time init_time = time.time() R_gr = goldberg_rao(G_gr, start_node, end_node) total_time_gr += time.time() - init_time # Check correctness d_mf = R_dinitz.graph["flow_value"] gr_mf = R_gr.graph["flow_value"] if d_mf != gr_mf: vprint( f"\t\t\tComputed max flow in {name} graph is {d_mf}, but goldberg_rao function computed {gr_mf}" .upper()) vprint( f"{d}-regular graph with {len(G_gr.nodes)} nodes, cap {cap} and {len(G_gr.edges)} edges took {total_time_gr / n_runs} seconds with goldberg_rao" ) vprint( f"{d}-regular graph with {len(G_dinitz.nodes)} nodes, cap {cap} and {len(G_dinitz.edges)} edges took {total_time_dinitz / n_runs} seconds with dinitz" ) results_gr[name] = total_time_gr / n_runs results_dinitz[name] = total_time_dinitz / n_runs return results_gr, results_dinitz
def run_analysis_n_nodes(n, unit_cap, n_runs=3): print(f"Running analysis for {n} nodes...") graphs = [ lambda: balanced_tree(2, int(round(np.log2(n) - 1))), lambda: binomial_tree(int(round(np.log2(n)))), lambda: cycle_graph(n), lambda: path_graph(n), lambda: star_graph(n - 1), lambda: random_regular_graph(3, n), lambda: random_regular_graph(5, n) ] results_dinitz = {} for graph, name in zip(graphs, names): # Initialize both graphs G_dinitz = graph() total_time_dinitz = 0 for _ in range(n_runs): # Set random capacities of graph edges for u, v in G_dinitz.edges: cap = randint(1, 100) if not unit_cap else 1 G_dinitz.edges[u, v]["capacity"] = cap # Pick random start and end node start_node = randint(0, len(G_dinitz.nodes) - 1) end_node = randint(0, len(G_dinitz.nodes) - 1) while start_node == end_node: end_node = randint(0, len(G_dinitz.nodes) - 1) # Run max-flow init_time = time.time() R_dinitz = dinitz(G_dinitz, start_node, end_node) total_time_dinitz += time.time() - init_time vprint( f"{name} with {len(G_dinitz.nodes)} nodes took {total_time_dinitz / n_runs} seconds with dinitz" ) results_dinitz[name] = total_time_dinitz / n_runs return results_dinitz
def run_analysis_n_nodes(n, unit_cap, n_runs=3): print(f"Running analysis for {n} nodes...") graphs = [lambda: balanced_tree(2, int(round(np.log2(n)-1))), lambda: binomial_tree(int(round(np.log2(n)))), lambda: cycle_graph(n), lambda: path_graph(n), lambda: star_graph(n-1), lambda: random_regular_graph(3, n), lambda: random_regular_graph(5, n)] results_gr = {} results_dinitz = {} for graph, name in zip(graphs, names): # Initialize both graphs G_dinitz = graph() G_gr = G_dinitz.copy() total_time_gr = 0 total_time_dinitz = 0 for _ in range(n_runs): # Set random capacities of graph edges for u, v in G_dinitz.edges: cap = randint(1, 100) if not unit_cap else 1 G_dinitz.edges[u, v]["capacity"] = cap G_gr.edges[u, v]["capacity"] = cap # Pick random start and end node start_node = randint(0, len(G_dinitz.nodes)-1) end_node = randint(0, len(G_dinitz.nodes)-1) while start_node == end_node: end_node = randint(0, len(G_dinitz.nodes)-1) # Run max-flow init_time = time.time() R_dinitz = dinitz(G_dinitz, start_node, end_node) total_time_dinitz += time.time() - init_time init_time = time.time() R_gr = goldberg_rao(G_gr, start_node, end_node) total_time_gr += time.time() - init_time # Check correctness d_mf = R_dinitz.graph["flow_value"] gr_mf = R_gr.graph["flow_value"] if d_mf != gr_mf: vprint(f"\t\t\tComputed max flow in {name} graph is {d_mf}, but goldberg_rao function computed {gr_mf}".upper()) vprint(f"{name} with {len(G_gr.nodes)} nodes took {total_time_gr / n_runs} seconds with goldberg_rao") vprint(f"{name} with {len(G_dinitz.nodes)} nodes took {total_time_dinitz / n_runs} seconds with dinitz") results_gr[name] = total_time_gr / n_runs results_dinitz[name] = total_time_dinitz / n_runs return results_gr, results_dinitz
def _createGraph(self): dlg = PropertyViewer(self.name, self.icon, Nodes=Integer(5, 1, 100, 1), Degree=Integer(2,1,100,1)) nodes = [] edges = [] if dlg.exec_(): values = dlg.values() n = values['Nodes'] m = values['Degree'] G = rnd.random_regular_graph(m, n) nodes = layout.circularNodes(n, 25) for i in G.edges_iter(): edges.append(i) return nodes, edges
def smoke_test_random_graph(self): seed = 42 G = gnp_random_graph(100, 0.25, seed) G = gnp_random_graph(100, 0.25, seed, directed=True) G = binomial_graph(100, 0.25, seed) G = erdos_renyi_graph(100, 0.25, seed) G = fast_gnp_random_graph(100, 0.25, seed) G = fast_gnp_random_graph(100, 0.25, seed, directed=True) G = gnm_random_graph(100, 20, seed) G = gnm_random_graph(100, 20, seed, directed=True) G = dense_gnm_random_graph(100, 20, seed) G = watts_strogatz_graph(10, 2, 0.25, seed) assert len(G) == 10 assert G.number_of_edges() == 10 G = connected_watts_strogatz_graph(10, 2, 0.1, tries=10, seed=seed) assert len(G) == 10 assert G.number_of_edges() == 10 pytest.raises(NetworkXError, connected_watts_strogatz_graph, \ 10, 2, 0.1, tries=0) G = watts_strogatz_graph(10, 4, 0.25, seed) assert len(G) == 10 assert G.number_of_edges() == 20 G = newman_watts_strogatz_graph(10, 2, 0.0, seed) assert len(G) == 10 assert G.number_of_edges() == 10 G = newman_watts_strogatz_graph(10, 4, 0.25, seed) assert len(G) == 10 assert G.number_of_edges() >= 20 G = barabasi_albert_graph(100, 1, seed) G = barabasi_albert_graph(100, 3, seed) assert G.number_of_edges() == (97 * 3) G = extended_barabasi_albert_graph(100, 1, 0, 0, seed) assert G.number_of_edges() == 99 G = extended_barabasi_albert_graph(100, 3, 0, 0, seed) assert G.number_of_edges() == 97 * 3 G = extended_barabasi_albert_graph(100, 1, 0, 0.5, seed) assert G.number_of_edges() == 99 G = extended_barabasi_albert_graph(100, 2, 0.5, 0, seed) assert G.number_of_edges() > 100 * 3 assert G.number_of_edges() < 100 * 4 G = extended_barabasi_albert_graph(100, 2, 0.3, 0.3, seed) assert G.number_of_edges() > 100 * 2 assert G.number_of_edges() < 100 * 4 G = powerlaw_cluster_graph(100, 1, 1.0, seed) G = powerlaw_cluster_graph(100, 3, 0.0, seed) assert G.number_of_edges() == (97 * 3) G = random_regular_graph(10, 20, seed) pytest.raises(NetworkXError, random_regular_graph, 3, 21) pytest.raises(NetworkXError, random_regular_graph, 33, 21) constructor = [(10, 20, 0.8), (20, 40, 0.8)] G = random_shell_graph(constructor, seed) G = random_lobster(10, 0.1, 0.5, seed) # difficult to find seed that requires few tries seq = random_powerlaw_tree_sequence(10, 3, seed=14, tries=1) G = random_powerlaw_tree(10, 3, seed=14, tries=1)
b_list = np.linspace(3, 5, 10) rho_list = [] with Pool(num_workers) as pool: for benefit in tqdm(b_list, leave=False, desc='benefits'): results = [] for i in tqdm(range(num_refreshes), leave=False, desc=f'benefit = {benefit}'): for j in tqdm(range(network_refresh_interval // num_workers), desc='Batch', leave=False): # Generate a fresh graph with a random cooperator invader = np.random.randint(graph_size) graphs = [ random_regular_graph(graph_degree, graph_size, seed=time.time()) for _ in range(num_workers) ] # Initializing graph nodes for G in graphs: for node in G: G.nodes[node][ 'name'] = 'C' if node == invader else 'D' set_result = pool.map(partial(evolve, b=benefit), graphs) results += set_result # print('{} --> {}'.format(i*network_refresh_interval+j*num_workers,set_result)) # print("\nFixation probability of C: {}".format(sum(results)/num_trials)) rho_list.append(sum(results) / num_trials) plt.plot(b_list, rho_list, 'o') neutral_fix_p = 0.01 * np.ones_like(b_list)
def test_random_graph(self): seed = 42 G = gnp_random_graph(100, 0.25, seed) G = gnp_random_graph(100, 0.25, seed, directed=True) G = binomial_graph(100, 0.25, seed) G = erdos_renyi_graph(100, 0.25, seed) G = fast_gnp_random_graph(100, 0.25, seed) G = fast_gnp_random_graph(100, 0.25, seed, directed=True) G = gnm_random_graph(100, 20, seed) G = gnm_random_graph(100, 20, seed, directed=True) G = dense_gnm_random_graph(100, 20, seed) G = watts_strogatz_graph(10, 2, 0.25, seed) assert len(G) == 10 assert G.number_of_edges() == 10 G = connected_watts_strogatz_graph(10, 2, 0.1, tries=10, seed=seed) assert len(G) == 10 assert G.number_of_edges() == 10 pytest.raises(NetworkXError, connected_watts_strogatz_graph, 10, 2, 0.1, tries=0) G = watts_strogatz_graph(10, 4, 0.25, seed) assert len(G) == 10 assert G.number_of_edges() == 20 G = newman_watts_strogatz_graph(10, 2, 0.0, seed) assert len(G) == 10 assert G.number_of_edges() == 10 G = newman_watts_strogatz_graph(10, 4, 0.25, seed) assert len(G) == 10 assert G.number_of_edges() >= 20 G = barabasi_albert_graph(100, 1, seed) G = barabasi_albert_graph(100, 3, seed) assert G.number_of_edges() == (97 * 3) G = extended_barabasi_albert_graph(100, 1, 0, 0, seed) assert G.number_of_edges() == 99 G = extended_barabasi_albert_graph(100, 3, 0, 0, seed) assert G.number_of_edges() == 97 * 3 G = extended_barabasi_albert_graph(100, 1, 0, 0.5, seed) assert G.number_of_edges() == 99 G = extended_barabasi_albert_graph(100, 2, 0.5, 0, seed) assert G.number_of_edges() > 100 * 3 assert G.number_of_edges() < 100 * 4 G = extended_barabasi_albert_graph(100, 2, 0.3, 0.3, seed) assert G.number_of_edges() > 100 * 2 assert G.number_of_edges() < 100 * 4 G = powerlaw_cluster_graph(100, 1, 1.0, seed) G = powerlaw_cluster_graph(100, 3, 0.0, seed) assert G.number_of_edges() == (97 * 3) G = random_regular_graph(10, 20, seed) pytest.raises(NetworkXError, random_regular_graph, 3, 21) pytest.raises(NetworkXError, random_regular_graph, 33, 21) constructor = [(10, 20, 0.8), (20, 40, 0.8)] G = random_shell_graph(constructor, seed) def is_caterpillar(g): """ A tree is a caterpillar iff all nodes of degree >=3 are surrounded by at most two nodes of degree two or greater. ref: http://mathworld.wolfram.com/CaterpillarGraph.html """ deg_over_3 = [n for n in g if g.degree(n) >= 3] for n in deg_over_3: nbh_deg_over_2 = [ nbh for nbh in g.neighbors(n) if g.degree(nbh) >= 2 ] if not len(nbh_deg_over_2) <= 2: return False return True def is_lobster(g): """ A tree is a lobster if it has the property that the removal of leaf nodes leaves a caterpillar graph (Gallian 2007) ref: http://mathworld.wolfram.com/LobsterGraph.html """ non_leafs = [n for n in g if g.degree(n) > 1] return is_caterpillar(g.subgraph(non_leafs)) G = random_lobster(10, 0.1, 0.5, seed) assert max([G.degree(n) for n in G.nodes()]) > 3 assert is_lobster(G) pytest.raises(NetworkXError, random_lobster, 10, 0.1, 1, seed) pytest.raises(NetworkXError, random_lobster, 10, 1, 1, seed) pytest.raises(NetworkXError, random_lobster, 10, 1, 0.5, seed) # docstring says this should be a caterpillar G = random_lobster(10, 0.1, 0.0, seed) assert is_caterpillar(G) # difficult to find seed that requires few tries seq = random_powerlaw_tree_sequence(10, 3, seed=14, tries=1) G = random_powerlaw_tree(10, 3, seed=14, tries=1)