btj<dZddlZddlZddlmZddlZddlmZddl m Z ddl m Z m Z mZmZdd lmZgd Zedejdd d&dddZedejdd d&dddZeZeZedejdd d'dddZedejdd d&dddZedejdd d'dddZedejdd d'dddZedejdd d(dddZedejdd d'dddZdZedejdd d)dddZedejdd  d)dddZ edejdd d'dddZ!edejdd d'dddZ"edejdd d'dddZ#edejdd d'ddd Z$edejdd d'ddd!Z%edejdd d*ddd"Z&edejd#d*d$Z'edejdd  d)ddd%Z(dS)+z Generators for random graphs. N) defaultdict)py_random_state)check_create_using)complete_graph empty_graph path_graph star_graph)degree_sequence_tree)fast_gnp_random_graphgnp_random_graphdense_gnm_random_graphgnm_random_grapherdos_renyi_graphbinomial_graphnewman_watts_strogatz_graphwatts_strogatz_graphconnected_watts_strogatz_graphrandom_regular_graphbarabasi_albert_graphdual_barabasi_albert_graphextended_barabasi_albert_graphpowerlaw_cluster_graphrandom_lobsterrandom_lobster_graphrandom_shell_graphrandom_powerlaw_treerandom_powerlaw_tree_sequencerandom_kernel_graphT)graphs returns_graphF create_usingc:|r tjn tj}t||d|}|dks|dkrtj|||||St ||}t jd|z }|rd}d} ||krt jd|z } | dzt| |z z} | |kr||kr| |z } |dz}| |kr||k||kr| | |||kd}d} ||krt jd|z } | dzt| |z z} | |kr||kr| |z } |dz}| |kr||k||kr| || ||k|S) uReturns 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. create_using : Graph constructor, optional (default=nx.Graph or nx.DiGraph) Graph type to create. If graph instance, then cleared before populated. Multigraph types are not supported and raise a ``NetworkXError``. By default NetworkX Graph or DiGraph are used depending on `directed`. 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. Fdirected multigraphdefaultrr)seedr'r$r#g?) nxDiGraphGraphrrr mathlograndomintadd_edge) npr*r'r$r)Glpvwlrs _/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/networkx/generators/random_graphs.pyr r )sT%2bjj"(G%xE7L Avva" qth\     AL111A #'  B !  !ee# -..BABG $Aq&&QUUEEq&&QUU1uu 1a   !ee A A a%% XcDKKMM) * * ECRLL 1ffQAAAA1ffQ q55 JJq!    a%% Hcz|r tjn tj}t||d|}|dkrt ||Stj||}|dkr|S|r t jn t j}|t|dD]$}| |kr |j |%|S)uReturns 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. create_using : Graph constructor, optional (default=nx.Graph or nx.DiGraph) Graph type to create. If graph instance, then cleared before populated. Multigraph types are not supported and raise a ``NetworkXError``. By default NetworkX Graph or DiGraph are used depending on `directed`. 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). Fr&rr#rr) r,r-r.rrr itertools permutations combinationsranger1r3) r4r5r*r'r$r)r6edgetooles r;rrzs\%2bjj"(G%xE7L Avval;;;; q|444AAvv)1My%%y7MH XeAhh " " ;;==1   AJNN Hr<cdt|dd}||dz zdz}||krt||St||}|dkr|Sd}d}d}d} |||z || z kr#|||| dz } | |kr|S|dz }|dz }||kr |dz }|dz}])aoReturns 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`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. 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. Fr'r(rrr)rrr randranger3) r4mr*r$mmaxr6ur8tks r;rrsN&lUuUUUL A;! DDyya...A|$$AAvv A A A A  >>$( # #a!e + + JJq!    FAAvv Q Q 66 FAAA r<c|r tjn tj}t||d|}|dkrtj||S|r||dz zn ||dz zdz }||krt ||Stj||}t |}d} | |krh||} ||} | | ks|| | rM| | | | dz} | |kh|S)aReturns 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 create_using : Graph constructor, optional (default=nx.Graph or nx.DiGraph) Graph type to create. If graph instance, then cleared before populated. Multigraph types are not supported and raise a ``NetworkXError``. By default NetworkX Graph or DiGraph are used depending on `directed`. See also -------- dense_gnm_random_graph Fr&rr#g@r) r,r-r.rr rlistchoicehas_edger3) r4rGr*r'r$r) max_edgesr6nlist edge_countrIr8s r;rrs/@%2bjj"(G%xE7L Avv~al;;;;'>QU Q!a%[3->II~~al;;;; q|444A GGEJ q.. KK   KK   66QZZ1%%6  JJq!   #aJ q.. Hr<ct|dd}||krtjd||krtj||St ||}t |}|}td|dzdzD]X}||d|d|z} tt|D]$} | || | | %Yt | } | D]\} } | |kr| |}|| ks| | |rN| |}|| |dz krn2|| k8| | |N| | ||S)uReturns 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`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. 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 FrEz"k>=n, choose smaller k or larger nrrNr)rr, NetworkXErrorrr rMnodesrAlenr3edgesr1rNrOdegree)r4rKr5r*r$r6rQfromvjtovirCrIr8r9s r;rr9sT&lUuUUUL1uuCDDD Avv L111A|$$A OOE E 1a1fqj ! !))ABBi%!*$s5zz"" ) )A JJuQxQ ( ( ( ( ) QWWYYA ! !1 ;;==1   E""Aq&&AJJq!,,&KK&&88A;;!a%''q&&AJJq!,,&  1a   Hr<ct|dd}||krtjd||krtj||}|Stj||}t t |}t d|dzdzD]:}||d|d|z}|t||;t d|dzdzD]}||d|d|z}t||D]\} } | |kr| |} | | ks| | | rN| |} | | |dz krnH| | k8| | | N| | | || | Ɍ|S) u:Returns 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`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. 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. FrEz!k>n, choose smaller k or larger nr#rrNr)rr,rUrr rMrAadd_edges_fromzipr1rNrOrY remove_edger3) r4rKr5r*r$r6rVr[targetsrIr8r9s r;rrsZ&lUuUUUL1uuBCCC Avv  a . . q|444A qNNE 1a1fqj ! !..)eAaCj( UG,,----1a1fqj ! ! % %)eAaCj(w'' % %DAq{{}}q  KK&&1ff 1a 0 0f E**Axx{{a!e++1ff 1a 0 0f MM!Q'''JJq!$$$ % Hr<dct|D].}t|||||}tj|r|cS/tjd)uReturns 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`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. 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. r#z Maximum number of tries exceeded)rArr, is_connectedrU)r4rKr5triesr*r$r]r6s r;rrsd`5\\ Aq$\ J J J ?1   HHH  = > >>r<cdt|dd}zdzdkrtjddcxkrksntjdtj|}dkr|Sdfd }|}| |}| |||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`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. 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 FrErrzn * d must be evenz+the 0 <= d < n inequality must be satisfiedr#cZ|sdS|D]#}|D]}||krn||kr||}}||f|vrdS$dS)NTF)rXpotential_edgess1s2s r; _suitablez'random_regular_graph.._suitableIst 4! B% 88E77B85((444)ur<ct}ttz}|rtd} |t |}t ||D]S\}}||kr||}}||kr||f|vr|||f3||xxdz cc<||xxdz cc<T||sdSd|D}||S)NcdS)Nrrjrjr<r;z=random_regular_graph.._try_creation..cs!r<rc<g|]\}}t|D]}|SrjrA).0node potential_s r; z?random_regular_graph.._try_creation..rsK#D)y))r<) setrMrArshuffleiterr`additems) rXstubsrkstubiterrlrmrndr4r*s r; _try_creationz+random_regular_graph.._try_creation\sFU1XX" )))44O LL   E{{Hh11 - -B77B88"b!6!6IIr2h''''#B'''1,'''#B'''1,''''9UO44 t'6'<'<'>'>E! * r<)rr,rUr r_)rr4r*r$r6rrXrns``` @r;rr sb&lUuUUUL A{a3444 ::::A::::LMMM q|444AAvv&@ MOOE -  -U Hr<ct}t||kr=||}||t||k=|S)zReturn 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. )ryrWrNr|)seqrGrngrbxs r;_random_subsetrsVeeG g,,   JJsOO A g,,   Nr<ct|dd}|dks||krtjd|d||t||}nUt ||kst ||krtjd|d|d |}d |D}t |}||krqt|||}|t|g|z|| || |g|z|dz }||kq|S) ueReturns 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. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. 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. FrEru;Barabási–Albert network must have m >= 1 and m < n, m = , n = Nu1Barabási–Albert initial graph needs between m=z and n= nodesc<g|]\}}t|D]}|Srjrsrtr4rrws r;rxz)barabasi_albert_graph../AAADAqaAA1aAAAAr<) rr,rUr rWcopyrYrr_r`extend) r4rGr* initial_graphr$r6repeated_nodessourcerbs r;rrsR&lUuUUUL1uuQ V! V VST V V    q, ' ' }   ! !S%7%7!%;%;"WAWWaWWW     BAAHHJJAAAN VVF 1**!D99 fX\733444g&&&vhl+++!  1** Hr<c0t|dd}|dks||krtjd|d||dks||krtjd|d||dks|dkrtjd||dkrt|||| S|dkrt|||| S|t t |||}nqt |t ||kst ||kr)tjd t ||d |d |}t|}d| D} t |} | |kr| |kr|} n|} t| | |}| t| g| z|| || | g| z| dz } | |k|S)uReturns 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. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. 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. FrEru;Dual Barabási–Albert must have m1 >= 1 and m1 < n, m1 = ru;Dual Barabási–Albert must have m2 >= 1 and m2 < n, m2 = ru;Dual Barabási–Albert network must have 0 <= p <= 1, p = r#NuABarabási–Albert initial graph must have between max(m1, m2) = z and n = rc<g|]\}}t|D]}|Srjrsrs r;rxz.dual_barabasi_albert_graph..1rr<)rr,rUrr maxrWrrMrYr1rr_r`r) r4m1m2r5r*rr$r6rbrrrGs r;rrs`&lUuUUUL Avvq W" W WTU W W    Avvq W" W WTU W W    1uuA M! M M    Avv$QD|LLLL a$QD|LLLL s2r{{L 1 1 }  B + +s=/A/AA/E/E"A!$RAA78AAA     1ggGAAAHHJJAAAN VVF 1** ;;==1  AAA!D99 fX\733444g&&&vhl+++! ! 1**" Hr<ct|dd}|dks||krd|d|}tj|||zdkrd|d|}tj|t||}g}|t ||} | |kr|} t|dz t|zdz } | |krR|| |z kr6fd | D} t |D]} | | }t|| || fd |D}| ||| || || |kr| || |kr|| vr| |n;|| cxkr ||zkrnn||cxkr| krnnfd | D} t |D]b} | | }t||| } || fd |D}|||| ||||| || |d kr|| vr| ||| vr0| |kr| |4| |dkr| |dnnt!|||}|t%| g|z||||| g|dzz| dz } | |k|S)uuReturns 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`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. 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. FrErz7Extended Barabasi-Albert network needs m>=1 and m.s'RRRWRcM>Q>Qb>Q>Q>Qr<cg|]}|v| Srjrj)rtrprohibited_nodess r;rxz2extended_barabasi_albert_graph..s$VVVB2EU;U;UR;U;U;Ur<c:g|]\}}d|cxkrknn|Srrjrs r;rxz2extended_barabasi_albert_graph..s>VVVWRa#>U>U>U>U >U>U>U>U>Ub>U>U>Ur<cg|]}|v| Srjrj)rtr nbr_nodess r;rxz2extended_barabasi_albert_graph..s#OOOB2Y;N;NR;N;N;Nr<r)rr,rUr rrAr1rWsizerYrNrMappendr3removerarr_r`)r4rGr5qr*r$msgr6attachment_preferencenew_node a_probability clique_sizeeligible_nodesr]src_node dest_noderurbrrrs @@@r;rrHsl&lUuUUUL1uuQRRRqRRs###1uzzPaPPQPPs### A|$$A  q***H Q,, A 1vv -2  1  [1_!22!4MM  ;;y11  &&& KKOOOO"7OOO  dH--- 4+++&,,X666%,,Y77788H%%**x>/I/I"))(333..xx **m;;&--i888xx **a//&--i888C! 9L%%:AtDDG  S(a99 : : : " ( ( 1 1 1 ! ( ((q1u)= > > > MHo Q,,p Hr<c t|dd}|dks||krtjd|d||dks|dkrtjd|t|| t }| |krIt |||}|}  |||d}||kr| |krj fd |D} | rF| | }  | || |dz}|}  ||||dz}||k| g|z dz |kI S) uHolme 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`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. 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. FrErz'NetworkXError must have m>1 and m.5sB   ::fc22 8;f}}7D}}r<) rr,rUr rMrpopr3rr1 neighborsrNr) r4rGr5r*r$rpossible_targetstargetcount neighborhoodrr6rs @@r;rrsf&lUuUUUL1uuARRRqRRSSS1uuAIaIIJJJA|$$A!WWN F 1**).!TBB!%%'' 66"""f%%%aii{{}}q        {{622     ++l33CJJvs+++"))#...!AIE%))++F JJvv & & &  ! !& ) ) )AIE#aii& vhl+++! 7 1**8 Hr<ct|dd}t|t|}}td||fDrtjdt d|z|zdz}t||}|dz }t|D]}||kr|dz }| |||}||kr3|dz }| ||||k3||k|S)aReturns 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`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. Raises ------ NetworkXError If `p1` or `p2` parameters are >= 1 because the while loops would never finish. FrEc3"K|] }|dkV dS)rNrj)rtr5s r; z'random_lobster_graph..os& $ $a16 $ $ $ $ $ $r<z6Probability values for `p1` and `p2` must both be < 1.rg?r) rabsanyr,rUr2r1r rAr3) r4p1p2r*r$llenL current_nodecat_nodes r;rrKsPD&lUuUUUL WWc"ggB $ $B8 $ $ $$$YWXXX q4;;== 1$s* + +D4&&A!8L 4[[33kkmmb  A L JJq, ' ' '#H++--"$$!  8\222++--"$$ kkmmb   Hr<clddl}|dtdt|||||S)z .. deprecated:: 3.5 `random_lobster` is a deprecated alias for `random_lobster_graph`. Use `random_lobster_graph` instead. rNzC`random_lobster` is deprecated, use `random_lobster_graph` instead.r)category stacklevelr*r$)warningswarnDeprecationWarningr)r4rrr*r$rs r;rrsLOOO MMM# 2r< P P PPr<c t|dd}td|}g}g}d}|D]\}}} t|| z} ||| z t jt || ||j|} || ||z }tj || }tt|dz D]} t|| } t|| dz}|| }d}||krh| | }| |}||ks|||rM||||dz}||kh|S)a;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 : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. Graph instances are not supported. Multigraph and directed types are not supported and raise a ``NetworkXError``. Examples -------- >>> constructor = [(10, 20, 0.8), (20, 40, 0.8)] >>> G = nx.random_shell_graph(constructor) FrErr) first_labelr)rr r2rr,convert_node_labels_to_integersr __class__ operatorsunionrArWrMrNrOr3) constructorr*r$r6glist intra_edgesnnodesr4rGr inter_edgesgginlist1nlist2 total_edgesrRrIr8s r;rrs8&lUuUUULA|$$A EK F % %1a!a%jj 1{?+++  . Q $Q[ Q Q Q     Q!  L  q! $ $CJJN## , ,eBieBFm$$!"o  ;&& F##A F##AAvvAq))v 1a   '!^ ;&& Hr<cpt|dd}t||||}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. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. 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). FrE)gammar*rg)rrr )r4rr*rgr$rr6s r;rrsCD&lUuUUUL 'T O O OCS,//A Hr<)r!ctj||}fd|D}tj|||}fd|D}|D]Z}tj|\}}|r|cS|ddz } ||| <[tjd|d)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). )exponentr*c fg|]-}ttt|d.Srminrroundrtsr4s r;rxz1random_powerlaw_tree_sequence..3 0 0 0C3uQxx## $ $ 0 0 0r<c fg|]-}ttt|d.Srrrs r;rxz1random_powerlaw_tree_sequence..$rr<rrzExceeded max (z%) attempts for a valid tree sequence.)r,utilspowerlaw_sequenceis_valid_tree_degree_sequencerandintrrU) r4rr*rgzzseqswaprwvalidindexs ` r;rrs@ ""1u4"@@A 0 0 0 0a 0 0 0D ""55t"DDA 0 0 0 0a 0 0 0D !!899$??q  KKK QA&&hhjjU EEEE  r<c t|dd}| ddl  fd}tj|}|t |d\}}||krt jd|z  }||z ||z d|kr |dz|dz}}nDt j ||||z ||z |z}| |dz |dz ||k|S) uReturns 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`. create_using : Graph constructor, optional (default=nx.Graph) Graph type to create. If graph instance, then cleared before populated. Multigraph and directed types are not supported and raise a ``NetworkXError``. 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 FrENrcRfd}j|dS)Nc$|z SNrj)bakernel_integralrys r; my_functionz=random_kernel_graph..kernel_root..my_functionys&q!Q//!33r<r)optimizebrentq)rrrrrsps``` r; kernel_rootz(random_kernel_graph..kernel_rootxsJ 4 4 4 4 4 4 4 4;%%k1a88 8r<r#)rrr) rscipyr,r add_nodes_fromrAr/r0r1ceilr3) r4rrr*r$graphr]r[rrs ` @r;r r 2s6D&lUuUUUL 9 9 9 9 9 9 N 5 5 5E q""" FQ a%% Xa$++--' ( ( ( ?1q5!a% + +q 0 0q5!a%qAA !kk!a%Q:::;;A NN1q5!a% ( ( ( a%% Lr<)NFr)rdN)NN)rSNrd))__doc__r>r/ collectionsrnetworkxr,networkx.utilsr utils.miscrclassicrr r r degree_seqr __all__ _dispatchabler rrrrrrrrrrrrrrrrrrrr rjr<r;r s  ######******++++++HHHHHHHHHHHH,,,,,,   0T222L 4L L L L 32L ^T222; d; ; ; ; 32; ~"$T222<D<<<<32<~T2224 d4 4 4 4 324 nT222F DF F F F 32F RT222K TK K K K 32K \T2223?RV3?3?3?3?323?lT222s $s s s s 32s l   T222G tG G G G 32G TT222+/d AEd d d d 32d NT222a $a a a a 32a HT222X tX X X X 32X vT2222 t2 2 2 2 322 jT222QQQQQ32Q"T222: t: : : : 32: zT222$ 4$ $ $ $ 32$ N0000fT222/3TEITTTT32TTTr<