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)
