huNSrSSKrSSKrSSKJrJrJr SSKJr SSK r SSK J r J r /SQr\RrSrSSjr\ "S 5\ R&"SS S 9SS j55r\ "S 5\ R&"SS S 9SSj55r\ "S5\ R&"SS S 9SSj55r\ R&"SS S 9SSj5r\ R&"SS S 9SSj5r\ R&"SS S 9SSj5r\ "S5\ R&"SS S 9SSj55r"SS5rg)zIGenerate graphs with a given degree sequence or expected degree sequence.N)chain combinations zip_longest) itemgetter)py_random_staterandom_weighted_sample)configuration_modeldirected_configuration_modelexpected_degree_graphhavel_hakimi_graphdirected_havel_hakimi_graphdegree_sequence_treerandom_degree_sequence_graphcJ[[S[U5555$)a:Returns a list of degree-repeated node numbers. ``degree_sequence`` is a list of nonnegative integers representing the degrees of nodes in a graph. This function returns a list of node numbers with multiplicities according to the given degree sequence. For example, if the first element of ``degree_sequence`` is ``3``, then the first node number, ``0``, will appear at the head of the returned list three times. The node numbers are assumed to be the numbers zero through ``len(degree_sequence) - 1``. Examples -------- >>> degree_sequence = [1, 2, 3] >>> _to_stublist(degree_sequence) [0, 1, 1, 2, 2, 2] If a zero appears in the sequence, that means the node exists but has degree zero, so that number will be skipped in the returned list:: >>> degree_sequence = [2, 0, 1] >>> _to_stublist(degree_sequence) [0, 0, 2] c32# UH upU/U-v M g7fN).0nds P/var/www/html/env/lib/python3.13/site-packages/networkx/generators/degree_seq.py _to_stublist..5sF+E41sQw+Es)listchaini enumerate)degree_sequences r _to_stublistrs: F9_+EFF GGc[U5n[R"XQ5nUS:XaU$U(aM[XSS9n[ U6up[ U5n [ U 5n UR U 5 UR U 5 O4[ U5n [U 5nUS-n UR U 5 U SU XSpUR[ X55 U$)aHelper function for generating either undirected or directed configuration model graphs. ``deg_sequence`` is a list of nonnegative integers representing the degree of the node whose label is the index of the list element. ``create_using`` see :func:`~networkx.empty_graph`. ``directed`` and ``in_deg_sequence`` are required if you want the returned graph to be generated using the directed configuration model algorithm. If ``directed`` is ``False``, then ``deg_sequence`` is interpreted as the degree sequence of an undirected graph and ``in_deg_sequence`` is ignored. Otherwise, if ``directed`` is ``True``, then ``deg_sequence`` is interpreted as the out-degree sequence and ``in_deg_sequence`` as the in-degree sequence of a directed graph. .. note:: ``deg_sequence`` and ``in_deg_sequence`` need not be the same length. ``seed`` is a random.Random or numpy.random.RandomState instance This function returns a graph, directed if and only if ``directed`` is ``True``, generated according to the configuration model algorithm. For more information on the algorithm, see the :func:`configuration_model` or :func:`directed_configuration_model` functions. r) fillvalueN)lennx empty_graphrziprshuffleadd_edges_from) deg_sequence create_usingdirectedin_deg_sequenceseedrGpairsout_degin_deg out_stublist in_stubliststublisthalfs r_configuration_modelr68sD LA q'AAvLQGu+#G, "6*  \" [! - MAv X$,UdOXe_kS34 Hrr"T)graphs returns_graphc [U5S-S:waSn[R"U5e[R"SU[RS9nUR 5(a[R "S5e[XUS9nU$)ah Returns a random graph with the given degree sequence. The configuration model generates a random pseudograph (graph with parallel edges and self loops) by randomly assigning edges to match the given degree sequence. Parameters ---------- deg_sequence : list of nonnegative integers Each list entry corresponds to the degree of a node. create_using : NetworkX graph constructor, optional (default MultiGraph) Graph type to create. If graph instance, then cleared before populated. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Returns ------- G : MultiGraph A graph with the specified degree sequence. Nodes are labeled starting at 0 with an index corresponding to the position in deg_sequence. Raises ------ NetworkXError If the degree sequence does not have an even sum. See Also -------- is_graphical Notes ----- As described by Newman [1]_. A non-graphical degree sequence (not realizable by some simple graph) is allowed since this function returns graphs with self loops and parallel edges. An exception is raised if the degree sequence does not have an even sum. This configuration model construction process can lead to duplicate edges and loops. You can remove the self-loops and parallel edges (see below) which will likely result in a graph that doesn't have the exact degree sequence specified. The density of self-loops and parallel edges tends to decrease as the number of nodes increases. However, typically the number of self-loops will approach a Poisson distribution with a nonzero mean, and similarly for the number of parallel edges. Consider a node with *k* stubs. The probability of being joined to another stub of the same node is basically (*k* - *1*) / *N*, where *k* is the degree and *N* is the number of nodes. So the probability of a self-loop scales like *c* / *N* for some constant *c*. As *N* grows, this means we expect *c* self-loops. Similarly for parallel edges. References ---------- .. [1] M.E.J. Newman, "The structure and function of complex networks", SIAM REVIEW 45-2, pp 167-256, 2003. Examples -------- You can create a degree sequence following a particular distribution by using the one of the distribution functions in :mod:`~networkx.utils.random_sequence` (or one of your own). For example, to create an undirected multigraph on one hundred nodes with degree sequence chosen from the power law distribution: >>> sequence = nx.random_powerlaw_tree_sequence(100, tries=5000) >>> G = nx.configuration_model(sequence) >>> len(G) 100 >>> actual_degrees = [d for v, d in G.degree()] >>> actual_degrees == sequence True The returned graph is a multigraph, which may have parallel edges. To remove any parallel edges from the returned graph: >>> G = nx.Graph(G) Similarly, to remove self-loops: >>> G.remove_edges_from(nx.selfloop_edges(G)) r"r=Invalid degree sequence: sum of degrees must be even, not odddefaultz#not implemented for directed graphs)r-)sumr$ NetworkXErrorr% MultiGraph is_directedNetworkXNotImplementedr6)r)r*r-msgr.s rr r }sqt <1!Ms## q, >A}}''(MNN\48A Hrc[U5[U5:waSn[R"U5eUc[Rn[ UUSUUS9nSnU$)a Returns a directed_random graph with the given degree sequences. The configuration model generates a random directed pseudograph (graph with parallel edges and self loops) by randomly assigning edges to match the given degree sequences. Parameters ---------- in_degree_sequence : list of nonnegative integers Each list entry corresponds to the in-degree of a node. out_degree_sequence : list of nonnegative integers Each list entry corresponds to the out-degree of a node. create_using : NetworkX graph constructor, optional (default MultiDiGraph) Graph type to create. If graph instance, then cleared before populated. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Returns ------- G : MultiDiGraph A graph with the specified degree sequences. Nodes are labeled starting at 0 with an index corresponding to the position in deg_sequence. Raises ------ NetworkXError If the degree sequences do not have the same sum. See Also -------- configuration_model Notes ----- Algorithm as described by Newman [1]_. A non-graphical degree sequence (not realizable by some simple graph) is allowed since this function returns graphs with self loops and parallel edges. An exception is raised if the degree sequences does not have the same sum. This configuration model construction process can lead to duplicate edges and loops. You can remove the self-loops and parallel edges (see below) which will likely result in a graph that doesn't have the exact degree sequence specified. This "finite-size effect" decreases as the size of the graph increases. References ---------- .. [1] Newman, M. E. J. and Strogatz, S. H. and Watts, D. J. Random graphs with arbitrary degree distributions and their applications Phys. Rev. E, 64, 026118 (2001) Examples -------- One can modify the in- and out-degree sequences from an existing directed graph in order to create a new directed graph. For example, here we modify the directed path graph: >>> D = nx.DiGraph([(0, 1), (1, 2), (2, 3)]) >>> din = list(d for n, d in D.in_degree()) >>> dout = list(d for n, d in D.out_degree()) >>> din.append(1) >>> dout[0] = 2 >>> # We now expect an edge from node 0 to a new node, node 3. ... D = nx.directed_configuration_model(din, dout) The returned graph is a directed multigraph, which may have parallel edges. To remove any parallel edges from the returned graph: >>> D = nx.DiGraph(D) Similarly, to remove self-loops: >>> D.remove_edges_from(nx.selfloop_edges(D)) z8Invalid degree sequences: sequences must have equal sumsT)r+r,r-z.directed configuration_model {} nodes {} edges)r=r$r> MultiDiGraphr6)in_degree_sequenceout_degree_sequencer*r-rBr.names rr r sch #&9"::Hs## *   A `. Returns ------- Graph Examples -------- >>> z = [10 for i in range(100)] >>> G = nx.expected_degree_graph(z) Notes ----- The nodes have integer labels corresponding to index of expected degrees input sequence. The complexity of this algorithm is $\mathcal{O}(n+m)$ where $n$ is the number of nodes and $m$ is the expected number of edges. The model in [1]_ includes the possibility of self-loop edges. Set selfloops=False to produce a graph without self loops. For finite graphs this model doesn't produce exactly the given expected degree sequence. Instead the expected degrees are as follows. For the case without self loops (selfloops=False), .. math:: E[deg(u)] = \sum_{v \ne u} p_{uv} = w_u \left( 1 - \frac{w_u}{\sum_k w_k} \right) . NetworkX uses the standard convention that a self-loop edge counts 2 in the degree of a node, so with self loops (selfloops=True), .. math:: E[deg(u)] = \sum_{v \ne u} p_{uv} + 2 p_{uu} = w_u \left( 1 + \frac{w_u}{\sum_k w_k} \right) . References ---------- .. [1] Fan Chung and L. Lu, Connected components in random graphs with given expected degree sequences, Ann. Combinatorics, 6, pp. 125-145, 2002. .. [2] Joel Miller and Aric Hagberg, Efficient generation of networks with given expected degrees, in Algorithms and Models for the Web-Graph (WAW 2011), Alan Frieze, Paul Horn, and Paweł Prałat (Eds), LNCS 6732, pp. 115-126, 2011. rrIT)keyreverse)r#r$r%maxr=sortedrrrangeminrandommathfloorlogadd_edge)wr- selfloopsrr.rhoordercuvmappingseqlastfactorprqs rr r KsT AA qA AvQ1 c!f*C 9Qr#r%r@rOappendrMpoprU)r)r*rar.inum_degsdmaxdsumrrmodstubssourcemslenktargetstubval stubtargets rr r s P ??< ( (899 LA q'A}}BCC!!H%HqHH%MD  q5 K  q !L$(AED   Avx4!8$H a%(.!Q& AID(.!Q& a%<""#CD D##% Q tAhk"a'Qhk"a'[__&F JJv & FA1u#$q5&/ uA$,K !Wj   $ $Z 0 FA3 a%< HW&s Hc&[RRU5n[RRU5nSup4[U5[U5pe[ XV5n[R "Xr[R S9nUS:XaU$Sn //p[U5Hn SupX:aXnX:aX n U S:dUS:a[R"S5eX=-XN-[ X5pnU S:aU RSU-SU -U 45 MoUS:dMwU RSU-U 45 M X4:wa[R"S5e[R"U 5 [R"U 5 S/U S--nU (Ga[R"U 5unnnUS-nU[U 5[U 5-:a[R"S 5eSn[U5HnU (a5U (aU SSU SS:a[R"U 5unnSnO[R"U 5unnnUS:Xa[R"S 5eURUU5 US-S:dUS:dMUS-UU4UU'US- nM [U5HInUUnUSS:a[R"U U5 M*[R"U USUS 45 MK US:a[R"U UU45 U (aGMU$) aReturns a directed graph with the given degree sequences. Parameters ---------- in_deg_sequence : list of integers Each list entry corresponds to the in-degree of a node. out_deg_sequence : list of integers Each list entry corresponds to the out-degree of a node. create_using : NetworkX graph constructor, optional (default DiGraph) Graph type to create. If graph instance, then cleared before populated. Returns ------- G : DiGraph A graph with the specified degree sequences. Nodes are labeled starting at 0 with an index corresponding to the position in deg_sequence Raises ------ NetworkXError If the degree sequences are not digraphical. See Also -------- configuration_model Notes ----- Algorithm as described by Kleitman and Wang [1]_. References ---------- .. [1] D.J. Kleitman and D.L. Wang Algorithms for Constructing Graphs and Digraphs with Given Valences and Factors Discrete Mathematics, 6(1), pp. 79-88 (1973) rfr;rz;Invalid degree sequences. Sequence values must be positive.z9Invalid degree sequences. Sequences must have equal sums.rerIz Non-digraphical integer sequencer")r$utilsmake_list_of_intsr#rMr%DiGraphrOr>rhheapqheapifyheappoprUheappush)r,out_deg_sequencer*suminsumoutninnoutmaxnr.maxinstubheapzeroheaprr1r0rnfreeoutfreeinrrrprjstubout stubsourcestubinstubs rr r sNhh00AOxx112BCMEO$c*:&; s>D t2::>A qy ERh 4[ 8&)G 7$'F A:1""M  %~v/?UASu A: OOR'\2;: ; q[ OOR'\1- .  G   MM( MM({eai(H $)MM($;!&&"  CMCM1 1""#EF FvAXa[^hqk!n-L(- h(?%*05 h0G-&*!|&&'IJJ JJz6 *{Q&1*#*Q; "C uAA;DAw{x.x$q'47);<  Q; NN8gv%6 7? (B Hrc[U5nUS-S:waSn[R"U5e[U5US-- S:waSn[R"U5e[R"SU5nUR 5(a[R"S5e[ SU5SS 9n[U5S-n[R"U[U55 Un[SUS- 5H@nUR5S- n [XwU -5Hn URX5 M Xy- nMB [U5[U5:aURS5 U$) zMake a tree for the given degree sequence. A tree has #nodes-#edges=1 so the degree sequence must have len(deg_sequence)-sum(deg_sequence)/2=1 r"rr:rIzbInvalid degree sequence: tree must have number of nodes equal to one less than the number of edgeszDirected Graph not supportedc34# UHoS:dM Uv M g7f)rINr)rss rr'degree_sequence_tree..s3\U!!\s  T)rL) r=r$r>r#r%r@rNadd_pathrOrirU remove_node) r)r* degree_sumrBr.degrr_ronedgesrrs rrrs9\"JA~Ms## <:?*a/ 4 s## q,'A}}=>> 3\3T BC C1 AKK58 D1q5/QD-0F JJv &1  " 1vL!! a Hrc[X5n[U5HnUR5s $ [R "SUS35e![Ra MIf=f)aAReturns a simple random graph with the given degree sequence. If the maximum degree $d_m$ in the sequence is $O(m^{1/4})$ then the algorithm produces almost uniform random graphs in $O(m d_m)$ time where $m$ is the number of edges. Parameters ---------- sequence : list of integers Sequence of degrees seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. tries : int, optional Maximum number of tries to create a graph Returns ------- G : Graph A graph with the specified degree sequence. Nodes are labeled starting at 0 with an index corresponding to the position in the sequence. Raises ------ NetworkXUnfeasible If the degree sequence is not graphical. NetworkXError If a graph is not produced in specified number of tries See Also -------- is_graphical, configuration_model Notes ----- The generator algorithm [1]_ is not guaranteed to produce a graph. References ---------- .. [1] Moshen Bayati, Jeong Han Kim, and Amin Saberi, A sequential algorithm for generating random graphs. Algorithmica, Volume 58, Number 4, 860-910, DOI: 10.1007/s00453-009-9340-1 Examples -------- >>> sequence = [1, 2, 2, 3] >>> G = nx.random_degree_sequence_graph(sequence, seed=42) >>> sorted(d for n, d in G.degree()) [1, 2, 2, 3] zfailed to generate graph in z tries)DegreeSequenceRandomGraphrOgenerater$NetworkXUnfeasibler>)sequencer-triesDSRGtry_ns rrrsen %X 4Du ==? "  9%G HH$$   sA  A! A!cN\rSrSrSrSrS SjrSrSrSr S r S r S r S r g)ric0[R"U5(d[R"S5eX l[ U5Ul[ UR 5S- Ul[UR 5Ul g![a SUl gf=f)Nz degree sequence is not graphicalg@r) r$rgrrngrdegreer=mrMrl ValueError)selfrrs r__init__"DegreeSequenceRandomGraph.__init__ssv&&''(JK K6l T[[!C' DKK(DI DI s&BBBc[[UR55Ul[R "5UlUR RUR5 [URR55HupUS:XdM URU M [UR5S:a0UR5 UR5 UR5 UR $)Nr)dictrrremaining_degreer$Graphgraphadd_nodes_fromritemsr#phase1phase2phase3)rrrs rr"DegreeSequenceRandomGraph.generates $Yt{{%; <XXZ  !!$"7"78..4467DAAv))!,8 t$$ % ) KKM KKM KKMzzrNc^UbURX5 URUS:Xa"URU UbURU5 OURU==S-ss'URUS:Xa#URU UbURU5 ggURU==S-ss'g)NrI) remove_edgerr)rr[r\ aux_graphs rupdate_remaining*DegreeSequenceRandomGraph.update_remainings   ! !! '   #q (%%a($%%a(  ! !! $ ) $   #q (%%a($%%a(%  ! !! $ ) $rcfSURUURU-SUR-- - $)NrIg@)rr)rr[r\s rraDegreeSequenceRandomGraph.p&s/4;;q>DKKN2cDFFlCCCrc[URR55S-nURUURU-U- $Nr")rMrvalues)rr[r\norms rrcDegreeSequenceRandomGraph.q*sF4((//12a7$$Q'$*?*?*BBTIIrcr^^[TR5n[U5m[UU4SjU55$)zsReturns True if and only if an arbitrary remaining node can potentially be joined with some other remaining node. c3F># UHoTRT;v M g7fr)r)rr\rr[s rr:DegreeSequenceRandomGraph.suitable_edge..6s95aDJJqM)5s!)iterrnextany)rnodesr[s` @r suitable_edge'DegreeSequenceRandomGraph.suitable_edge/s/ T**+ K95999rcURn[UR55SURS--:a[ [ USUR 55up#URRX#5(aMqUR R5URX#5:a,URRX#5 URX#5 [UR55SURS--:aMggr) rr=rrlrNrrrhas_edgerQrarUr)rrem_degr[r\s rr DegreeSequenceRandomGraph.phase18s'''.."#q499a<'770!TXXFGDAzz""1((xx 466!</ ##A)%%a+ '.."#q499a<'77rcBURnURn[U5SUR-:a[ UR [ UR55S55up4URRX45(aMWUR5URX45:aOM|UR5URX45:a,URRX45 URX45 [U5SUR-:aMggr)rrr#rlrNsamplerkeysrrrQrcrarUr)r remaining_degrr[r\s rr DegreeSequenceRandomGraph.phase2Cs-- hh- A M1cjjm.@.@.B)CQGH::&&q,,::<$&&,.  zz|dffQl* ##A)%%a+- A M1rc [URS5n[R"UVVs/sH*up#URR X#5(aM'X#4PM, snn5nUR nUR(aUR5(d[R"S5e[UR[UR5555up#UR5URX#5:aOMYUR5URX#5:a+URR!X#5 UR#X#US9 UR(aMggs snnf)Nr"zno suitable edges left)r)rrr$rrrrrrrNchoiceredgesrQrcrarUr)rpotential_edgesr[r\Hrs rr DegreeSequenceRandomGraph.phase3Rs&t'<'rsO 66B    HBLPB JT2b 3b JT2EIb 3b JT2i 3i XT2Y 3Y xT2l 3l ^T2* 3* ZT2;I3;I|o9o9r