def test_evolution_operator(n_qubits, n_levels): #generate random parameters params = 0.01*np.random.rand(2, n_levels) gammas = params[0] betas = params[1] #generate random graph edges = [] while len(edges) < 1: prob = 0.5 graph = erdos_renyi_graph(n_qubits, prob) edges = list(graph.edges) #generate random n-qubits state list_gen_state = qucs.n_rand_qubits(n_qubits) gen_state = qu.tensor(list_gen_state) #Test if it works as expected obs = qaoa.evolution_operator(n_qubits, edges, gammas, betas)*gen_state exp = gen_state for i in range(len(gammas)): u_mix_hamilt_i = (-complex(0,betas[i])*qaoa.mix_hamilt(n_qubits)).expm() u_prob_hamilt_i = (-complex(0,gammas[i])*qaoa.prob_hamilt(n_qubits, edges)).expm() exp = u_mix_hamilt_i*u_prob_hamilt_i*exp assert (np.round(np.array(exp.full()), 8) == (np.round(np.array(obs.full()), 8))).all() #test if it evolves a state for known parameters exp = qu.qload('final_state_simple_graph_p=1') obs = qaoa.evolution_operator(3, [(0,1),(1,2)], [1.0], [0.4])*qaoa.initial_state(3)
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 __init__(self, inp=sys.argv[1:]): self.nodes = int(inp[0]) self.probability = float(inp[1]) self.start = int(inp[2]) self.targ = int(inp[3]) self.verbose = inp[4].upper() self.initgraph = erdos_renyi_graph(self.nodes, self.probability) self.alledges = list(self.initgraph.edges) self.queue = [] self.stack = [] self.fingraph = {}
def _generate_graph_structure(self) -> dict: """ Generate random graph structure with given number of nodes and % of routes :return: Dictionary representing graph structure """ nodes_counter = random.choice(range(5, 10)) percent_of_routes = 0.4 graph = erdos_renyi_graph(nodes_counter, percent_of_routes) edges = [] for edge in graph.edges: edges.append(list(edge)) self.log_file.log_all(priority=3, string=f"Dungeon skeleton generated") return {"rooms": list(graph.nodes), "routes": edges, "mobs": {}}
def test_stresses(self): for i in range(10000): if i % 100 == 0: print("i: ", i) n = 7 max_w = 40 p = 0.5 g = erdos_renyi_graph(n, p).edges gg = [] for i, j in g: gg.append((i, j, randint(0, max_w))) ans = MatchingTests.matching(gg) exp = MatchingTests.slow_matching(gg) self.assertEqual(ans, exp)
def random_graph(n_nodes, prob=0.5): """ This method generate a random graph, with n_nodes and at least one edge Parameters ---------- n_nodes : int number of nodes of the graph. prob : float, optional probability, that two edges are linked during the creation, must be in [0, 1]. The default is 0.5. Returns ------- graph : networkx.classes.graph.Graph Returns a $G_{n,p}$ random graph, also known as an Erdős-Rényi graph or a binomial graph. The $G_{n,p}$ model chooses each of the possible edges with probability 0.5. """ graph = erdos_renyi_graph(n_nodes, prob) while len(list(graph.edges)) < 1: graph = erdos_renyi_graph(n_nodes, prob) return graph
def generate_connected_graph(nds, p): n = nds i = 0 while (1): G = erdos_renyi_graph(n, p) # print("Iterator: ",i) # print(G.nodes) # print(G.edges) # print(nx.is_connected(G)) #return true if all nodes in geaph connected # nx.draw_networkx(G) # plt.show() if (nx.is_connected(G)): break i = i + 1 # print('\n------------------------\n') return G
def test_prob_hamilt(n_qubits): #generate a generic n-qubits state list_gen_state = qucs.n_rand_qubits(n_qubits) gen_state = qu.tensor(list_gen_state) #generate a random graph of n-vertices edges = [] while len(edges) < 1: prob = 0.5 graph = erdos_renyi_graph(n_qubits, prob) edges = list(graph.edges) #test is ìf the result is the one expected obs = qaoa.prob_hamilt(n_qubits,edges)*gen_state list_exp = [] for j in range(0,len(edges)): list_exp.append(0.5*(qucs.n_qeye(n_qubits) -qucs.n_sigmaz(n_qubits,edges[j][0])*qucs.n_sigmaz(n_qubits,edges[j][1]))*gen_state) exp = sum(list_exp) assert_equal(obs,exp)
def initialize(): for i in range(USER_NUM):users[i]=round(random.uniform(-1,1),2) for i in range(POST_NUM):posts[i]=round(random.uniform(-1,1),2) users.sort() posts.sort() g = erdos_renyi_graph(USER_NUM,0.5) for x,y in g.edges: if x not in graph:graph[x] = [] if y not in graph:graph[y] = [] graph[x].append(y) graph[y].append(x) print(users) print(posts) for i in graph: print(i,graph[i]) viewership()
def generateRandGraph(n, p, path): g = erdos_renyi_graph(n, p) x = g.edges with open(path, 'w') as f: f.write('FROM TO:\n') for a_tuple in x: node1 = a_tuple[0] node2 = a_tuple[1] if random.random() > 0.5: f.write(str(node1)) f.write(' ') f.write(str(node2)) f.write('\n') if random.random() > 0.5: f.write(str(node2)) f.write(' ') f.write(str(node1)) f.write('\n') f.close return g
def run_wl_kernel(args, dataloader, model, edge_ratio): dataset = dataloader.dataset pos_graph_list = [] neg_graph_list = [] meta_test_edge_ratio = 1 - args.meta_val_edge_ratio - args.meta_train_edge_ratio i = 0 for graph in dataset: print("Graph : %d" % (i)) i += 1 try: x, train_pos_edge_index = graph.x.to(args.dev), \ graph.train_pos_edge_index.to(args.dev) data = graph except: data = model.split_edges(graph,val_ratio=args.meta_val_edge_ratio,\ test_ratio=meta_test_edge_ratio) nx_graph = create_masked_networkx_graph(data) neg_graph = erdos_renyi_graph(len(nx_graph), edge_ratio) pos_edge_list = list(nx_graph.edges()) neg_edge_list = list(neg_graph.edges()) pos_node_dict = {} neg_node_dict = {} ''' Pos Samples ''' for node_id in nx_graph.nodes: nx_graph.node[node_id]['label'] = nx_graph.degree[node_id] pos_node_dict[node_id] = nx_graph.degree[node_id] pos_grakel_graph = [pos_edge_list, pos_node_dict] pos_graph_list.append(pos_grakel_graph) '''Neg Samples ''' for node_id in nx_graph.nodes: nx_graph.node[node_id]['label'] = nx_graph.degree[node_id] neg_node_dict[node_id] = nx_graph.degree[node_id] neg_grakel_graph = [neg_edge_list, neg_node_dict] neg_graph_list.append(neg_grakel_graph) wl_kernel = GraphKernel(kernel = [{"name": "weisfeiler_lehman", "n_iter": 5},\ {"name": "subtree_wl"}], Nystroem=len(dataset)) kernel_mat = wl_kernel.fit_transform(pos_graph_list) neg_kernel_mat = wl_kernel.transform(neg_graph_list) return kernel_mat, neg_kernel_mat
def gen_erdos(n: int): p = 8.0 / n return erdos_renyi_graph(n, p)
def erdos_renyi_generator(args): return generators.erdos_renyi_graph(args.num_nodes, args.probability)
type=str, default="./data/packet-forward/test1.db") parser.add_argument("-s", type=str) parser.add_argument("-n", type=int, default=6) parser.add_argument("-p", type=float, default=0.5) parser.add_argument("-pr", type=int, default=0) args = parser.parse_args() if not os.path.exists(args.s): os.mkdir(args.s) si = args.s + "/test.png" sf = args.s + "/test.db" f = open(sf, 'w') g = erdos_renyi_graph(args.n, args.p) # print(g.nodes); # print(g.edges); drawGraph(g, si) routes = buildRouteTable(g) for node in routes: for dest in routes[node]: if args.pr == 0: f.write("route " + str(node + 1) + " " + str(dest + 1) + " " + str(routes[node][dest][0] + 1) + "\n") else: p = random.random if args.pr == 0: packets = generatePackets(g, 200)
def erdosRenyi(n,p=0.3): graphsToReturn = [] for i in range(100): print RandomGraphGenerator.erdos_renyi_graph, n, i graphsToReturn.append([i*TIME_UNIT_IN_SECONDS, my_nx.getDictForGraph(erdos_renyi_graph(n,p))]) return graphsToReturn
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)
from time import time min_n = int(input('Min N: ')) max_n = int(input('Max N: ')) test_cases = int(input('Test case amount: ')) test_case_prefix = input('Test case file prefix: ') for i in range(1, test_cases + 1): with open(f'{test_case_prefix}.{i}.in', 'w+') as input_file, \ open(f'{test_case_prefix}.{i}.out','w+') as output_file: n = randint(min_n, max_n) print(f'Generating test case {i} (n={n})...') start_time = time() graph = erdos_renyi_graph(n, random() / 2) nodes = [randint(-4, 5) for _ in range(n)] # guaranteed to create a winnable configuration 35% of the time if random() <= 0.35: genus = len(graph.edges) - n + 1 node_sum = sum(nodes) if node_sum < genus: nodes[randint(0, n - 1)] += genus - node_sum + randint(1, 10) node_sum = sum(nodes) if node_sum < 0: nodes[randint(0, n - 1)] += node_sum + randint(1, 10) print( f'-> Completed generating input data... ({round(time() - start_time, 3)} seconds elapsed)'
posts = POST_NUM*[0] graph = {} for i in range(USER_NUM):users[i]=round(random.uniform(-1,1),2) # for i in range(USER_NUM//2):users[i]=round(random.uniform(0,0.5),2) # for i in range(USER_NUM//2,USER_NUM):users[i]=round(random.uniform(-0.5,0),2) for i in range(POST_NUM):posts[i]=round(random.uniform(-1,1),2) # for i in range(POST_NUM//2):posts[i]=round(random.uniform(0.7,1),2) # for i in range(POST_NUM//2,POST_NUM):posts[i]=round(random.uniform(-1,-0.7),2) # users.sort() # posts.sort() g = erdos_renyi_graph(USER_NUM,0.5) for x,y in g.edges: if x not in graph:graph[x] = [] if y not in graph:graph[y] = [] graph[x].append(y) graph[y].append(x) datafile = "data_" + str(USER_NUM) + "_" + str(POST_NUM) + "_" + RANGE + ".csv" with open(datafile, 'w') as csvfile: csvwriter = csv.writer(csvfile) csvwriter.writerow(users) csvwriter.writerow(posts) for i in graph:
def _generate_graph(self, n): return erdos_renyi_graph(n, self._param[f'{n}'])
def generate_graph(n, p): g = random_graphs.erdos_renyi_graph(n, p, seed=None, directed=False) a = nx.adjacency_matrix(g) return g, a
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)
def create_erdos_renyi_graph(num_nodes, edge_prob): graph = erdos_renyi_graph(num_nodes, edge_prob) return graph
def erdos_renyi_network(n, p, seed=None): return nx2gt(erdos_renyi_graph(n, p, seed))
#!/usr/bin/python import networkx as nx import numpy as np from networkx.generators.random_graphs import erdos_renyi_graph import matplotlib.pyplot as plt n = 20000 p = 0.001290309 g = erdos_renyi_graph(n, p) ##nx.draw(g, with_labels=True) ##plt.show() file1 = open(str(n) + "_sp" + "_nodes.txt", "w+") for (i, j) in g.edges: file1.write(str(j) + " " + str(i) + "\n") file1.close()
def generationGrapheAleatoireEdgarGilbert(): n = int(sys.argv[1]) p = 0.5 g = erdos_renyi_graph(n, p) EnregistrerGrapheAlea(g)
from networkx.generators.random_graphs import erdos_renyi_graph from networkx.readwrite.edgelist import read_edgelist, write_edgelist import logging import numpy as np import os import pickle import random import sys if __name__ == "__main__": n = 100 p = 0.05 logging.basicConfig(level=logging.INFO) logging.info('Creating graph...') G = erdos_renyi_graph(n, p, directed=True) numOfNodes = G.number_of_nodes() numOfEdges = G.number_of_edges() logging.info( '\n...done. Created a directed Erdos-Renyi graph with %d nodes and %d edges' % (numOfNodes, numOfEdges)) degrees = dict(list(G.out_degree(G.nodes()))) descending_degrees = sorted(degrees.values(), reverse=True) evens = set(descending_degrees[::2]) odds = set(descending_degrees[1::2]) # evens = evens.intersection(set(G.nodes())) # odds = odds.intersection(set(G.nodes())) target_partitions = { 0: evens, 1: odds } # create partitions based on their position in the descending_degrees list
#%% using networkx from networkx.algorithms.bipartite.edgelist import read_edgelist from networkx.generators.random_graphs import erdos_renyi_graph from networkx.algorithms.community.modularity_max import greedy_modularity_communities from networkx.algorithms.community.quality import modularity netx = read_edgelist(file) partx = greedy_modularity_communities(netx) modx_real = modularity(G=netx, communities=partx) print(f'\nmod_real_nx = {modx_real}') p = (2. * m) / n**2 netx_er = erdos_renyi_graph(n=n, p=p) partx = greedy_modularity_communities(netx_er) modx_rand = modularity(G=netx_er, communities=partx) print(f'\nmod_random_nx = {modx_rand}') #%% data plotting import pandas as pd import seaborn as sns import pylab as plt data = { 'Networks': ['Real network', 'Random', 'Real Network ', 'Random '], 'Modularity': [mod_real, mod_rand, modx_real, modx_rand], 'Class': ['Our Algorithm', 'Our Algorithm', 'NetworkX', 'NetworkX']