def random_powerlaw_tree_sequence(n, gamma=3, seed=None, tries=100):
# get trial sequence
z = powerlaw_sequence(n, exponent=gamma, seed=seed)
# round to integer values in the range [0,n]
zseq = [min(n, max(int(round(s)), 0)) for s in z]
# another sequence to swap values from
z = powerlaw_sequence(tries, exponent=gamma, seed=seed)
# round to integer values in the range [0,n]
swap = [min(n, max(int(round(s)), 0)) for s in z]
for deg in swap:
# If this degree sequence can be the degree sequence of a tree, return
# it. It can be a tree if the number of edges is one fewer than the
# number of nodes, or in other words, `n - sum(zseq) / 2 == 1`. We
# use an equivalent condition below that avoids floating point
# operations.
if 2 * n - sum(zseq) == 2:
return zseq
index = seed.randint(0, n - 1)
zseq[index] = swap.pop()
raise nx.NetworkXError(
"Exceeded max (%d) attempts for a valid tree" " sequence." % tries
)
def random_powerlaw_tree_sequence(n, gamma=3, seed=None, tries=100):
"""Returns a degree sequence for a tree with a power law distribution.
Parameters
----------
n : int,
The number of nodes.
gamma : float
Exponent of the power law.
seed : integer, random_state, or None (default)
Indicator of random number generation state.
See :ref:`Randomness<randomness>`.
tries : int
Number of attempts to adjust the sequence to make it a tree.
Raises
------
NetworkXError
If no valid sequence is found within the maximum number of
attempts.
Notes
-----
A trial power law degree sequence is chosen and then elements are
swapped with new elements from a power law distribution until
the sequence makes a tree (by checking, for example, that the number of
edges is one smaller than the number of nodes).
"""
# get trial sequence
z = powerlaw_sequence(n, exponent=gamma, seed=seed)
# round to integer values in the range [0,n]
zseq = [min(n, max(int(round(s)), 0)) for s in z]
# another sequence to swap values from
z = powerlaw_sequence(tries, exponent=gamma, seed=seed)
# round to integer values in the range [0,n]
swap = [min(n, max(int(round(s)), 0)) for s in z]
for deg in swap:
# If this degree sequence can be the degree sequence of a tree, return
# it. It can be a tree if the number of edges is one fewer than the
# number of nodes, or in other words, `n - sum(zseq) / 2 == 1`. We
# use an equivalent condition below that avoids floating point
# operations.
if 2 * n - sum(zseq) == 2:
return zseq
index = seed.randint(0, n - 1)
zseq[index] = swap.pop()
raise nx.NetworkXError("Exceeded max (%d) attempts for a valid tree"
" sequence." % tries)
def generate_DAG(p, m=4, prob=0., type_='config_model'):
if type_ == 'config_model':
z = [int(e) for e in powerlaw_sequence(p)]
if np.sum(z) % 2 != 0:
z[0] += 1
G = nx.configuration_model(z)
elif type_ == 'barabasi':
G = nx.barabasi_albert_graph(p, m)
elif type_ == 'small_world':
G = nx.watts_strogatz_graph(p, m, prob)
elif type_ == 'chain':
source_node = int(np.ceil(p / 2)) - 1
arcs = {(i + 1, i)
for i in range(source_node)
} | {(i, i + 1)
for i in range(source_node, p - 1)}
print(source_node, arcs)
return cd.DAG(nodes=set(range(p)), arcs=arcs)
elif type_ == 'chain_one_direction':
return cd.DAG(nodes=set(range(p)),
arcs={(i, i + 1)
for i in range(p - 1)})
else:
raise Exception('Not a graph type')
G = nx.Graph(G)
dag = cd.DAG(nodes=set(range(p)))
for i, j in G.edges:
if i != j:
dag.add_arc(*sorted((i, j)))
return dag
def powerLawArray(n, beta, mean_degree):
powerLawSequence = nu.powerlaw_sequence(n, beta)
powerLawArr = np.array(powerLawSequence)
initialSum = np.sum(powerLawArr)
expectedSum = mean_degree * n
for i in xrange(n):
powerLawArr[i] = powerLawArr[i] * 1.0 * expectedSum / initialSum
return powerLawArr
def test_random_number_distribution():
# smoke test only
z = powerlaw_sequence(20, exponent=2.5)
z = discrete_sequence(20, distribution=[0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3])
# random number generator
from datetime import datetime
random.seed(datetime.now())
# %% [markdown]
# ## Create Scale-free graph
# %%
num_nodes = 1000 # number of nodes
exp = 2.2 # exponent of power law distribution
# random power law degree sequence
sequence = []
while len(sequence) < num_nodes:
nextval = int(powerlaw_sequence(1, exp)[0])
# we throw away nodes with degree more than num_nodes/2
# also we set min degree to 2. because this methods creates too many parallel edges
# that we need to remove
if 2 <= nextval <= (num_nodes // 2):
sequence.append(nextval)
# sum of degrees must even
if sum(sequence) % 2 == 1:
sequence[0] += 1
# create multigraph
graph = nx.configuration_model(sequence)
# remove parallel edges
graph = nx.Graph(graph)
# remove self loops
def pesudo_power_sequence_alt(n, gamma):
unround_sequence = powerlaw_sequence(n, exponent=gamma)
current_degree_sequence=[min(n, max( int(round(unround_sequence)),0)) for s in unround_sequence]
return sorted(current_degree_sequence)
def test_degree_sequences():
seq = powerlaw_sequence(10, seed=1)
seq = powerlaw_sequence(10)
assert len(seq) == 10
def test_degree_sequences():
seq = powerlaw_sequence(10)
assert_equal(len(seq), 10)
from networkx.utils import powerlaw_sequence import sys, math nNodos = int(sys.argv[1]) nComunidades = int(nNodos * 0.01) exp = float(sys.argv[2]) sequence = powerlaw_sequence(nComunidades, exponent = exp) sequence = map(lambda x : int(math.fmod(4 + int(x), nNodos)), sequence) for i in sequence: print i
