def random_powerlaw_tree(n, gamma=3, create_using=None, seed=None, tries=100):
"""Return a tree with a powerlaw degree distribution.
Parameters
----------
n : int,
The number of nodes
gamma : float
Exponent of the power-law
create_using : graph, optional (default Graph)
The graph instance used to build the graph.
seed : int, optional
Seed for random number generator (default=None).
tries : int
Number of attempts to adjust sequence to make a tree
Notes
-----
A trial powerlaw degree sequence is chosen and then elements are
swapped with new elements from a powerlaw distribution until
the sequence makes a tree (#edges=#nodes-1).
"""
from networkx.generators.degree_seq import degree_sequence_tree
try:
s=random_powerlaw_tree_sequence(n,
gamma=gamma,
seed=seed,
tries=tries)
except:
raise networkx.NetworkXError(\
"Exceeded max (%d) attempts for a valid tree sequence."%tries)
G=degree_sequence_tree(s,create_using)
G.name="random_powerlaw_tree(%s,%s)"%(n,gamma)
return G
def random_powerlaw_tree(n, gamma=3, seed=None, tries=100):
"""Return a tree with a powerlaw degree distribution.
Parameters
----------
n : int,
The number of nodes
gamma : float
Exponent of the power-law
seed : int, optional
Seed for random number generator (default=None).
tries : int
Number of attempts to adjust sequence to make a tree
Notes
-----
A trial powerlaw degree sequence is chosen and then elements are
swapped with new elements from a powerlaw distribution until
the sequence makes a tree (#edges=#nodes-1).
"""
from networkx.generators.degree_seq import degree_sequence_tree
try:
s=random_powerlaw_tree_sequence(n,
gamma=gamma,
seed=seed,
tries=tries)
except:
raise nx.NetworkXError(\
"Exceeded max (%d) attempts for a valid tree sequence."%tries)
G=degree_sequence_tree(s)
G.name="random_powerlaw_tree(%s,%s)"%(n,gamma)
return G
def random_powerlaw_tree(n, gamma=3, seed=None, tries=100):
"""Returns a tree with a power law degree 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 powerlaw distribution until the
sequence makes a tree (by checking, for example, that the number of
edges is one smaller than the number of nodes).
"""
# This call may raise a NetworkXError if the number of tries is succeeded.
seq = random_powerlaw_tree_sequence(n, gamma=gamma, seed=seed, tries=tries)
G = degree_sequence_tree(seq)
return G
def random_powerlaw_tree(n, gamma=3, seed=None, tries=100):
"""
Return a tree with a powerlaw degree distribution.
A trial powerlaw degree sequence is chosen and then elements are
swapped with new elements from a powerlaw distribution until
the sequence makes a tree (#edges=#nodes-1).
:Parameters:
- `n`: the number of nodes
- `gamma`: exponent of power law is gamma
- `tries`: number of attempts to adjust sequence to make a tree
- `seed`: seed for random number generator (default=None)
"""
from networkx.generators.degree_seq import degree_sequence_tree
try:
s=random_powerlaw_tree_sequence(n,
gamma=gamma,
seed=seed,
tries=tries)
except:
raise networkx.NetworkXError,\
"Exceeded max (%d) attempts for a valid tree sequence."%tries
G=degree_sequence_tree(s)
G.name="random_powerlaw_tree(%s,%s)"%(n,gamma)
return G
def random_powerlaw_tree(n, gamma=3, seed=None, tries=100):
"""Returns a tree with a power law degree distribution.
Parameters
----------
n : int
The number of nodes.
gamma : float
Exponent of the power law.
seed : int, optional
Seed for random number generator (default=None).
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 powerlaw distribution until the
sequence makes a tree (by checking, for example, that the number of
edges is one smaller than the number of nodes).
"""
from networkx.generators.degree_seq import degree_sequence_tree
try:
s = random_powerlaw_tree_sequence(n,
gamma=gamma,
seed=seed,
tries=tries)
except:
raise nx.NetworkXError(\
"Exceeded max (%d) attempts for a valid tree sequence."%tries)
G = degree_sequence_tree(s)
G.name = "random_powerlaw_tree(%s,%s)" % (n, gamma)
return G
def random_powerlaw_tree(n, gamma=3, seed=None, tries=100):
"""Returns a tree with a power law degree distribution.
Parameters
----------
n : int
The number of nodes.
gamma : float
Exponent of the power law.
seed : int, optional
Seed for random number generator (default=None).
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 powerlaw distribution until the
sequence makes a tree (by checking, for example, that the number of
edges is one smaller than the number of nodes).
"""
from networkx.generators.degree_seq import degree_sequence_tree
try:
s=random_powerlaw_tree_sequence(n,
gamma=gamma,
seed=seed,
tries=tries)
except:
raise nx.NetworkXError(\
"Exceeded max (%d) attempts for a valid tree sequence."%tries)
G=degree_sequence_tree(s)
G.name="random_powerlaw_tree(%s,%s)"%(n,gamma)
return G