|*^c@sdZdjdddgZddlZddlZddlZddlZddlm Z m Z m Z ddl m Z d d d d d ddddddddddddgZdedZdedZeZeZddZdedZddZddZd dd!Zdd"Zd#Zdd$Zdd%Zdd&Zdd'Zdd(Z d)dd d*Z!d)dd d+Z"dS(,s Generators for random graphs. s sAric Hagberg (hagberg@lanl.gov)sPieter Swart (swart@lanl.gov)s Dan Schult (dschult@colgate.edu)iN(t empty_grapht path_graphtcomplete_graph(t defaultdicttfast_gnp_random_graphtgnp_random_graphtdense_gnm_random_graphtgnm_random_graphterdos_renyi_graphtbinomial_graphtnewman_watts_strogatz_graphtwatts_strogatz_graphtconnected_watts_strogatz_graphtrandom_regular_graphtbarabasi_albert_graphtpowerlaw_cluster_graphtduplication_divergence_graphtrandom_lobstertrandom_shell_graphtrandom_powerlaw_treetrandom_powerlaw_tree_sequencec Cst|}d||f|_|dk r;tj|n|dksS|dkritj||d|Sd}tjd|}|rhtj |}d}xd||krdtjdtj}|dt ||}||kr|d}nxI||krA||krA||}|d}||kr|d}qqW||kr|j ||qqWnd}x||krtjdtj}|dt ||}x0||kr||kr||}|d}qW||krq|j ||qqqqW|S(s=Returns a `G_{n,p}` random graph, also known as an Erdős-Rényi graph or a binomial graph. Parameters ---------- n : int The number of nodes. p : float Probability for edge creation. seed : int, optional Seed for random number generator (default=None). directed : bool, optional (default=False) If ``True``, this function returns a directed graph. Notes ----- The `G_{n,p}` graph algorithm chooses each of the `[n (n - 1)] / 2` (undirected) or `n (n - 1)` (directed) possible edges with probability `p`. This algorithm runs in `O(n + m)` time, where `m` is the expected number of edges, which equals `p n (n - 1) / 2`. This should be faster than :func:`gnp_random_graph` when `p` is small and the expected number of edges is small (that is, the graph is sparse). See Also -------- gnp_random_graph References ---------- .. [1] Vladimir Batagelj and Ulrik Brandes, "Efficient generation of large random networks", Phys. Rev. E, 71, 036113, 2005. sfast_gnp_random_graph(%s,%s)iitdirectedig?N( RtnametNonetrandomtseedtnxRtmathtlogtDiGraphtinttadd_edge( tntpRRtGtwtlptvtlr((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyR/sB#          cCs|rtj}n tj}|jt|d||f|_|dkrW|S|dkrst|d|S|dk rtj |n|j rt j t|d}nt j t|d}x0|D](}tj|kr|j|qqW|S(sReturns a `G_{n,p}` random graph, also known as an Erdős-Rényi graph or a binomial graph. The `G_{n,p}` model chooses each of the possible edges with probability ``p``. The functions :func:`binomial_graph` and :func:`erdos_renyi_graph` are aliases of this function. Parameters ---------- n : int The number of nodes. p : float Probability for edge creation. seed : int, optional Seed for random number generator (default=None). directed : bool, optional (default=False) If ``True``, this function returns a directed graph. See Also -------- fast_gnp_random_graph Notes ----- This algorithm runs in `O(n^2)` time. For sparse graphs (that is, for small values of `p`), :func:`fast_gnp_random_graph` is a faster algorithm. References ---------- .. [1] P. Erdős and A. Rényi, On Random Graphs, Publ. Math. 6, 290 (1959). .. [2] E. N. Gilbert, Random Graphs, Ann. Math. Stat., 30, 1141 (1959). sgnp_random_graph(%s,%s)iit create_usingiN(RRtGraphtadd_nodes_fromtrangeRRRRRt is_directedt itertoolst permutationst combinationsR(R R!RRR"tedgeste((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyR|s$#      c Cs.||dd}||kr-t|}n t|}d||f|_|dksd||krh|S|dk rtj|nd}d}d}d}xtr)tj||||kr|j|||d7}||kr|Sn|d7}|d7}||kr|d7}|d}qqWdS(sFReturns a `G_{n,m}` random graph. In the `G_{n,m}` model, a graph is chosen uniformly at random from the set of all graphs with `n` nodes and `m` edges. This algorithm should be faster than :func:`gnm_random_graph` for dense graphs. Parameters ---------- n : int The number of nodes. m : int The number of edges. seed : int, optional Seed for random number generator (default=None). See Also -------- gnm_random_graph() Notes ----- Algorithm by Keith M. Briggs Mar 31, 2006. Inspired by Knuth's Algorithm S (Selection sampling technique), in section 3.4.2 of [1]_. References ---------- .. [1] Donald E. Knuth, The Art of Computer Programming, Volume 2/Seminumerical algorithms, Third Edition, Addison-Wesley, 1997. iisdense_gnm_random_graph(%s,%s)iN( RRRRRRtTruet randrangeR( R tmRtmmaxR"tuR%tttk((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyRs0!          c Cs5|rtj}n tj}|jt|d||f|_|dk rctj|n|dkrs|S||d}|s|d:}n||krt |d|S|j }d}xl||kr0tj |}tj |} || ks|j || rqq|j || |d}qW|S(sVReturns a `G_{n,m}` random graph. In the `G_{n,m}` model, a graph is chosen uniformly at random from the set of all graphs with `n` nodes and `m` edges. This algorithm should be faster than :func:`dense_gnm_random_graph` for sparse graphs. Parameters ---------- n : int The number of nodes. m : int The number of edges. seed : int, optional Seed for random number generator (default=None). directed : bool, optional (default=False) If True return a directed graph See also -------- dense_gnm_random_graph sgnm_random_graph(%s,%s)ig@R'iN(RRR(R)R*RRRRRtnodestchoicethas_edgeR( R R3RRR"t max_edgestnlistt edge_countR5R%((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyRs0      cCs|dk rtj|n||kr:tjdnt|}d|||f|_|j}|}xitd|ddD]P}|||d|!}x2tt |D]} |j || || qWqW|j } x| D]\} } tj|krtj |} xa| | ks;|j | | rjtj |} |j| |dkrPqqW|j | | qqW|S(sReturn a Newman–Watts–Strogatz small-world graph. Parameters ---------- n : int The number of nodes. k : int Each node is joined with its ``k`` nearest neighbors in a ring topology. p : float The probability of adding a new edge for each edge. seed : int, optional The seed for the random number generator (the default is ``None``). Notes ----- First create a ring over ``n`` nodes. Then each node in the ring is connected with its ``k`` nearest neighbors (or ``k - 1`` neighbors if ``k`` is odd). Then shortcuts are created by adding new edges as follows: for each edge ``(u, v)`` in the underlying "``n``-ring with ``k`` nearest neighbors" with probability ``p`` add a new edge ``(u, w)`` with randomly-chosen existing node ``w``. In contrast with :func:`watts_strogatz_graph`, no edges are removed. See Also -------- watts_strogatz_graph() References ---------- .. [1] M. E. J. Newman and D. J. Watts, Renormalization group analysis of the small-world network model, Physics Letters A, 263, 341, 1999. http://dx.doi.org/10.1016/S0375-9601(99)00757-4 s"k>=n, choose smaller k or larger ns%newman_watts_strogatz_graph(%s,%s,%s)iiiN(RRRRt NetworkXErrorRRR8R*tlenRR/R9R:tdegree(R R7R!RR"R<tfromvtjttovtiR0R5R%R#((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyR 2s,$      !c Cs||krtjdn|dk r:tj|ntj}d|||f|_tt|}xJtd|ddD]1}|||d|!}|j t ||qWxtd|ddD]}|||d|!}xt ||D]\}} tj|krtj |} xq| |ksL|j || r{tj |} |j ||dkr.Pq.q.W|j|| |j|| qqWqW|S(s"Return a Watts–Strogatz small-world graph. Parameters ---------- n : int The number of nodes k : int Each node is joined with its ``k`` nearest neighbors in a ring topology. p : float The probability of rewiring each edge seed : int, optional Seed for random number generator (default=None) See Also -------- newman_watts_strogatz_graph() connected_watts_strogatz_graph() Notes ----- First create a ring over ``n`` nodes. Then each node in the ring is joined to its ``k`` nearest neighbors (or ``k - 1`` neighbors if ``k`` is odd). Then shortcuts are created by replacing some edges as follows: for each edge ``(u, v)`` in the underlying "``n``-ring with ``k`` nearest neighbors" with probability ``p`` replace it with a new edge ``(u, w)`` with uniformly random choice of existing node ``w``. In contrast with :func:`newman_watts_strogatz_graph`, the random rewiring does not increase the number of edges. The rewired graph is not guaranteed to be connected as in :func:`connected_watts_strogatz_graph`. References ---------- .. [1] Duncan J. Watts and Steven H. Strogatz, Collective dynamics of small-world networks, Nature, 393, pp. 440--442, 1998. s"k>=n, choose smaller k or larger nswatts_strogatz_graph(%s,%s,%s)iiiN(RR>RRRR(RtlistR*tadd_edges_fromtzipR9R:R@t remove_edgeR( R R7R!RR"R8RBttargetsR5R%R#((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyR ts,'   !idcCsrt||||}d}xPtj|smt||||}|d}||krtjdqqW|S(sReturns a connected Watts–Strogatz small-world graph. Attempts to generate a connected graph by repeated generation of Watts–Strogatz small-world graphs. An exception is raised if the maximum number of tries is exceeded. Parameters ---------- n : int The number of nodes k : int Each node is joined with its ``k`` nearest neighbors in a ring topology. p : float The probability of rewiring each edge tries : int Number of attempts to generate a connected graph. seed : int, optional The seed for random number generator. See Also -------- newman_watts_strogatz_graph() watts_strogatz_graph() is Maximum number of tries exceeded(R Rt is_connectedR>(R R7R!ttriesRR"R6((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyR s  csddkr&tjdndko=knsTtjdndkrjtS|dk rtj|ndfd}|}x|dkr|}qWtj}df|_|j||S( sReturns a random ``d``-regular graph on ``n`` nodes. The resulting graph has no self-loops or parallel edges. Parameters ---------- d : int The degree of each node. n : integer The number of nodes. The value of ``n * d`` must be even. seed : hashable object The seed for random number generator. Notes ----- The nodes are numbered from ``0`` to ``n - 1``. Kim and Vu's paper [2]_ shows that this algorithm samples in an asymptotically uniform way from the space of random graphs when `d = O(n^{1 / 3 - \epsilon})`. Raises ------ NetworkXError If ``n * d`` is odd or ``d`` is greater than or equal to ``n``. References ---------- .. [1] A. Steger and N. Wormald, Generating random regular graphs quickly, Probability and Computing 8 (1999), 377-396, 1999. http://citeseer.ist.psu.edu/steger99generating.html .. [2] Jeong Han Kim and Van H. Vu, Generating random regular graphs, Proceedings of the thirty-fifth ACM symposium on Theory of computing, San Diego, CA, USA, pp 213--222, 2003. http://portal.acm.org/citation.cfm?id=780542.780576 iisn * d must be evens+the 0 <= d < n inequality must be satisfiedcSsr|s tSxa|D]Y}xP|D]H}||kr4Pn||krP||}}n||f|krtSqWqWtS(N(R1tFalse(R/tpotential_edgests1ts2((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyt _suitables     c s3t}tt}x |r.td}tj|t|}xt||D]|\}}||kr||}}n||kr||f|kr|j||fq`||cd7<||cd7.si( tsetRER*RRtshuffletiterRGtaddRtitems( R/tstubsRMtstubiterRNROtnodet potentialt_(RPtdR (su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyt _try_creation's$     #srandom_regular_graph(%s, %s)N( RR>RRRRR(RRF(R\R RR]R/R"((RPR\R su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyR s")        cCsBt}x2t||kr=tj|}|j|q W|S(s Return m unique elements from seq. This differs from random.sample which can return repeated elements if seq holds repeated elements. (RRR?RR9RU(tseqR3RItx((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyt_random_subsetNs  cCs|dks||kr4tjd||fn|dk rPtj|nt|}d||f|_tt|}g}|}xg||kr|j t |g|||j ||j |g|t ||}|d7}qW|S(sReturns a random graph according to the Barabási–Albert preferential attachment model. A graph of ``n`` nodes is grown by attaching new nodes each with ``m`` edges that are preferentially attached to existing nodes with high degree. Parameters ---------- n : int Number of nodes m : int Number of edges to attach from a new node to existing nodes seed : int, optional Seed for random number generator (default=None). Returns ------- G : Graph Raises ------ NetworkXError If ``m`` does not satisfy ``1 <= m < n``. References ---------- .. [1] A. L. Barabási and R. Albert "Emergence of scaling in random networks", Science 286, pp 509-512, 1999. isEBarabási–Albert network must have m >= 1 and m < n, m = %d, n = %dsbarabasi_albert_graph(%s,%s)N( RR>RRRRRRER*RFRGtextendR`(R R3RR"RItrepeated_nodestsource((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyRZs"    c Cs|dks||kr4tjd||fn|dksL|dkrbtjd|n|dk r~tj|nt|}d|_|j}|}xK||krt||}|j }|j |||j |d} x| |krtj|krg|j |D],} |j ||  r#| |k r#| ^q#} | rtj| } |j || |j | | d} qqn|j }|j |||j || d} qW|j|g||d7}qW|S(sHolme and Kim algorithm for growing graphs with powerlaw degree distribution and approximate average clustering. Parameters ---------- n : int the number of nodes m : int the number of random edges to add for each new node p : float, Probability of adding a triangle after adding a random edge seed : int, optional Seed for random number generator (default=None). Notes ----- The average clustering has a hard time getting above a certain cutoff that depends on ``m``. This cutoff is often quite low. The transitivity (fraction of triangles to possible triangles) seems to decrease with network size. It is essentially the Barabási–Albert (BA) growth model with an extra step that each random edge is followed by a chance of making an edge to one of its neighbors too (and thus a triangle). This algorithm improves on BA in the sense that it enables a higher average clustering to be attained if desired. It seems possible to have a disconnected graph with this algorithm since the initial ``m`` nodes may not be all linked to a new node on the first iteration like the BA model. Raises ------ NetworkXError If ``m`` does not satisfy ``1 <= m <= n`` or ``p`` does not satisfy ``0 <= p <= 1``. References ---------- .. [1] P. Holme and B. J. Kim, "Growing scale-free networks with tunable clustering", Phys. Rev. E, 65, 026107, 2002. is.NetworkXError must have m>1 and mRRRRRR8R`tpopRtappendt neighborsR:R9Ra( R R3R!RR"RbRctpossible_targetsttargettcounttnbrt neighborhood((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyRsH.           c CsL|dks|dkr9dj|}tj|n|dkr]d}tj|n|dk rytj|ntj}d|jd<|jddd}x||krGtj |j }|j |t }xB|j |D]1}tj|kr|j||t}qqW|s:|j|q|d7}qW|S( scReturns an undirected graph using the duplication-divergence model. A graph of ``n`` nodes is created by duplicating the initial nodes and retaining edges incident to the original nodes with a retention probability ``p``. Parameters ---------- n : int The desired number of nodes in the graph. p : float The probability for retaining the edge of the replicated node. seed : int, optional A seed for the random number generator of ``random`` (default=None). Returns ------- G : Graph Raises ------ NetworkXError If `p` is not a valid probability. If `n` is less than 2. References ---------- .. [1] I. Ispolatov, P. L. Krapivsky, A. Yuryev, "Duplication-divergence model of protein interaction network", Phys. Rev. E, 71, 061911, 2005. iis$NetworkXError p={0} is not in [0,1].is$n must be greater than or equal to 2sDuplication-Divergence GraphRN(tformatRR>RRRR(tgraphRR9R8tadd_nodeRLRfR1t remove_node( R R!RtmsgR"RDt random_nodetflagRj((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyRs0!      cCs|dk rtj|ntdtj|d}t|}d|||f|_|d}xvt|D]h}tj|krs|d7}|j||tj|kr|d7}|j|d|qqsqsW|S(sSReturns a random lobster graph. A lobster is a tree that reduces to a caterpillar when pruning all leaf nodes. A caterpillar is a tree that reduces to a path graph when pruning all leaf nodes; setting ``p2`` to zero produces a caterillar. Parameters ---------- n : int The expected number of nodes in the backbone p1 : float Probability of adding an edge to the backbone p2 : float Probability of adding an edge one level beyond backbone seed : int, optional Seed for random number generator (default=None). ig?srandom_lobster(%d,%s,%s)iN(RRRRRRR*R(R tp1tp2RtllentLt current_node((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyR2s     cCstd}d|_|dk r1tj|ng}g}d}x|D]z\}}}t||} |j|| tjt || d|} |j| ||7}tj j || }qJWxt t |dD]} || j} || dj} || }d}xl||krtj| }tj| }||ks|j||rjqq|j|||d}qWqW|S(s+Returns a random shell graph for the constructor given. Parameters ---------- constructor : list of three-tuples Represents the parameters for a shell, starting at the center shell. Each element of the list must be of the form ``(n, m, d)``, where ``n`` is the number of nodes in the shell, ``m`` is the number of edges in the shell, and ``d`` is the ratio of inter-shell (next) edges to intra-shell edges. If ``d`` is zero, there will be no intra-shell edges, and if ``d`` is one there will be all possible intra-shell edges. seed : int, optional Seed for random number generator (default=None). Examples -------- >>> constructor = [(10, 20, 0.8), (20, 40, 0.8)] >>> G = nx.random_shell_graph(constructor) israndom_shell_graph(constructor)t first_labeliN(RRRRRRReRtconvert_node_labels_to_integersRt operatorstunionR*R?R8R9R:R(t constructorRR"tglistt intra_edgestnnodesR R3R\t inter_edgestgtgitnlist1tnlist2t total_edgesR=R5R%((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyRUs:       icCsrddlm}y"t|d|d|d|}Wntjd|nX||}d||f|_|S(sReturns 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). i(tdegree_sequence_treetgammaRRKs5Exceeded max (%d) attempts for a valid tree sequence.srandom_powerlaw_tree(%s,%s)(tnetworkx.generators.degree_seqRRRR>R(R RRRKRtsR"((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyRs   c Cs&|dk rtj|ntjj|d|}g|D]*}t|ttt |d^q;}tjj|d|}g|D]*}t|ttt |d^q}xR|D]J}|t |ddkr|Stj d|d} |j || RL( R RRRKtzRtzseqtswaptdegtindex((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pyRs 77  (#t__doc__tjoint __author__R,RRtnetworkxRtnetworkx.generators.classicRRRt collectionsRt__all__RRLRRR RRRR R R R R`RRRRRRR(((su/home/gitlab-runner/builds/8480fa44/0/bergerc/fluidmanager-web/art-framework/bin/networkx/generators/random_graphs.pytsX       M= =9 B F% o ; Y D # ;*