def _gen_(self, n): for _ in range(n): #generate p value: if self.distribution == "Uniform": p = np.random.uniform(self.metaparams[0], self.metaparams[1]) num_v = np.random.randint(self.min_num_v, self.max_num_v) g = nx.binomial_graph(num_v, p) self.graphs.append(g) self.pvals.append(p) elif self.distribution == "Normal": p = min( abs( np.random.normal(self.metaparams[0], self.metaparams[1])), 1) num_v = np.random.randint(self.min_num_v, self.max_num_v) g = nx.binomial_graph(num_v, p) self.graphs.append(g) self.pvals.append(p) else: raise Exception( "Please enter a valid distribution from: Normal, Uniform")
def main(): G = nx.complete_graph(10) #完全グラフ G2 = nx.barbell_graph(10, 10) #ようわからん G3 = nx.watts_strogatz_graph(100, 15, 0.1) #small world graph #watts_strogatz_graph(n,k,p) n: number of node, k:nearest neoghbors, G4 = nx.complete_bipartite_graph(3, 3) #完全二部グラフ G5 = nx.scale_free_graph(50) G6 = nx.newman_watts_strogatz_graph(100, 10, 0.05) G7 = nx.binomial_graph(10, 0.2) # z=[int(random.gammavariate(alpha=9.0,beta=2.0)) for i in range(6)] # G8 = nx.configuration_model(z) # aseq = [1,2,1] # bseq = [2,1,1] # G8 = nx.configuration_model(aseq,bseq) G8 = bp.random_graph(5, 5, 0.5) pos = nx.spring_layout(G6) # pos = nx.circular_layout(G5) plt.axis('off') nx.draw(G6, pos, with_labels=False) plt.show()
def create(self, model, kwargs): if model == 1: degree = kwargs.get("degree", self.degree) nodes = kwargs.get("nodes", self.nodes) self.graph = nx.random_regular_graph(degree, nodes) elif model == 2: nodes = kwargs.get("nodes", self.nodes) edge_prob = kwargs.get("edge_prob", self.edge_prob) self.graph = nx.binomial_graph(nodes, edge_prob) # elif model == 3: # self.graph = nx.gaussian_random_partition_graph(self.nodes, self.nodes/self.neighbour_edges, # self.nodes / self.neighbour_edges, # self.edge_prob, self.edge_prob) elif model == 3: nodes = kwargs.get("nodes", self.nodes) neighbour_edges = kwargs.get("neighbour_edges", self.neighbour_edges) edge_prob = kwargs.get("edge_prob", self.edge_prob) self.graph = nx.powerlaw_cluster_graph(nodes, neighbour_edges, edge_prob) elif model == 4: # self.graph = nx.scale_free_graph(self.nodes) # else: nodes = kwargs.get("nodes", self.nodes) neighbour_edges = kwargs.get("neighbour_edges", self.neighbour_edges) self.graph = nx.barabasi_albert_graph(nodes, neighbour_edges) return self.graph
def createGraph(numNodes, nodeProb): """ Create a graph and compute and save """ print "Creating random graph with node connectivity probability = %f ...." % nodeProb G_fn = "bench_concomp"+str(numNodes) randGr = nx.binomial_graph(numNodes, nodeProb, directed=False) adjMat = [ [ 0 for i in range(numNodes) ] for j in range(numNodes) ] for row in range (len(randGr.adj.items())): for ind in ((randGr.adj.items()[row])[1]).keys(): adjMat[row][ind] = 1 # Make equivalent csc_matrix Gsparse = csc_matrix(adjMat, dtype=float64) gdir = os.path.join("bench",str(numNodes)) if not os.path.exists(gdir): os.makedirs(gdir) sio.savemat(os.path.join(gdir ,G_fn),{"fibergraph": Gsparse}, appendmat = True) print "Your graph is saved in %s ...\n" % os.path.abspath(gdir) inv = evaluate_graph(randGr, -1) printUTIL(inv) writeUTIL(inv)
def statsForGraphs(probaAccuracy=100, nbTestPerProba=100): proba = [] # Represents the largest clusters related to p maxiSizeCluster = [] degreePerProb = [] for i in range(1, 100): p = i / probaAccuracy maxiSizeClusterTemp = 0 degreeMoy = 0 for j in range(nbTestPerProba): degreeMoyPerG = 0 print(j) g = nx.binomial_graph(100, p) lstDegre = g.degree temp = len(max(nx.connected_component_subgraphs(g), key=len).nodes) maxiSizeClusterTemp += temp for tuple in lstDegre: degreeMoyPerG += tuple[1] degreeMoyPerG = degreeMoyPerG / len(lstDegre) degreeMoy += degreeMoyPerG g.clear() degreePerProb.append(degreeMoy / nbTestPerProba) maxiSizeCluster.append(maxiSizeClusterTemp / nbTestPerProba) proba.append(p) return [proba, maxiSizeCluster, degreePerProb]
def create_graph_2100_edge(): p_dict = {300: 0.0203, 400: 0.01085} for N in tqdm(p_dict.keys()): # for N in tqdm([75, 125, 150, 175]): p = p_dict[N] for up_w in [1, 5, 10, 100, 1000, 10000]: for up_d in [1, 5, 10, 100, 1000, 10000]: # generate a cyclic backbone backbone_graph = nx.DiGraph() for n in range(N): backbone_graph.add_edge(n, (n + 1) % N) random_graph = nx.binomial_graph(n=N, p=p, seed=42, directed=True) graph = nx.compose(backbone_graph, random_graph) for edge in graph.edges: graph.edges[edge]["weight"] = randint(1, up_w) for node in graph.nodes: graph.nodes[node]["delay"] = randint(1, up_d) wrapper = GraphWrapper(graph) r = random_retime(graph) # randomization of the graph wrapper.set_retimed_graph(r) nx.set_node_attributes(wrapper.g, wrapper.delay, 'delay') nx.nx_pydot.write_dot(wrapper.g, f"../graph_files/2100edges/N_{N}_p_{parse_float(p)}_upw_{up_w}_upd_{up_d}")
def gen(N): global filiais_list for out in range(0, N): i = rand.randint(2, 3000) print "Generating Graph Number: " + str(out+1) + "/" + str(N) + " Size(nodes): " + str(i) filiais = rand.randint(1, i) G=nx.binomial_graph(i, 0.5, True) for n in range(0, i): for e in G[n]: r = rand.randint(1, 10) G[n][e] = r gen_fil(i, filiais) f = open(dirname + str(out), "w") f.write(str(i) + " " + str(filiais) + " " + str(len(G.edges())) + "\n") counter = 0 for a in filiais_list: if counter < len(filiais_list): f.write(str(a) + " ") else: f.write(str(a)) counter = counter + 1 f.write("\n") for e in G.edges(): f.write(str(e[0]+1) + " " + str(e[1]+1) + " " + str(G[e[0]][e[1]]) + "\n") f.close() filiais_list = []
def generate_test(): """ Generate test graphs as dot files. It is composed in three phases: 1. It first generates a backbone_graph, i.e. a cycle (N nodes and N edges). Then, it creates a `binomial graph <https://networkx.github.io/documentation/stable/reference/generated/networkx.generators.random_graphs.binomial_graph.html#networkx.generators.random_graphs.binomial_graph>`_ with a probability p, and merges the two. It is important that the graph has the cyclic backbone because it is required that every node is reachable from any other (for W and D). 2. After the merge, given two upperbounds upW and upD, respectively for the edge weights and the node delays, it initialize every node with a random delay from 1 to upD, and every edge with a random weight from 1 to upW. It is **crucial** that the weights of the graph are always >=1, because in this way it is known that the optimal CP is the max{d(v)}. 3. Now, the graph is complete, but it is in its optimal form. To randomize the graph the random_retime function (see utils) is used. After that, the graph is saved as dot file. These steps are repeated for different ranges of N, p, up_w, up_d. In particular: N in [5, 10, 20, 50, 75, 100, 125, 150, 175, 200, 500] p in [.0, .05, .1, .2, .3, .5, .75, 1] up_w in [1, 5, 10, 100, 1000, 10000] up_d in [1, 5, 10, 100, 1000, 10000] :return: None """ for N in tqdm([5, 10, 20, 50, 100, 200, 500]): # for N in tqdm([75, 125, 150, 175]): for p in tqdm([.0, .05, .1, .2, .3, .5, .75, 1]): for up_w in [1, 5, 10, 100, 1000, 10000]: for up_d in [1, 5, 10, 100, 1000, 10000]: # generate a cyclic backbone backbone_graph = nx.DiGraph() for n in range(N): backbone_graph.add_edge(n, (n + 1) % N) random_graph = nx.binomial_graph(n=N, p=p, seed=42, directed=True) graph = nx.compose(backbone_graph, random_graph) for edge in graph.edges: graph.edges[edge]["weight"] = randint(1, up_w) for node in graph.nodes: graph.nodes[node]["delay"] = randint(1, up_d) wrapper = GraphWrapper(graph) r = random_retime(graph) # randomization of the graph wrapper.set_retimed_graph(r) nx.set_node_attributes(wrapper.g, wrapper.delay, 'delay') nx.nx_pydot.write_dot(wrapper.g, f"../graph_files/N_{N}_p_{parse_float(p)}_upw_{up_w}_upd_{up_d}")
def gen_graph(n, prob=0.5): while True: G = nx.binomial_graph(n, prob, None, True) if nx.number_strongly_connected_components(G) == 1: break return G
def createGraph(numNodes = 10): #numNodes = int(NumNodes) G_fn = "bench_concomp"+str(numNodes) nodeProb = 0.4 randGr = nx.binomial_graph(numNodes,nodeProb,directed=False) adjMat = [ [ 0 for i in range(numNodes) ] for j in range(numNodes) ] for row in range (len(randGr.adj.items())): for ind in ((randGr.adj.items()[row])[1]).keys(): adjMat[row][ind] = 1 # Make equivalent csc_matrix Gsparse = csc_matrix(adjMat, dtype=float64) if not os.path.exists(os.path.join("bench",str(numNodes))): os.makedirs(os.path.join("bench",str(numNodes))) sio.savemat(os.path.join("bench",str(numNodes) ,G_fn),{'fibergraph': Gsparse}, appendmat = True) inv = evaluate_graph(randGr, -1) printUTIL(inv) writeUTIL(inv)
def loadData(self): savename = self.name if self.name == "Power Grid of Western States of USA": self.num_of_nodes = 4941 self.add_nodes_from(range(self.num_of_nodes)) linkflag = 0 fromnode = -1 fobj = open(os.path.join('data', 'power.txt'),'r') for line in fobj: try: line = int(line) except ValueError: continue if linkflag == 0: fromnode = line linkflag = 1 else: linkflag = 0 self.add_edge(fromnode,line) fobj.close() elif self.name == "Barabasi Albert Scale-Free Network": nx.Graph.__init__(self, nx.barabasi_albert_graph(int(self.num_of_nodes),int(self.new_node_to_existing_nodes)) )# scale-free BA model elif self.name == "Binomial Graph": nx.Graph.__init__(self, nx.binomial_graph(int(self.num_of_nodes),int(self.average_degree)*1.0/int(self.num_of_nodes)) )# Random Graph elif self.name == "Watts-Strogatz Small-World Model": nx.Graph.__init__(self, nx.watts_strogatz_graph(int(self.num_of_nodes),int(self.average_degree),0.3) )# WS model self.name=savename
def make_random_binomial_graph(N_nodes, p_edge): """ random binomially connected graph with exponentially distributed potentials """ # initialize and add nodes graph_name = nx.binomial_graph(N_nodes, p_edge) node_state_sizes = np.random.randint( 10, high=20, size=graph_name.number_of_nodes()) # add indices of node state -- seems like there should be a slick way to # avoid this but can't figure it out for n in graph_name.nodes_iter(): graph_name.node[n]['node_state_indices'] = [ i for i in xrange(node_state_sizes[n])] # add potentials to graph for n in graph_name.nodes_iter(): node_potential = np.random.exponential(1, [node_state_sizes[n], 1]) graph_name.node[n]['node_potential'] = node_potential for i, edge in enumerate(graph_name.edges_iter()): n_a, n_b = edge len_n_a = len(graph_name.node[n_a]['node_potential']) len_n_b = len(graph_name.node[n_b]['node_potential']) edge_potential = np.random.exponential(1, [len_n_a, len_n_b]) graph_name.edge[n_a][n_b]['edge_potential'] = edge_potential return graph_name
def gen_new_random_graph(nodecount: int, prob: float) -> None: """ Generate a new random graph using binomial generation. Will save new network to file. """ newgraph = nx.binomial_graph(nodecount, prob) np.save('./test/testnetwork.npy', nx.adjacency_matrix(newgraph).todense())
def random_graphs(): print("Random graphs") print("fast GNP random graph") G = nx.fast_gnp_random_graph(n=9, p=0.4) draw_graph(G) print("GNP random graph") G = nx.gnp_random_graph(n=9, p=0.1) draw_graph(G) print("Dense GNM random graph") G = nx.dense_gnm_random_graph(n=19, m=28) draw_graph(G) print("GNM random graph") G = nx.gnm_random_graph(n=11, m=14) draw_graph(G) print("Erdős Rényi graph") G = nx.erdos_renyi_graph(n=11, p=0.4) draw_graph(G) print("Binomial graph") G = nx.binomial_graph(n=45, p=0.4) draw_graph(G) print("Newman Watts Strogatz") G = nx.newman_watts_strogatz_graph(n=9, k=5, p=0.4) draw_graph(G) print("Watts Strogatz") G = nx.watts_strogatz_graph(n=9, k=2, p=0.4) draw_graph(G) print("Watts Strogatz") G = nx.watts_strogatz_graph(n=9, k=2, p=0.4) draw_graph(G) print("Connected Watts Strogatz") G = nx.connected_watts_strogatz_graph(n=8, k=2, p=0.1) draw_graph(G) print("Random Regular Graph") G = nx.random_regular_graph(d=2, n=9) draw_graph(G) print("Barabasi Albert Graph") G = nx.barabasi_albert_graph(n=10, m=2) draw_graph(G) print("Powerlow Cluster Graph") G = nx.powerlaw_cluster_graph(n=10, m=2, p=0.2) draw_graph(G) print("Duplication Divergence Graph") G = nx.duplication_divergence_graph(n=10, p=0.2) draw_graph(G) print("Random lobster Graph") G = nx.random_lobster(n=10, p1=0.2, p2=0.8) draw_graph(G) print("Random shell Graph") constructor = [(10, 20, 0.8), (20, 40, 0.8)] G = nx.random_shell_graph(constructor) draw_graph(G) print("Random Powerlow Tree") G = nx.random_powerlaw_tree(n=24, gamma=3) draw_graph(G) print("Random Powerlow Tree Sequence") G = nx.random_powerlaw_tree(n=13, gamma=3) draw_graph(G)
def get_random_graph(filename, n, p, w): G = nx.binomial_graph(n, p) color = 'blue' # all nodes are one color nx.set_node_attributes(G, color, 'color') nx.set_edge_attributes(G, w, 'weight') # save_graph(filename, G) return G
def init_graph(): # Initialize graph # g = nx.binomial_graph(n, p, seed=None, directed=True) g = nx.binomial_graph(n, p, seed=None, directed=False) # Opinions # Initialize initial opinion values # Extreme values for i in range(0, 20): g.node[i]['x'] = 1 for i in range(180, n): g.node[i]['x'] = 0 # Moderate values for i in range(20, 180): g.node[i]['x'] = random.random()%0.5 # Empathy values for i in range(0, n): g.node[i]['h'] = random.gauss(0.5, 0.01) # Curmudegeons for i in range(0, n): g.node[i]['c'] = False for i in range(10, 50): g.node[i]['c'] = True # Edge weights - uniform as of now due to paucity of time e = g.edges() weights = {} for i in range(0, len(e)): # Set weight to 0 if node is a curmudegeon if g.node[e[i][0]] == True: weights[e[i]] = 0 else: weights[e[i]] = 1 w[e[i][0]][e[i][1]] = 1 w[e[i][1]][e[i][0]] = 1 nx.set_edge_attributes(g, 'w', weights) for i in g.nodes(): #g[g.node[i]][g.node[i]]['w'] = 1 g.add_edge(i,i) e = nx.all_neighbors(g, i) l = 0 for _ in e: l = l + 1 g[i][i]['w'] = l w[i][i] = l return g
def init_graph(): # Initialize graph # g = nx.binomial_graph(n, p, seed=None, directed=True) g = nx.binomial_graph(n, p, seed=None, directed=False) # Opinions # Initialize initial opinion values # Extreme values for i in range(0, 20): g.node[i]['x'] = 1 for i in range(180, n): g.node[i]['x'] = 0 # Moderate values for i in range(20, 180): g.node[i]['x'] = random.random() % 0.5 # Empathy values for i in range(0, n): g.node[i]['h'] = random.gauss(0.5, 0.01) # Curmudegeons for i in range(0, n): g.node[i]['c'] = False for i in range(10, 50): g.node[i]['c'] = True # Edge weights - uniform as of now due to paucity of time e = g.edges() weights = {} for i in range(0, len(e)): # Set weight to 0 if node is a curmudegeon if g.node[e[i][0]] == True: weights[e[i]] = 0 else: weights[e[i]] = 1 w[e[i][0]][e[i][1]] = 1 w[e[i][1]][e[i][0]] = 1 nx.set_edge_attributes(g, 'w', weights) for i in g.nodes(): #g[g.node[i]][g.node[i]]['w'] = 1 g.add_edge(i, i) e = nx.all_neighbors(g, i) l = 0 for _ in e: l = l + 1 g[i][i]['w'] = l w[i][i] = l return g
def er(n, p, directed=False): """ Generates an undirected (or directed) Erdös-Renyi network with link probability p. :param p: probability for link presence, :param n: number of nodes, :param directed: whether or not the network is directed, default False. :return: Adjacency matrix of the network. """ return np.array( nx.convert_matrix.to_numpy_array( nx.binomial_graph(n, p, directed=directed)))
def create(self, model): if model == 1: self.graph = nx.random_regular_graph(self.degree, self.nodes) elif model == 2: self.graph = nx.binomial_graph(self.nodes, self.edge_prob) elif model == 3: self.graph = nx.gnm_random_graph(self.nodes, self.neighbour_edges) elif model == 4: self.graph = nx.powerlaw_cluster_graph(self.nodes, self.neighbour_edges, self.edge_prob) elif model == 5: self.graph = nx.dense_gnm_random_graph(self.nodes, self.neighbour_edges) else: self.graph = nx.barabasi_albert_graph(self.nodes, self.neighbour_edges)
def __init__(self, agent_pool=[], numnodes=0, nettype="unspecified", density=1.0, maxdeg=6, is_directed=False, rand_seed=1, weight_type="comm_succ"): """[summary] Args: agent_pool (list, optional): [description]. Defaults to []. numnodes(int, optional): Defaults to 0. nettype (str, optional): [description]. Defaults to "unspecified". density (float, optional): [description]. Defaults to 1.0. maxdeg (int, optional): [description]. Defaults to 6. is_directed (bool, optional): [description]. Defaults to False. weight_type (str, optional): [description]. Defaults to "comm_succ". num_forests (int, optional): [description]. Defaults to 1. Raises: WrongGraphTypeException: If a NullGraphException: If a networkx graph is not fed for a merged method """ #object variables: #agent_pool #num_nodes #is_dir #maxdeg #weight_type (what kind) #num_forests self.agent_pool = agent_pool self.numnodes = len(agent_pool) self.nettype = nettype if nettype == 'complete' or nettype == 'com': self.nxgraph = nx.complete_graph(self.agent_pool) if nettype == 'scalefree' or nettype == 'sf': self.nxgraph = nx.scale_free_graph(self.agent_pool) if nettype == 'smallworld' or nettype == 'sw': self.nxgraph = nx.watts_strogatz_graph(self.agent_pool) if nettype == 'chain' or nettype == 'path' or nettype == 'ch': self.nxgraph = nx.path_graph(self.agent_pool) if nettype == 'merged' or nettype == 'm': if self.nxgraph is None: raise NullGraphException("Please feed an existing graph.") if nettype == 'unspecified' or nettype == 'u': self.nxgraph = nx.binomial_graph(self.agent_pool, seed=rand_seed, directed=self.is_directed) self.nxgraph.add_nodes_from(agent_pool) self.is_directed = is_directed self.weight_type = weight_type self.num_forests = num_forests
def get_generated_graph(self, parameters): """ Initializes graph according to the dictianary of parameters given by user. This graph is going to be initializes by a mathematical model such as Erdos - Renyi model, Albert Barabasi model, Watts Strogatz model, etc randomly. :param parameters dictionary of parameters which define the way graph is going to be initialized. """ model = parameters['model'] n = int(parameters['nodes']) directed = False if model != 'regular' and model != 'watts_strogatz' \ and parameters['graphtype'] == 'Directed': directed = True if model == 'erdos': self.graph = nx.erdos_renyi_graph(n, float(parameters['probability']), directed=directed) elif model == 'binomial': self.graph = nx.binomial_graph(n, float(parameters['probability']), directed=directed) elif model == 'watts_strogatz': if parameters['isConnected'] == 'Yes': self.graph = nx.connected_watts_strogatz_graph( n, int(parameters['edges']), float(parameters['probability'])) else: self.graph = nx.watts_strogatz_graph( n, int(parameters['edges']), float(parameters['probability'])) elif model == 'regular': self.graph = nx.random_regular_graph(int(parameters['degree']), n) elif model == 'random': self.graph = nx.gnm_random_graph(n, int(parameters['edges']), directed=directed) elif model == 'barabasi': self.growing = True self._initial_nodes = n self.graph = self.initialize_barabasi_graph(n, directed) if self.graph.is_directed(): self.graphtype = 'Directed' else: self.graphtype = 'Undirected'
def test_negative_weight_cycle_consistency(self): import random unif = random.uniform for random_seed in range(2): # range(20): random.seed(random_seed) for density in [.1, .9]: # .3, .7, .9]: for N in [1, 10, 20]: # range(1, 60 - int(30 * density)): for max_cost in [1, 90]: # [1, 10, 40, 90]: G = nx.binomial_graph(N, density, seed=4, directed=True) edges = ((u, v, unif(-1, max_cost)) for u, v in G.edges) G.add_weighted_edges_from(edges) no_heuristic = nx.negative_edge_cycle(G, heuristic=False) with_heuristic = nx.negative_edge_cycle(G, heuristic=True) assert no_heuristic == with_heuristic
def generate_weighted_binomial_graph(n=15, p=0.2, min_weight=3, max_weight=15): #generate graph nok = True while (nok): #prevents zero degree nodes g = nx.binomial_graph(n, p) d = dict(nx.degree(g)) if (0 not in d.values() and nx.is_connected(g)): nok = False #generate weights for (u, v, w) in g.edges(data=True): w['weight'] = randint(min_weight, max_weight) #initialize colormap global colormap colormap = [entity_color.get("default")] * n return g
def drawGraph(): #Create Graph G=nx.binomial_graph(200,.003) #Set the positions for the nodes pos=nx.spring_layout(G) #Draw UNDERGROUND nx.draw_networkx_nodes(G,pos, nodelist=ulist, node_size=30, node_color='#ff0000') nx.draw_networkx_edges(G,pos, edgelist=uconnections, edge_color="#ff0000",width=3) #DRAW BUSES nx.draw_networkx_nodes(G,pos, nodelist=blist, node_size=20, node_color='#0000ff') nx.draw_networkx_edges(G,pos, edgelist=bconnections, edge_color="#0000ff",width=2) #Draw TAXIS nx.draw_networkx_nodes(G,pos, nodelist=tlist, node_size=10, node_color='#ffff00') nx.draw_networkx_edges(G,pos, edgelist=tconnections, edge_color="#ffff00",width=1) nx.draw_networkx_labels(G,pos) #plt.savefig("edge_colormap.png") # save as png plt.show() # display
def __create__histdat__(self, no_g_per_val): """ Creates a set of graphs with p=0.1 -> 0.9 in steps of 0.1. Used to test weakness of GNN on p_vals Parameters --------- no_g_per_val : int Number of graphs per p value Returns ------- Dataset of graphs p = 0.1 -> 0.9, in form ([list],p) for each p """ test_uni = [] pvals = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] for p in pvals: p_list = [] for i in range(no_g_per_val): num_v = np.random.randint(self.min_num_v, self.max_num_v) g = nx.binomial_graph(num_v, p) p_list.append(g) test_uni.append((p_list, p)) return test_uni
layout=nx.spring_layout n=150 # 150 nodes # p value at which giant component (of size log(n) nodes) is expected p_giant=1.0/(n-1) # p value at which graph is expected to become completely connected p_conn=math.log(n)/float(n) # the following range of p values should be close to the threshold pvals=[0.003, 0.006, 0.008, 0.015] region=220 # for pylab 2x2 subplot layout plt.subplots_adjust(left=0,right=1,bottom=0,top=0.95,wspace=0.01,hspace=0.01) for p in pvals: G=nx.binomial_graph(n,p) pos=layout(G) region+=1 plt.subplot(region) plt.title("p = %6.3f"%(p)) nx.draw(G,pos, with_labels=False, node_size=10 ) # identify largest connected component Gcc=sorted(nx.connected_component_subgraphs(G), key = len, reverse=True) G0=Gcc[0] nx.draw_networkx_edges(G0,pos, with_labels=False, edge_color='r', width=6.0
def simuleer_uitbraak(n, initgeinf, netwerk, fractie_gevac, strategie): similatiestappen = 10 if netwerk == "willekeurig": p = 10.0 / n G = nx.binomial_graph(n=n, p=p) elif netwerk == "schaalvrij": G = nx.barabasi_albert_graph(n=n, m=2) else: raise ( AttributeError("Netwerk is ofwel 'willekeurig' of 'schaalvrij'")) A = geef_verbindingsmatrix(G) posities = nx.spring_layout(G) x = np.zeros((n, 1), dtype=int) x[:initgeinf] = 1 # eerste persoon is geinfecteerd resistent = [] if strategie == "willekeurig": resistent = random.sample(range(initgeinf, n), int(n * fractie_gevac)) elif strategie == "best connecteerd": if fractie_gevac > 0: D = -A.sum(0) resistent = D.argsort(1).tolist()[0][:int(n * fractie_gevac)] resistent = list(set(resistent) - set(range(initgeinf))) else: raise (AttributeError( "strategie is ofwel 'willeurig' of 'best connecteerd'")) geinfecteerd = [sum(x) / n] for t in range(similatiestappen): update_toestand(A, x, resistent) geinfecteerd.append(sum(x) / n) # plot resultaat fig, axes = plt.subplots(ncols=2, figsize=(15, 10)) # plot het netwerk knoopkleuren = [blauw] * initgeinf for i in range(initgeinf, n): if i in resistent: knoopkleuren.append(groen) elif x[i]: knoopkleuren.append(rood) else: knoopkleuren.append(geel) nx.draw_networkx_nodes(G, posities, node_size=10, alpha=0.8, node_color=knoopkleuren, ax=axes[0]) nx.draw_networkx_edges(G, posities, ax=axes[0], edge_color=blauw, width=0.5, alpha=0.8) deax(axes[0]) axes[0].set_title("Eindtoestand van de het netwerk na {} stappen".format( similatiestappen)) # plot nu de toestanden vatbaar = 1 - np.array(geinfecteerd) - fractie_gevac axes[1].plot(geinfecteerd, color=rood, ls="--", lw=2, label="geinfecteerd") axes[1].plot([0, similatiestappen], [fractie_gevac, fractie_gevac], color=groen, ls=":", lw=2, label="resistent") axes[1].plot(vatbaar, color=geel, lw=2, label="vatbaar") axes[1].legend(loc=1) axes[1].set_xlabel(r"$t$") axes[1].set_ylabel(r"Fractie van de knopen") axes[1].set_title("Evolutie van de toestanden.")
nx.draw_networkx_labels(netwerk_voorbeeld, posities, labels=labels, ax=ax, label_color=zwart) deax(ax) fig.savefig("figuren/socialnetwerk.png") # Figuur gradenverdeling standaard netwerken # ------------------------------------------ fig, ax = plt.subplots(figsize=(10, 8)) netwerk_random = nx.binomial_graph(n=1000, p=0.05) ax.plot(bereken_gradenverdeling(netwerk_random), color=groen, label="willekeurig netwerk") netwerk_schaalvrij = nx.barabasi_albert_graph(n=1000, m=10) ax.plot(bereken_gradenverdeling(netwerk_schaalvrij), color=rood, ls=':', label="schaalvrij netwerk") """ netwerk_grid = nx.grid_2d_graph(n=50, m=20) ax.plot(bereken_gradenverdeling(netwerk_grid), color=oranje, ls=":", label="grid netwerk") """ ax.set_xlabel(r"Graad $k$")
p_giant = 1.0 / (n - 1) # p value at which graph is expected to become completely connected p_conn = math.log(n) / float(n) # the following range of p values should be close to the threshold pvals = [0.003, 0.006, 0.008, 0.015] region = 220 # for pylab 2x2 subplot layout plt.subplots_adjust(left=0, right=1, bottom=0, top=0.95, wspace=0.01, hspace=0.01) for p in pvals: G = nx.binomial_graph(n, p) pos = layout(G) region += 1 plt.subplot(region) plt.title("p = %6.3f" % (p)) nx.draw(G, pos, with_labels=False, node_size=10) # identify largest connected component Gcc = sorted(nx.connected_component_subgraphs(G), key=len, reverse=True) G0 = Gcc[0] nx.draw_networkx_edges(G0, pos, with_labels=False, edge_color='r', width=6.0) # show other connected components for Gi in Gcc[1:]:
import matplotlib.pyplot as plt import networkx as nx n = 150 # 150 nodes # p value at which giant component (of size log(n) nodes) is expected p_giant = 1.0 / (n - 1) # p value at which graph is expected to become completely connected p_conn = math.log(n) / n # the following range of p values should be close to the threshold pvals = [0.003, 0.006, 0.008, 0.015] fig, axes = plt.subplots(2, 2) for p, ax, seed in zip(pvals, axes.ravel(), range(len(pvals))): #### generate graph #### G = nx.binomial_graph(n, p, seed=seed) # identify connected/disconnected nodes connected = [n for n, d in G.degree() if d > 0] disconnected = list(set(G.nodes()) - set(connected)) # identify largest connected component Gcc = sorted(nx.connected_components(G), key=len, reverse=True) G0 = G.subgraph(Gcc[0]) #### draw graph #### pos = nx.nx_agraph.graphviz_layout(G) ax.set_title(f"p = {p:.3f}") # draw largest connected component options = {"ax": ax, "edge_color": "tab:red"} nx.draw_networkx_edges(G0, pos, width=6.0, **options) # draw other connected components for Gi in Gcc[1:]: if len(Gi) > 1:
""" Using another style =================== In this example, we show how to use another default Matplotlib style. """ import networkx as nx import matplotlib.pyplot as plt from grave import plot_network network = nx.binomial_graph(50, .05) fig, ax_mat = plt.subplots(ncols=2) plot_network(network, ax=ax_mat[0]) ax_mat[0].set_axis_on() with plt.style.context(('ggplot')): plot_network(network, ax=ax_mat[1]) ax_mat[1].set_axis_on() for ax in ax_mat: ax.set_axis_on() ax.tick_params(which='both', bottom=False, top=False, left=False, right=False, labelbottom=False, labelleft=False) plt.show()
import os import networkx as nx import matplotlib.pyplot as plt os.chdir('/Users/xueyiheng/Desktop') filename = 'cit-HepTh_3.txt' G=nx.DiGraph() with open(filename) as file: for line in file: head, tail = [float(x) for x in line.split()] G.add_edge(head,tail) pr=nx.pagerank(G,alpha=0.85) x = 0; for node, value in pr.items(): x = x + value print(x) G=nx.binomial_graph(1000, 0.3, directed=True) layout = nx.spring_layout(G) plt.figure(1) nx.draw(G, pos=layout, node_color='y') pr=nx.pagerank(G,alpha=0.85) print(pr) for node, pageRankValue in pr.items(): print("%d,%.4f" %(node,pageRankValue)) plt.figure(2) nx.draw(G, pos=layout, node_size=[x * 6000 for x in pr.values()],node_color='m',with_labels=True) plt.show()
import random as rnd import networkx as nx import pandas as pd import matplotlib.pyplot as plt G = nx.binomial_graph(30, 0.30, seed=None) plt.figure(figsize=(4, 4)) position = nx.spring_layout(G, scale=5, iterations=200) nx.draw_networkx_nodes(G, position, node_size=50, node_color="#093ea8", node_shape="8") nx.draw_networkx_edges(G, position, width=0.5, edge_color='black') plt.axis("off") plt.savefig("binomial_graph.png", bbox_inches='tight') plt.savefig("binomial_graph.eps", bbox_inches='tight') plt.show(G)
# set seed axl.seed(tournament_size) for sample_players in range (num_sample_players) : # create players axl.seed(sample_players) players = random.sample(ordinary_players, tournament_size) for parameter in range(1, ub_parameter + 1) : p = parameter/(ub_parameter) for seed in range(ub_seed) : axl.seed(seed) # Define graph G = nx.binomial_graph(len(players), p) # check for connected nodes connections = [len(c) for c in sorted(nx.connected_components(G), key=len, reverse=True)] if connections and (1 not in connections): # if connections is empty, or equal to 1, it means # at least on node is disconnected. Thus, skip this # tournament and generate next edges = G.edges() tournament_id += 1 results = tournament_results(G, seed, p, players, turns, edges, repetitions,
def create_random_graph(n): g = networkx.binomial_graph(n, 0.5) while not networkx.is_connected(g): g = networkx.binomial_graph(n, 0.5) return g.nodes(), g.edges()
""" Created on Fri Dec 20 13:26:58 2019 @author: tangu """ import networkx as nx import matplotlib.pyplot as plt n = 100 pIteration = 100 probabilities = [] clusterSize = [] maxDegree = [] G = nx.binomial_graph(100,1) nx.draw(G,with_labels=True, font_weight='bold') for i in range(0,pIteration): probabilities.append([]) clusterSize.append([]) maxDegree.append([]) print(probabilities) for i in range(0,100) : print(i) for tempP in range(0,pIteration) : p = tempP/(pIteration*10) probabilities[tempP].append(p) G = nx.binomial_graph(n,p) Gc = max(nx.connected_component_subgraphs(G), key=len)
import networkx as nx import random import pickle numberOfNodes = 50 numberOfRouters = 15 edgeProbability = 0.1 budget=32 connected = False while (connected == False): randomGraph = nx.binomial_graph(numberOfNodes, edgeProbability) connected = nx.is_connected(randomGraph) V_P = range(0, numberOfNodes) V_L = random.sample(V_P, numberOfRouters) E_P = randomGraph.edges() C_P = dict() for (u,v) in E_P: C_P[(u,v)] = 4 print E_P, "\n\n", V_P myDictionary = dict() myDictionary['B'] = budget myDictionary['C_P'] = C_P myDictionary['E_P'] = E_P myDictionary['V_L'] = V_L myDictionary['V_P'] = V_P pickle.dump(myDictionary, open("save.p", "wb"))
import networkx as nx def first_return_times(G,k): return_times = dict() # length = shortest path lengths <= k # length[i][j] = length of shortest path i->j, if <= k # length[i] a dict keyed by neighbors of node i, with values # length of path to j length = nx.all_pairs_shortest_path_length(G,k) for i in G.nodes_iter(): # nodes = list of successors j which return to i nodes = filter(lambda j: length[j].has_key(i),G.successors(i)) # distances for each successor j distances = [length[j][i]+1 for j in nodes] if distances: return_times[i] = min(distances) return return_times, length if __name__ == "__main__": G = nx.binomial_graph(10,0.1,directed=True) d, ld = first_return_times(G,4) # return times <= 4 print "return times", d
import networkx as nx def print_g(G): for line in nx.generate_adjlist(G): print line print "" ngames = 1 for i in range(0,ngames): n = 10 #G = nx.fast_gnp_random_graph(n, 0.7, None, True) G = nx.binomial_graph(n, 0.3, None, True) print n # number of verts print_g(G) # left's game graph print n # number of verts print_g(G) # right's game graph print_g(G) # allowed moves for left print_g(G) # allowed moves for right print n # number of final states for i in range(0,n): # final states print i, print "", print i print "" print 0 # starting positions print 2 print ""