U ª9%eo­ã@sÈdZddlZddlZddlmZddlZddlmZddl m Z m Z m Z m Z ddlmZdd d d d d dddddddddddddgZedƒd3dd„ƒZedƒd4dd „ƒZeZeZedƒd5dd „ƒZedƒd6d d „ƒZed!ƒd7d"d„ƒZed!ƒd8d#d„ƒZed$ƒd9d&d„ƒZedƒd:d'd„ƒZd(d)„Zedƒd;d*d„ƒZed$ƒdd-d„ƒZed!ƒd?d.d„ƒZ edƒd@d/d„ƒZ!edƒdAd0d„ƒZ"edƒdBd1d„ƒZ#ed!ƒdCd2d„ƒZ$dS)Dz Generators for random graphs. éN)Ú defaultdict)Úpy_random_stateé)Úcomplete_graphÚ empty_graphÚ path_graphÚ star_graph)Údegree_sequence_treeÚfast_gnp_random_graphÚgnp_random_graphÚdense_gnm_random_graphÚgnm_random_graphÚerdos_renyi_graphÚbinomial_graphÚnewman_watts_strogatz_graphÚwatts_strogatz_graphÚconnected_watts_strogatz_graphÚrandom_regular_graphÚbarabasi_albert_graphÚdual_barabasi_albert_graphÚextended_barabasi_albert_graphÚpowerlaw_cluster_graphÚrandom_lobsterÚrandom_shell_graphÚrandom_powerlaw_treeÚrandom_powerlaw_tree_sequenceÚrandom_kernel_graphéFc Cs,t|ƒ}|dks|dkr*tj||||dSt d|¡}|r´t |¡}d}d}||kr´t d| ¡¡}|dt||ƒ}||krž||krž||}|d}q|||krN| ||¡qNd}d}||kr(t d| ¡¡}|dt||ƒ}||kr||kr||}|d}qì||kr¼| ||¡q¼|S)u€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 : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. 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 [1]_ 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. rr)ÚseedÚdirectedgð?éÿÿÿÿ) rÚnxr ÚmathÚlogÚDiGraphÚrandomÚintÚadd_edge) ÚnÚprrÚGZlpÚvÚwÚlr©r.ú`/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/networkx/generators/random_graphs.pyr 's6%    cCsˆ|rt t|ƒd¡}t ¡}nt t|ƒd¡}t ¡}| t|ƒ¡|dkrP|S|dkrdt||dS|D]}|  ¡|krh|j |Žqh|S)u³Returns 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$. Parameters ---------- n : int The number of nodes. p : float Probability for edge creation. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. directed : bool, optional (default=False) If True, this function returns a directed graph. See Also -------- fast_gnp_random_graph Notes ----- This algorithm [2]_ 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. :func:`binomial_graph` and :func:`erdos_renyi_graph` are aliases for :func:`gnp_random_graph`. >>> nx.binomial_graph is nx.gnp_random_graph True >>> nx.erdos_renyi_graph is nx.gnp_random_graph True 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). rrr©Z create_using) Ú itertoolsÚ permutationsÚranger!r$Ú combinationsÚGraphÚadd_nodes_fromrr%r')r(r)rrÚedgesr*Úer.r.r/r ns)    c Cs²||dd}||kr"t|ƒ}nt|ƒ}|dks:||kr>|Sd}d}d}d}| ||¡||kr„| ||¡|d7}||kr„|S|d7}|d7}||krN|d7}|d}qNdS)a†Returns 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 : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. 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. rrrN)rrÚ randranger') r(ÚmrZmmaxr*Úur+ÚtÚkr.r.r/r ®s(#  c Cs¶|rt ¡}nt ¡}| t|ƒ¡|dkr0|S||d}|sH|d}||kr\t||dSt|ƒ}d}||kr²| |¡}| |¡} || ksh| || ¡rœqhqh|  || ¡|d}qh|S)a˜Returns 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 : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. directed : bool, optional (default=False) If True return a directed graph See also -------- dense_gnm_random_graph rg@r0r) r!r$r5r6r3rÚlistÚchoiceÚhas_edger') r(r:rrr*Z max_edgesÚnlistÚ edge_countr;r+r.r.r/r ës*       écCs||krt d¡‚||kr$t |¡St|ƒ}t| ¡ƒ}|}td|ddƒD]B}||d…|d|…}tt|ƒƒD]} | || || ¡qvqNt|  ¡ƒ} | D]^\} } |  ¡|kr¢|  |¡} | | ksÔ|  | | ¡rô|  |¡} |  | ¡|dkrÀq¢qÀ| | | ¡q¢|S)uØReturns 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 : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Notes ----- First create a ring over $n$ nodes [1]_. 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. https://doi.org/10.1016/S0375-9601(99)00757-4 z"k>=n, choose smaller k or larger nrrNr)r!Ú NetworkXErrorrrr>Únodesr3Úlenr'r7r%r?r@Údegree)r(r=r)rr*rAZfromvÚjZtovÚir8r;r+r,r.r.r/r"s*&        c Cs$||krt d¡‚||kr$t |¡St ¡}tt|ƒƒ}td|ddƒD],}||d…|d|…}| t||ƒ¡qJtd|ddƒD]”}||d…|d|…}t||ƒD]l\}} | ¡|kr°|  |¡} | |ksä|  || ¡r|  |¡} |  |¡|dkrÎq°qÎ|  || ¡|  || ¡q°qŠ|S)uQReturns 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 : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. See Also -------- newman_watts_strogatz_graph connected_watts_strogatz_graph Notes ----- First create a ring over $n$ nodes [1]_. 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. z!k>n, choose smaller k or larger nrrNr)r!rDrr5r>r3Úadd_edges_fromÚzipr%r?r@rGÚ remove_edger') r(r=r)rr*rErHÚtargetsr;r+r,r.r.r/rhs*)       éédcCs<t|ƒD]$}t||||ƒ}t |¡r|Sqt d¡‚dS)u¶Returns 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 : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Notes ----- First create a ring over $n$ nodes [1]_. 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$. The entire process is repeated until a connected graph results. See Also -------- newman_watts_strogatz_graph watts_strogatz_graph References ---------- .. [1] Duncan J. Watts and Steven H. Strogatz, Collective dynamics of small-world networks, Nature, 393, pp. 440--442, 1998. z Maximum number of tries exceededN)r3rr!Z is_connectedrD)r(r=r)ÚtriesrrIr*r.r.r/r²s ,   csˆˆddkrt d¡‚dˆkr.ˆks:nt d¡‚ˆdkrJtˆƒSdd„‰‡‡‡‡fdd„}|ƒ}|d krz|ƒ}qjt ¡}| |¡|S) a@Returns a random $d$-regular graph on $n$ nodes. A regular graph is a graph where each node has the same number of neighbors. 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 \times d$ must be even. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. 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 \times 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. https://doi.org/10.1017/S0963548399003867 .. [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 rrzn * d must be evenz+the 0 <= d < n inequality must be satisfiedcSsR|sdS|D]@}|D]6}||kr$q ||kr6||}}||f|krdSqq dS)NTFr.)r7Úpotential_edgesÚs1Ús2r.r.r/Ú _suitables   z'random_regular_graph.._suitablecsÈtƒ}ttˆƒƒˆ}|rÄtdd„ƒ}ˆ |¡t|ƒ}t||ƒD]^\}}||kr\||}}||kr€||f|kr€| ||f¡qB||d7<||d7<qBˆ||ƒs°dSdd„| ¡Dƒ}q|S)NcSsdS)Nrr.r.r.r.r/Ú6óz=random_regular_graph.._try_creation..rcSs"g|]\}}t|ƒD]}|‘qqSr.©r3)Ú.0ÚnodeZ potentialÚ_r.r.r/Ú Es þz?random_regular_graph.._try_creation..) Úsetr>r3rÚshuffleÚiterrKÚaddÚitems)r7ZstubsrQZstubiterrRrS©rTÚdr(rr.r/Ú _try_creation/s&    þz+random_regular_graph.._try_creationN)r!rDrr5rJ)rbr(rrcr7r*r.rar/ræs-    cCs,tƒ}t|ƒ|kr(| |¡}| |¡q|S)zÛReturn m unique elements from seq. This differs from random.sample which can return repeated elements if seq holds repeated elements. Note: rng is a random.Random or numpy.random.RandomState instance. )r\rFr?r_)Úseqr:ÚrngrMÚxr.r.r/Ú_random_subsetYs    rgcCsÜ|dks||kr&t d|›d|›¡‚|dkr8t|ƒ}n8t|ƒ|ksPt|ƒ|krht d|›d|›d¡‚| ¡}dd „| ¡Dƒ}t|ƒ}||krØt|||ƒ}| t|g||ƒ¡|  |¡|  |g|¡|d7}qŠ|S) u|Returns a random graph using Barabási–Albert preferential attachment 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 : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. initial_graph : Graph or None (default) Initial network for Barabási–Albert algorithm. It should be a connected graph for most use cases. A copy of `initial_graph` is used. If None, starts from a star graph on (m+1) nodes. Returns ------- G : Graph Raises ------ NetworkXError If `m` does not satisfy ``1 <= m < n``, or the initial graph number of nodes m0 does not satisfy ``m <= m0 <= n``. References ---------- .. [1] A. L. Barabási and R. Albert "Emergence of scaling in random networks", Science 286, pp 509-512, 1999. ru;Barabási–Albert network must have m >= 1 and m < n, m = ú, n = Nu1Barabási–Albert initial graph needs between m=z and n=ú nodescSs"g|]\}}t|ƒD]}|‘qqSr.rW©rXr(rbrZr.r.r/r[žs z)barabasi_albert_graph..) r!rDrrFÚcopyrGrgrJrKÚextend)r(r:rÚ initial_graphr*Úrepeated_nodesÚsourcerMr.r.r/rhs(&ÿ ÿ   c Cs€|dks||kr&t d|›d|›¡‚|dks6||krLt d|›d|›¡‚|dks\|dkrlt d|›¡‚|dkr€t|||ƒS|dkr”t|||ƒS|dkr¬tt||ƒƒ}nDt|ƒt||ƒksÊt|ƒ|krèt dt||ƒ›d |›d ¡‚| ¡}t|ƒ}d d „| ¡Dƒ}t|ƒ} | |kr||  ¡|kr0|} n|} t || |ƒ}|  t | g| |ƒ¡|  |¡|  | g| ¡| d7} q|S) u¯Returns a random graph using dual Barabási–Albert preferential attachment A graph of $n$ nodes is grown by attaching new nodes each with either $m_1$ edges (with probability $p$) or $m_2$ edges (with probability $1-p$) that are preferentially attached to existing nodes with high degree. Parameters ---------- n : int Number of nodes m1 : int Number of edges to link each new node to existing nodes with probability $p$ m2 : int Number of edges to link each new node to existing nodes with probability $1-p$ p : float The probability of attaching $m_1$ edges (as opposed to $m_2$ edges) seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. initial_graph : Graph or None (default) Initial network for Barabási–Albert algorithm. A copy of `initial_graph` is used. It should be connected for most use cases. If None, starts from an star graph on max(m1, m2) + 1 nodes. Returns ------- G : Graph Raises ------ NetworkXError If `m1` and `m2` do not satisfy ``1 <= m1,m2 < n``, or `p` does not satisfy ``0 <= p <= 1``, or the initial graph number of nodes m0 does not satisfy m1, m2 <= m0 <= n. References ---------- .. [1] N. Moshiri "The dual-Barabasi-Albert model", arXiv:1810.10538. ru;Dual Barabási–Albert must have m1 >= 1 and m1 < n, m1 = rhu;Dual Barabási–Albert must have m2 >= 1 and m2 < n, m2 = ru;Dual Barabási–Albert network must have 0 <= p <= 1, p = NuABarabási–Albert initial graph must have between max(m1, m2) = z and n = ricSs"g|]\}}t|ƒD]}|‘qqSr.rWrjr.r.r/r[üs z.dual_barabasi_albert_graph..)r!rDrrÚmaxrFrkr>rGr%rgrJrKrl) r(Úm1Úm2r)rrmr*rMrnror:r.r.r/r°sH+ÿÿÿ  ÿ    csú|dks||kr*d|›d|›}t |¡‚||dkrPd|›d|›}t |¡‚t|ƒ}g}| t|ƒ¡|}||krö| ¡} t|ƒd‰t|ƒˆd} | |krp| ¡| |krp‡fdd„| ¡Dƒ} t|ƒD]–} |  | ¡} t || ƒ‰ˆ  | ¡|  ‡fd d„|Dƒ¡}|  | |¡|  | ¡|  |¡| | ¡ˆkrL|   | ¡| |¡ˆkrÖ|| krÖ|   |¡qÖqn|| krŒ||kr¬nn|| ¡kr®| kr¬nnú‡fd d„| ¡Dƒ} t|ƒD]Ø} |  | ¡}t ||ƒ‰|  ˆ¡} ˆ  |¡|  ‡fd d„|Dƒ¡}| || ¡|  ||¡|  | ¡|  |¡| | ¡d krf| | krf|   | ¡|| krŒ| |¡ˆkr¦|   |¡n| |¡dkrÐ|   |¡qÐqnt|||ƒ}| t|g||ƒ¡| |¡| |g|d¡|d7}qn|S) uˆReturns an extended Barabási–Albert model graph. An extended Barabási–Albert model graph is a random graph constructed using preferential attachment. The extended model allows new edges, rewired edges or new nodes. Based on the probabilities $p$ and $q$ with $p + q < 1$, the growing behavior of the graph is determined as: 1) With $p$ probability, $m$ new edges are added to the graph, starting from randomly chosen existing nodes and attached preferentially at the other end. 2) With $q$ probability, $m$ existing edges are rewired by randomly choosing an edge and rewiring one end to a preferentially chosen node. 3) With $(1 - p - q)$ probability, $m$ new nodes are added to the graph with edges attached preferentially. When $p = q = 0$, the model behaves just like the Barabási–Alber model. Parameters ---------- n : int Number of nodes m : int Number of edges with which a new node attaches to existing nodes p : float Probability value for adding an edge between existing nodes. p + q < 1 q : float Probability value of rewiring of existing edges. p + q < 1 seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Returns ------- G : Graph Raises ------ NetworkXError If `m` does not satisfy ``1 <= m < n`` or ``1 >= p + q`` References ---------- .. [1] Albert, R., & Barabási, A. L. (2000) Topology of evolving networks: local events and universality Physical review letters, 85(24), 5234. rz7Extended Barabasi-Albert network needs m>=1 and m.csg|]}|ˆkr|‘qSr.r.©rXrt)Úprohibited_nodesr.r/r[mscs,g|]$\}}d|kr ˆkrnq|‘qS©rr.rsrvr.r/r[„s  csg|]}|ˆkr|‘qSr.r.rx)Úneighbor_nodesr.r/r[“sr)r!rDrrlr3r%rFÚsizerGr?r>Úappendr'ÚremoverLrgrJrK)r(r:r)ÚqrÚmsgr*Zattachment_preferenceÚnew_nodeZ a_probabilityZ clique_sizeZelligible_nodesrIZsrc_nodeZ dest_noderYrMr.)rwr{ryr/rsx1         ÿ     ÿþB     ÿ          c s:|dks||kr&t d|›d|›¡‚|dks6|dkrFt d|›¡‚t|ƒ‰tˆ ¡ƒ}|‰ˆ|kr6t|||ƒ}| ¡}ˆ ˆ|¡| |¡d}||kr|  ¡|krô‡‡fdd„ˆ  |¡Dƒ}|rô|  |¡} ˆ ˆ| ¡| | ¡|d}q–| ¡}ˆ ˆ|¡| |¡|d}q–|  ˆg|¡ˆd7‰q^ˆS)u)Holme 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 : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. 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. rz'NetworkXError must have m>1 and m.) r!rDrr>rErgÚpopr'r}r%Z neighborsr?rl) r(r:r)rrnZpossible_targetsÚtargetÚcountZ neighborhoodr‚r.rƒr/r¶s>0        þ       cCs´t|ƒt|ƒ}}tdd„||fDƒƒr2t d¡‚td| ¡|dƒ}t|ƒ}|d}t|ƒD]L}| ¡|krb|d7}| ||¡|}| ¡|krf|d7}| ||¡qŠqfqb|S)a0Returns 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 caterpillar. This implementation iterates on the probabilities `p1` and `p2` to add edges at levels 1 and 2, respectively. Graphs are therefore constructed iteratively with uniform randomness at each level rather than being selected uniformly at random from the set of all possible lobsters. 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 : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Raises ------ NetworkXError If `p1` or `p2` parameters are >= 1 because the while loops would never finish. css|]}|dkVqdS)rNr.)rXr)r.r.r/Ú .sz!random_lobster..z6Probability values for `p1` and `p2` must both be < 1.rgà?r) ÚabsÚanyr!rDr&r%rr3r')r(Úp1Úp2rZllenÚLZ current_nodeZcat_noder.r.r/rs     cCstdƒ}g}g}d}|D]\\}}}t||ƒ} | || ¡tjt|| |d|d} | | ¡||7}tj || ¡}qtt |ƒdƒD]v} t || ƒ} t || dƒ} || }d}||kr†|  | ¡}|  | ¡}||ks²|  ||¡ræq²q²|  ||¡|d}q²q†|S)aaReturns 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 : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Examples -------- >>> constructor = [(10, 20, 0.8), (20, 40, 0.8)] >>> G = nx.random_shell_graph(constructor) r)r)Z first_labelr)rr&r}r!Zconvert_node_labels_to_integersr Ú operatorsÚunionr3rFr>r?r@r')Ú constructorrr*ZglistZ intra_edgesZnnodesr(r:rbZ inter_edgesÚgÚgiZnlist1Znlist2Z total_edgesrBr;r+r.r.r/rAs6  ÿ      cCst||||d}t|ƒ}|S)a: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`. 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). )ÚgammarrP)rr )r(r’rrPrdr*r.r.r/rzsc s tjjˆ||d}‡fdd„|Dƒ}tjj|||d}‡fdd„|Dƒ}|D]<}dˆt|ƒdkrl|S| dˆd¡}| ¡||<qLt d|›d ¡‚d S) aKReturns 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`. 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). )Úexponentrcs g|]}tˆtt|ƒdƒƒ‘qSrz©ÚminrpÚround©rXÚs©r(r.r/r[¿sz1random_powerlaw_tree_sequence..cs g|]}tˆtt|ƒdƒƒ‘qSrzr”r—r™r.r/r[ÄsrrrzExceeded max (z%) attempts for a valid tree sequence.N)r!ÚutilsZpowerlaw_sequenceÚsumÚrandintr„rD) r(r’rrPÚzZzseqZswapruÚindexr.r™r/ržs ÿc sÄ|dkr&ddl‰ddl}‡‡fdd„}t ¡}| t|ƒ¡d\}}||krÀt d| ¡¡ }ˆ||||dƒ|krŒ|d|d}}qDt  |||||||ƒ¡}|  |d|d¡qD|S)uñReturns an random graph based on the specified kernel. The algorithm chooses each of the $[n(n-1)]/2$ possible edges with probability specified by a kernel $\kappa(x,y)$ [1]_. The kernel $\kappa(x,y)$ must be a symmetric (in $x,y$), non-negative, bounded function. Parameters ---------- n : int The number of nodes kernel_integral : function Function that returns the definite integral of the kernel $\kappa(x,y)$, $F(y,a,b) := \int_a^b \kappa(x,y)dx$ kernel_root: function (optional) Function that returns the root $b$ of the equation $F(y,a,b) = r$. If None, the root is found using :func:`scipy.optimize.brentq` (this requires SciPy). seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Notes ----- The kernel is specified through its definite integral which must be provided as one of the arguments. If the integral and root of the kernel integral can be found in $O(1)$ time then this algorithm runs in time $O(n+m)$ where m is the expected number of edges [2]_. The nodes are set to integers from $0$ to $n-1$. Examples -------- Generate an ErdÅ‘s–Rényi random graph $G(n,c/n)$, with kernel $\kappa(x,y)=c$ where $c$ is the mean expected degree. >>> def integral(u, w, z): ... return c * (z - w) >>> def root(u, w, r): ... return r / c + w >>> c = 1 >>> graph = nx.random_kernel_graph(1000, integral, root) See Also -------- gnp_random_graph expected_degree_graph References ---------- .. [1] Bollobás, Béla, Janson, S. and Riordan, O. "The phase transition in inhomogeneous random graphs", *Random Structures Algorithms*, 31, 3--122, 2007. .. [2] Hagberg A, Lemons N (2015), "Fast Generation of Sparse Random Kernel Graphs". PLoS ONE 10(9): e0135177, 2015. doi:10.1371/journal.pone.0135177 Nrcs"‡‡‡‡fdd„}ˆj |ˆd¡S)Ncsˆˆˆ|ƒˆS)Nr.)Úb)ÚaÚkernel_integralÚrÚyr.r/Ú my_functionsz=random_kernel_graph..kernel_root..my_functionr)ÚoptimizeZbrentq)r£r r¢r¤©r¡Úsp)r r¢r£r/Ú kernel_rootsz(random_kernel_graph..kernel_root)rrr) ÚscipyZscipy.optimizer!r5r6r3r"r#r%Úceilr') r(r¡r¨rr©ÚgraphrIrHr¢r.r¦r/rÖs<)NF)NF)N)NF)N)N)rON)N)NN)NN)N)N)N)N)rCNrO)rCNrO)NN)%Ú__doc__r1r"Ú collectionsrZnetworkxr!Znetworkx.utilsrZclassicrrrrZ degree_seqr Ú__all__r r rrr r rrrrrgrrrrrrrrrr.r.r.r/Ús‚   í F ; < 6 E I 3 r G b # X 1 8 # 7