~iSrSSKrSSKrSSKJr SSKrSSKJr SSK J r SSK J r J r JrJr SS KJr /S Qr\"S5\R&"SS S 9S$SS .Sjj55r\"S5\R&"SS S 9S$SS .Sjj55r\r\r\"S5\R&"SS S 9S%SS .Sjj55r\"S5\R&"SS S 9S$SS .Sjj55r\"S5\R&"SS S 9S%SS .Sjj55r\"S5\R&"SS S 9S%SS .Sjj55r\"S5\R&"SS S 9S&SS .Sjj55r\"S5\R&"SS S 9S%SS .Sjj55rSr\"S5\R&"SS S 9S'SS .Sjj55r\"S5\R&"SS S 9S'SS .Sjj55r \"S5\R&"SS S 9S%SS .Sjj55r!\"S5\R&"SS S 9S%SS .Sjj55r"\"S5\R&"SS S 9S%SS .Sjj55r#\"S5\R&"SS S 9S%SS .Sjj55r$\"S5\R&"SS S 9S%SS .Sjj55r%\"S5\R&"SS S 9S(SS .S jj55r&\"S5\R&"SS!9S(S"j55r'\"S5\R&"SS S 9S'SS .S#jj55r(g))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_graph create_usingcU(a[RO[Rn[XCSUS9nUS::dUS:a[R"XX#US9$[ XS9n[ R"SU- 5nU(aSnSn X:av[ R"SUR5- 5n U S-[X- 5-n X:aX:aX- n US-nX:aX:aMX:aURX5 X:aMvSnSn X:av[ R"SUR5- 5n U S-[X- 5-n X:aX:aX- n US-nX:aX:aMX:aURX5 X:aMvU$) u5Returns 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 ^/home/mande/repo/quber/.venv/lib/python3.13/site-packages/networkx/generators/random_graphs.pyr r )snT%bjj"((G%E7L Ava"" t\   A1A #' B  e# -.BABG $A&QUEE&QUu 1 e A A % XXcDKKM) * ECL fAAAf 5 JJq  % HcU(a[RO[Rn[XCSUS9nUS:a [ XS9$[R "XS9nUS::aU$U(a[ RO[ RnU"[U5S5H(nUR5U:dMUR"U6 M* U$)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. 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\%bjj"((G%E7L Ava;; q4AAv)1y%%y7M7MH eAh " ;;=1  JJN# Hr<c&[USSS9nXS- -S-nX:a [X5$[X5nUS:XaU$SnSnSnSn URXH- 5X- :aUR Xg5 U S- n X:XaU$US- nUS- nXp:Xa US- nUS-nMQ)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:`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&lUuUL A;! Dya..A$AAv A A A A  >>$( #ae + JJq  FAv Q Q 6 FAAA r<cU(a[RO[Rn[XCSUS9nUS:Xa[R"XS9$U(aXS- -O XS- -S- nX:a [ XS9$[R"XS9n[ U5nSn X:a\URU5n URU5n X:XdURX5(aMDURX5 U S-n X:aM\U$)auReturns 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@%bjj"((G%E7L Av~~a;;'U Qa%[3->I~a;; q4A GEJ . KK  KK  6QZZ%%  JJq #aJ . Hr<c[USSS9nX:a[R"S5eX:Xa[R"X5$[ X5n[ UR 55nUn[SUS-S-5H>nXxSUSU-n [[U55Hn URXzX5 M M@ [ UR55n U HupUR5U:dMURU5nX:XdURX5(aJURU5nURU 5US- :aMrX:XaM2URX5(aMJURX5 M U$)u9Returns 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;rr9sOT&lUuULuCDD v  11A$A OE E 1a1fqj !Bi%!*$s5z"A JJux (#" QWWYA ;;=1  E"A&AJJq,,KK&88A;!a%'&AJJq,,  1  Hr<c [USSS9nX:a[R"S5eX:Xa[R"X5nU$[R"XS9n[ [ U55n[ SUS-S-5H'nXgSUSU-nUR[Xh55 M) [ SUS-S-5HnXgSUSU-n[Xh5HupUR5U:dMURU5n X:XdURX5(aJURU5n URU 5US- :aMrX:XaM2URX5(aMJURX5 URX5 M M U$) uReturns 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;rrskZ&lUuULuBCC v   a . q4A qNE 1a1fqj !)eAaj( U,-" 1a1fqj !)eAaj('DA{{}q KK&f 1 0 0 E*Axx{a!e+f 1 0 0 MM!'JJq$(" Hr<c [U5H-n[XX$US9n[R"U5(dM+Us $ [R"S5e)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;rrsI`5\ q\ J ??1  H   = >>r<cR^^^^[USSS9nTT-S-S:wa[R"S5eSTs=::aT:dO [R"S5e[R"TUS9nTS:XaU$SmUUUU4S jnU"5nUc U"5nUcM UR U5 U$) aReturns 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#cjU(dgUH%nUHnX#:Xa MX#:aX2p2X#4U;dM g M' g)NTF)rXpotential_edgess1s2s r; _suitable'random_regular_graph.._suitableIsD!B%8785(&"r<c>[5n[[T 55T -nU(a[S5nT R U5 [ U5n[ X35HDupEXE:aXTpTXE:waXE4U;aURXE45 M,X$==S- ss'X%==S- ss'MF T "X5(dgUR5VVVs/sHupg[U5HnUPM M nnnnU(aMU$s snnnf)Ncg)Nrririr<r;=random_regular_graph.._try_creation..cs!r<r) setrMrArshuffleiterr`additems) rXstubsrjstubiterrkrlnode potential_rmdr4r*s r; _try_creation+random_regular_graph.._try_creation\sU1X"))4O LL E{Hh178"!6IIrh'#'1,'#'1,'2U44(7'<'<'>'>ODy)A)'> !e* s!C7)rr,rUr r_)r}r4r*r$r6r~rXrms``` @r;rr sb&lUuUL A{a344 :A:LMM q|4AAv&@ OE - -U Hr<c[5n[U5U:a3URU5nURU5 [U5U:aM3U$)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. )rsrWrNrv)seqrGrngrbxs r;_random_subsetrsDeG g,  JJsO A g,  Nr<cx[USSS9nUS:dX:a[R"SUSU35eUc [X5nOK[ U5U:d[ U5U:a[R"SUSUS35eUR 5nUR 5VVVs/sHup[U5HopPM M nnnn[ U5n U W:a][XU5n UR[U /U-U 55 URU 5 URU /U-5 U S- n X:aM]U$s snnnf) uReturns 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 = u1Barabási–Albert initial graph needs between m=z and n= nodes) rr,rUr rWcopyrYrArr_r`extend) r4rGr* initial_graphr$r6r}r|repeated_nodessourcerbs r;rrsFR&lUuUL1uI!FSTRU V   q ' }  !S%7!%;""CA3gaSPVW     %&HHJAJDAa1aaJNA VF 1*!D9 fX\734g&vhl+!  * HBs! D5c[USSS9nUS:dX:a[R"SUSU35eUS:dX :a[R"SUSU35eUS:dUS:a[R"SU35eUS:Xa [XXFS 9$US:Xa [XXFS 9$Uc[ [ X5U5nO][ U5[ X5:d[ U5U:a&[R"S [ X5S US 35eUR5n[U5nUR5VV V s/sHup [U 5HoPM M n n nn [ U5n U W:avUR5U:aUn OUn [XU5nUR[U /U -U55 U RU5 U RU /U -5 U S- n X:aMvU$s sn n nf) 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#uABarabási–Albert initial graph must have between max(m1, m2) = z and n = r)rr,rUrr maxrWrrMrYrAr1rr_r`r)r4m1m2r5r*rr$r6rbr}r|rrrGs r;rrs`&lUuUL AvI"VTUSV W   AvI"VTUSV W   1uAI! M   Av$QDLL a$QDLL s2{L 1 } B +s=/AA/E""!!$R YqcA     1gG$%HHJAJDAa1aaJNA VF 1* ;;=1 AA!D9 fX\734g&vhl+! ! *" H)Bs4 G!cL[USSS9nUS:dX:aSUSU3n[R"U5eX#-S:aSUSU3n[R"U5e[X5n/nUR [ U55 Un X:GaUR 5n [U5S- n [U5U -S- n X:Ga9UR5X- ::Ga"UR5V Vs/sHupX:dM U PM nn n[ U5HnURU5n[UU5nURU5 URUV s/sH oU;dM U PM sn 5nURUU5 URU5 URU5 URU5U :XaURU5 URU5U :XdMUU;dMURU5 M GOX*s=::a X#-:GaO GOXR5s=::aU :GaO GOUR5V Vs/sHupS Us=:aU :dMO MU PM nn n[ U5GH;nURU5n[UU5nURU5nURU5 URUV s/sH oU;dM U PM sn 5nURUU5 URUU5 URU5 URU5 URU5S :XaUU;aURU5 UU;a,URU5U :XaURU5 GMGMURU5S:XdGM*URU5 GM> OY[!XU5nUR#[%U /U-U55 UR U5 UR U /US--5 U S- n X:aGMU$s snn fs sn fs snn fs sn f) uReturns 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 mQb NR1X;;~6$(( #4  ''1 KK"7V"7BEU;UR"7V  8Y/&,,X6%,,Y788H%6"))(388I&-7IU >Ub>Ub NV1X{{>2!4M  ;;y1  & KK"7O"7BY;NR"7O  dH- 4+&,,X6%,,Y788H%*x>/I"))(3.xx *m;&--i8<xx *a/&--i8CL%%:tDG  S(a9 : " ( ( 1 ! ( ((q1u)= > MHo ,p H]SW(WPs6) P8P P P =PPP P! P! cn[USSS9nUS:dX:a[R"SUSU35eUS:dUS:a[R"SU35e[X5n[ U5nUnXp:Ga:[ XaU5nUR 5n URXy5 URU 5 Sn X:aUR5U:aURU 5V s/sH$n URX{5(aMX:wdM"U PM& n n U (a:URU 5n URX{5 URU 5 U S-n MUR 5n URXy5 URU 5 U S-n X:aMURU/U-5 US- nXp:aGM:U$s sn f)urHolme 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`. 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*# UH oS:v M g7f)rNri).0r5s r; 'random_lobster_graph..os $8a68sz6Probability values for `p1` and `p2` must both be < 1.rg?r) rabsanyr,rUr2r1r rAr3) r4p1p2r*r$llenL current_nodecat_nodes r;rrKsD&lUuUL Wc"g $B8 $$$WXX q4;;= 1$s* +D4&A!8L 4[kkmb A L JJq '#H++-"$!  82++-"$ kkmb  Hr<cJSSKnURS[SS9 [XX#US9$)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;rrs2 MMM# r< PPr<c [USSS9n[SU5n/n/nSnUHupxn [X-5n URX- 5 [R "[ XzXRS9US9n URU 5 Xg- n[RRX;5nM [[U5S- 5Hn [XL5n [XLS-5nX\nSnUU:dM.URU 5nURU5nUU:XdURUU5(aMIURUU5 US-nUU:aM`M U$)aReturns 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;rrsE8&lUuULA|$A EK Fa!%j 1?+  . . Q$[[ Q   Q  LL  q $CJN#eieFm$!o  ;& F#A F#AAvAq)) 1a '!^ ;& $ Hr<cF[USSS9n[XX#S9n[XT5nU$)aReturns 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*rf)rrr )r4rr*rfr$rr6s r;rrs.D&lUuUL 'T OCS/A Hr<)r!c 6[RRXUS9nUVs/sH"n[U[ [ U5S55PM$ nn[RRX1US9nUVs/sH"n[U[ [ U5S55PM$ nnUHVn[RR U5upU (aUs $URSUS- 5n UR5Xj'MX [R"SUS35es snfs snf)aReturns 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*rrzExceeded max (z%) attempts for a valid tree sequence.) r,utilspowerlaw_sequenceminrroundis_valid_tree_degree_sequencerandintrrU) r4rr*rfzszseqswapr|validindexs r;rrs@ ""14"@A./ 0aC3uQx# $aD 0 ""5t"DA./ 0aC3uQx# $aD 0 8899$? K QA&hhj    DE  1 1s )D0)Dc^^ [USSS9nUc SSKm UU 4Sjn[R"US9nUR [ U55 SupgX`:a[ R"SUR5- 5*nT"X`- Xp- S5U::a US-US-pvO<[ R"X"X`- Xp- U5-5nURUS- US- 5 X`:aMU$) 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 FrENrcV>^^^UUUU4SjnTRRUTS5$)Nc>T"TTU5T- $Nri)bakernel_integralrys r; my_function=random_kernel_graph..kernel_root..my_functionys&q!Q/!33r<r)optimizebrentq)rrrrrsps``` r; kernel_root(random_kernel_graph..kernel_rootxs( 4 4;;%%k1a8 8r<r#)rrr) rscipyr,r add_nodes_fromrAr/r0r1ceilr3) r4rrr*r$graphr]r[rrs ` @r;r r 2sD&lUuUL 9 NN 5E q" FQ % XXa$++-' ( ( 15!% +q 0q5!a%q !k!%::;A NN1q5!a% ( % Lr<)NFr)dN)NN)rSNr))__doc__r>r/ collectionsrnetworkxr,networkx.utilsr utils.miscrclassicrr r r degree_seqr __all__ _dispatchabler rrrrrrrrrrrrrrrrrrrr rir<r;rs(  #*+HH, 0T2L 4L 3L ^T2; d; 3; ~"$T2<D<3<~T24 d4 34 nT2F DF 3F RT2K TK 3K \T23?RV3?33?lT2s $s 3s l T2G tG 3G TT2+/d AEd 3d NT2a $a 3a HT2X tX 3X vT22 t2 32 jT2QQ3Q"T2: t: 3: zT2$ 4$ 3$ N00fT2/3TEIT3Tr<