def test_valid(self): node=[1,1,1,2,1,2,0,0] tri=[0,0,0,0,0,1,1,1] joint_degree_sequence=zip(node,tri) G = networkx.random_clustered_graph(joint_degree_sequence) assert_equal(G.number_of_nodes(),8) assert_equal(G.number_of_edges(),7)
def generate_configuration_model(degree_seq, original_no_edges, name): flag = 1 iteration = 0 criteria = 1 while (flag == 1): iteration = iteration + 1 #G=nx.configuration_model(degree_seq) G = nx.random_clustered_graph(degree_seq) G = nx.Graph(G) G.remove_edges_from(nx.selfloop_edges(G)) actual_degrees = [d for v, d in G.degree()] giant = nx.number_connected_components(G) #if (sorted(actual_degrees)==sorted(degree_seq)): #if (giant==1)&(len(G.edges())==original_no_edges): if iteration > 100: criteria = 2 if iteration > 200: criteria = 3 if iteration > 300: criteria = 4 if iteration > 400: criteria = 5 print(name, criteria, giant, original_no_edges, len(G.edges())) if (giant == criteria): flag = 0 edges = list(G.edges()) nodes = list(G.nodes()) return [nodes, edges]
def test_valid(self): node = [1, 1, 1, 2, 1, 2, 0, 0] tri = [0, 0, 0, 0, 0, 1, 1, 1] joint_degree_sequence = zip(node, tri) G = networkx.random_clustered_graph(joint_degree_sequence) assert G.number_of_nodes() == 8 assert G.number_of_edges() == 7
def random_clustered_graphs(): print("Random Clustered graphs") deg = [(1, 0), (1, 0), (1, 0), (2, 0), (1, 0), (2, 1), (0, 1), (0, 1)] G = nx.random_clustered_graph(deg) G = nx.Graph(G) # to remove parallel edges G.remove_edges_from(G.selfloop_edges()) # to remove self edges draw_graph(G)
def generate(): # Generates the joint degree sequence (Zero for i and delta for t) ki_seq = [0] * n kt_seq = [meank_t] * n make_sequence_3multiple(kt_seq) joint_deg_seq = [(ki, kt) for ki, kt in zip(ki_seq, kt_seq)] return nx.Graph(nx.random_clustered_graph(joint_deg_seq))
def triangle_rand_g(): #deg_tri=[[1,0],[1,0],[1,0],[2,0],[1,0],[2,1],[0,1],[0,1]] deg_tri=[[3,2],[1,2],[3,2],[2,1],[3,1],[2,1],[2,1],[2,2]] G = nx.random_clustered_graph(deg_tri) G=nx.Graph(G) G.remove_edges_from(G.selfloop_edges()) G.name = 'random.tri' return G
def generate(): # Generates the joint degree sequence (independent Poissons) ki_seq = my_poisson_sequence(n, meank_i, kmin_i) kt_seq = my_poisson_sequence(n, meank_t) make_sequence_even(ki_seq) make_sequence_3multiple(kt_seq) joint_deg_seq = [(ki, kt) for ki, kt in zip(ki_seq, kt_seq)] return nx.Graph(nx.random_clustered_graph(joint_deg_seq))
def __init__(self, deg_seq, triangle_proportion): self.deg_seq = deg_seq self.triangle_proportion = triangle_proportion number_of_nodes = len(self.deg_seq) triangular_degree_sequence = [] while self.deg_seq: triangular_degree = 0 single_edge_degree_of_selected_node = self.deg_seq.pop() if single_edge_degree_of_selected_node > 1: number_of_iteration = single_edge_degree_of_selected_node / 2 for iteration in range(number_of_iteration): if self.triangle_proportion > rd.random(): #~ print 'wow' triangular_degree += 1 single_edge_degree_of_selected_node -= 2 triangular_degree_sequence.append( [single_edge_degree_of_selected_node, triangular_degree]) #print [single_edge_degree_of_selected_node, triangular_degree] #### Add more edges if the sum of all single edges are not even, and add more triangles if the sum of all triangles are not divisible by 3. ### single_degree_list = [ triangular_degree_sequence[i][0] for i in range(number_of_nodes) ] while sum(single_degree_list) % 2 != 0: print 'not enough single edge' randomly_chosen_node = rd.randint(0, number_of_nodes - 1) triangular_degree_sequence[randomly_chosen_node][0] += 1 single_degree_list = [ triangular_degree_sequence[i][0] for i in range(number_of_nodes) ] triangular_degree_list = [ triangular_degree_sequence[i][1] for i in range(number_of_nodes) ] while sum(triangular_degree_list) % 3 != 0: print 'not enough single edge' randomly_chosen_node = rd.randint(0, number_of_nodes - 1) triangular_degree_sequence[randomly_chosen_node][1] += 1 triangular_degree_list = [ triangular_degree_sequence[i][1] for i in range(number_of_nodes) ] G = nx.random_clustered_graph(triangular_degree_sequence) #### Remove self edges and multi edges. #### G = nx.Graph(G) G.remove_edges_from(G.selfloop_edges()) self.triangular_degree_list = triangular_degree_list self.single_degree_list = single_degree_list
def testReduceClustering(self): '''Test that shuffling reduces clustrering.''' deg = [(1, 0), (1, 0), (1, 0), (2, 0), (1, 0), (2, 1), (0, 1), (0, 1)] g = networkx.random_clustered_graph(deg, create_using=networkx.Graph) kbefore = networkx.average_clustering(g) params = dict() params[ShuffleK.REWIRE_FRACTION] = 0.1 c = CaptureNetwork() e = StochasticDynamics(ProcessSequence([ShuffleK(), c]), g) rc = e.set(params).run() if not rc[epyc.Experiment.METADATA][epyc.Experiment.STATUS]: print(rc) kafter = networkx.average_clustering(c.finalNetwork()) self.assertTrue(kbefore >= kafter)
def test_incidence_matrix_simple(): deg = [3, 2, 2, 1, 0] G = havel_hakimi_graph(deg) deg = [(1, 0), (1, 0), (1, 0), (2, 0), (1, 0), (2, 1), (0, 1), (0, 1)] MG = nx.random_clustered_graph(deg, seed=42) I = nx.incidence_matrix(G).todense().astype(int) expected = np.array([[1, 1, 1, 0], [0, 1, 0, 1], [1, 0, 0, 1], [0, 0, 1, 0], [0, 0, 0, 0]]) npt.assert_equal(I, expected) I = nx.incidence_matrix(MG).todense().astype(int) expected = np.array([[1, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 0, 1]]) npt.assert_equal(I, expected) with pytest.raises(NetworkXError): nx.incidence_matrix(G, nodelist=[0, 1])
def test_valid2(self): G = networkx.random_clustered_graph(\ [(1,2),(2,1),(1,1),(1,1),(1,1),(2,0)]) assert_equal(G.number_of_nodes(),6) assert_equal(G.number_of_edges(),10)
def test_valid2(self): G = networkx.random_clustered_graph( [(1, 2), (2, 1), (1, 1), (1, 1), (1, 1), (2, 0)]) assert G.number_of_nodes() == 6 assert G.number_of_edges() == 10
def test_valid2(self): G = networkx.random_clustered_graph(\ [(1,2),(2,1),(1,1),(1,1),(1,1),(2,0)]) assert_equal(G.number_of_nodes(), 6) assert_equal(G.number_of_edges(), 10)
def configuration(c, N): """ Generator function for configuration model networks. Networks are generated with average degree = 4. The maximum attainable clustering c=0.2 is determined by the average degree. Model reference: adapted from the model described by M.E.J. Newman, Random graphs with clustering, Physical Review Letters, 103, 058701 (2009). Parameters ---------- c: the (global) clustering coefficient N : the network size """ # sample joint degree sequence (s,t) from doubly Poisson distribution, # where t = number of triangles and s = number of independent links k = 4 # the average degree used in all trials s_avg = k * (c * k + c - 1) / (c - 1) t_avg = -c * (k**2) / (2 * (c - 1)) s_max = 50 t_max = 50 # max should be ok because probabilities are very small by this stage d = {e: (0, 0) for e in range(s_max * t_max)} prob = [0] * ( s_max * t_max ) # the idea is to assign a probability to each (s,t) pair, then sample with these probabilities e = 0 for s in range(s_max): for t in range(t_max): d[e] = (s, t) prob[e] = (math.exp(-s_avg) * ( (s_avg**s) / math.factorial(s))) * (math.exp(-t_avg) * ( (t_avg**t) / math.factorial(t))) e += 1 # sample degree distribution from probabilities computed above options = list(range(len(prob))) indices = np.random.choice(options, N, p=prob) s = [d[i][0] for i in indices] t = [d[i][1] for i in indices] # ensure conditions for multiples of 2 and 3 are met while sum(s) % 2 != 0: random_node = rand.sample(list(range(N)), 1)[0] if s[random_node] > 0: s[random_node] = s[random_node] - 1 while sum(t) % 3 != 0: random_node = rand.sample(list(range(N)), 1)[0] if t[random_node] > 0: t[random_node] = t[random_node] - 1 # create network joint_degrees = zip(s, t) G = nx.random_clustered_graph(joint_degrees) G = nx.Graph(G) # remove parallel edges G.remove_edges_from(G.selfloop_edges()) # remove self loops #G = max(nx.connected_component_subgraphs(G), key=len) # if using largest connected component G = fix_graph(G) return (G)