~iOPSrSSKrSSKrSSKJr SSKrSSKJrJ r /SQr \R"SSS9\"SS/5SS j55r \ "S 5\R"S SSS 9SS j55r \R"SSSS 9SSj5r\R"SSS9SSj5r\R"SSS9SSj5r\ "S 5\R"SSS9SSj55r\ "S 5\R"SSS9SSj55r\ "S 5\R"SSS9SSj55rSrg)z0 Generators and functions for bipartite graphs. N)reduce)nodes_or_numberpy_random_state)configuration_modelhavel_hakimi_graphreverse_havel_hakimi_graphalternating_havel_hakimi_graphpreferential_attachment_graph random_graphgnmk_random_graphcomplete_bipartite_graphT)graphs returns_graphc^[R"SU5nUR5(a[R"S5eUupUunm[ U[ R 5(a4[ U[ R 5(aTVs/sHoPU-PM snmURUSS9 URTSS9 [U5[U5[T5-:wa[R"S5eURU4SjU55 S[U5S[T5S 3URS 'U$s snf) aReturns the complete bipartite graph `K_{n_1,n_2}`. The graph is composed of two partitions with nodes 0 to (n1 - 1) in the first and nodes n1 to (n1 + n2 - 1) in the second. Each node in the first is connected to each node in the second. Parameters ---------- n1, n2 : integer or iterable container of nodes If integers, nodes are from `range(n1)` and `range(n1, n1 + n2)`. If a container, the elements are the nodes. create_using : NetworkX graph instance, (default: nx.Graph) Return graph of this type. Notes ----- Nodes are the integers 0 to `n1 + n2 - 1` unless either n1 or n2 are containers of nodes. If only one of n1 or n2 are integers, that integer is replaced by `range` of that integer. The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.complete_bipartite_graph rDirected Graph not supported bipartiterz,Inputs n1 and n2 must contain distinct nodesc3>># UHnTHo!U4v M M g7fN).0uvbottoms e/home/mande/repo/quber/.venv/lib/python3.13/site-packages/networkx/algorithms/bipartite/generators.py +complete_bipartite_graph..As9S&QV&VSszcomplete_bipartite_graph(z, )name) nx empty_graph is_directed NetworkXError isinstancenumbersIntegraladd_nodes_fromlenadd_edges_fromgraph)n1n2 create_usingGtopirs @rr r s: q,'A}}=>>GBJB"g&&''Jr7;K;K,L,L"()&Qq&&)SA&Vq) 1vSCK''MNN9S991#c(2c&k]!LAGGFO H*sD?bipartite_configuration_model)r rrcb^ ^[R"SU[RS9nUR5(a[R"S5e[ U5n[ U5n[ U5n[ U5nXx:Xd[R"SUSU35e[XEU5n[ U5S:Xd[U5S:XaU$[U5V s/sH o/X -PM n n U V V s/sH oHoPM M sn n m [XUU-5V s/sH o/XU- -PM n n U V V s/sH oHoPM M sn n mURT 5 URT5 URU U4Sj[U555 SUl U$s sn fs sn n fs sn fs sn n f)a{Returns a random bipartite graph from two given degree sequences. Parameters ---------- aseq : list Degree sequence for node set A. bseq : list Degree sequence for node set B. create_using : NetworkX graph instance, optional Return graph of this type. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. The graph is composed of two partitions. Set A has nodes 0 to (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1). Nodes from set A are connected to nodes in set B by choosing randomly from the possible free stubs, one in A and one in B. Notes ----- The sum of the two sequences must be equal: sum(aseq)=sum(bseq) If no graph type is specified use MultiGraph with parallel edges. If you want a graph with no parallel edges use create_using=Graph() but then the resulting degree sequences might not be exact. The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.configuration_model rdefaultr/invalid degree sequences, sum(aseq)!=sum(bseq),,c38># UHnTUTU/v M g7frr)rr1astubsbstubss rr&configuration_model..sA[fQi+[sr3) r!r" MultiGraphr#r$r)sum_add_nodes_with_bipartite_labelmaxrangeshuffler*r )aseqbseqr.seedr/lenalenbsumasumbrstubssubseqxr:r;s @@rrrFs}F q, >A}}=>> t9D t9D t9D t9D <=dV1TF K   (6A 4yA~Ta%*$K 0KqS47]KE 0# 4eFVaVae 4F+0d{+C D+CaS4D> !+CE D# 4eFVaVae 4F LLLLAU4[AA ,AF H 1 4 D 4sF0F F&3F+bipartite_havel_hakimi_graphcf[R"SU[RS9nUR5(a[R"S5e[ U5n[ U5n[ U5n[ U5nXg:Xd[R"SUSU35e[X4U5n[ U5S:Xd[U5S:XaU$[U5Vs/sH oUU/PM n n[XDU-5Vs/sH oX- U/PM n nU R5 U (a}U R5upU S:XaOdU R5 X*SHBn U SnURX5 U S==S-ss'U SS:XdM1U RU 5 MD U (aM}SUlU$s snfs snf) aEReturns a bipartite graph from two given degree sequences using a Havel-Hakimi style construction. The graph is composed of two partitions. Set A has nodes 0 to (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1). Nodes from the set A are connected to nodes in the set B by connecting the highest degree nodes in set A to the highest degree nodes in set B until all stubs are connected. Parameters ---------- aseq : list Degree sequence for node set A. bseq : list Degree sequence for node set B. create_using : NetworkX graph instance, optional Return graph of this type. Notes ----- The sum of the two sequences must be equal: sum(aseq)=sum(bseq) If no graph type is specified use MultiGraph with parallel edges. If you want a graph with no parallel edges use create_using=Graph() but then the resulting degree sequences might not be exact. The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.havel_hakimi_graph rr5rr7r8NrrMr!r"r=r#r$r)r>r?r@rAsortpopadd_edgeremover )rCrDr.r/naseqnbseqrHrIrr:r;degreertargets rrrsB q, >A}}=>> IE IE t9D t9D <=dV1TF K   (%8A 4yA~Ta%*%L 1LqAwlLF 1,1%,G H,GqAI",GF H KKM jjl  Q;  WX&Fq A JJq  1INIayA~ f% ' &,AF H#2 H F)8F.cf[R"SU[RS9nUR5(a[R"S5e[ U5n[ U5n[ U5n[ U5nXg:Xd[R"SUSU35e[X4U5n[ U5S:Xd[U5S:XaU$[U5Vs/sH oUU/PM n n[XDU-5Vs/sH oX- U/PM n nU R5 U R5 U (amU R5upU S:XaOTU SU HBn U SnURX5 U S==S-ss'U SS:XdM1U RU 5 MD U (aMmSUlU$s snfs snf)aHReturns a bipartite graph from two given degree sequences using a Havel-Hakimi style construction. The graph is composed of two partitions. Set A has nodes 0 to (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1). Nodes from set A are connected to nodes in the set B by connecting the highest degree nodes in set A to the lowest degree nodes in set B until all stubs are connected. Parameters ---------- aseq : list Degree sequence for node set A. bseq : list Degree sequence for node set B. create_using : NetworkX graph instance, optional Return graph of this type. Notes ----- The sum of the two sequences must be equal: sum(aseq)=sum(bseq) If no graph type is specified use MultiGraph with parallel edges. If you want a graph with no parallel edges use create_using=Graph() but then the resulting degree sequences might not be exact. The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.reverse_havel_hakimi_graph rr5rr7r8r$bipartite_reverse_havel_hakimi_graphrO)rCrDr.r/rFrGrHrIrr:r;rVrrWs rrrsB q, >A}}=>> t9D t9D t9D t9D <=dV1TF K   (6A 4yA~Ta%*$K 0KqAwlKF 0+0d{+C D+CaAH~q!+CF D KKM KKM jjl  Q; Qv&Fq A JJq  1INIayA~ f% ' &4AF H#1 DrXch[R"SU[RS9nUR5(a[R"S5e[ U5n[ U5n[ U5n[ U5nXg:Xd[R"SUSU35e[X4U5n[ U5S:Xd[U5S:XaU$[U5Vs/sH oUU/PM n n[XDU-5Vs/sH oX- U/PM n nU (GaU R5 U R5upU S:XaOU R5 U SU S-n X*U S--Sn[X5VVs/sHoHnUPM M nnn[ U5[ U 5[ U5-:aURUR55 UHBnUSnURX5 US==S-ss'USS:XdM1U RU5 MD U (aGMS UlU$s snfs snfs snnf) a{Returns a bipartite graph from two given degree sequences using an alternating Havel-Hakimi style construction. The graph is composed of two partitions. Set A has nodes 0 to (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1). Nodes from the set A are connected to nodes in the set B by connecting the highest degree nodes in set A to alternatively the highest and the lowest degree nodes in set B until all stubs are connected. Parameters ---------- aseq : list Degree sequence for node set A. bseq : list Degree sequence for node set B. create_using : NetworkX graph instance, optional Return graph of this type. Notes ----- The sum of the two sequences must be equal: sum(aseq)=sum(bseq) If no graph type is specified use MultiGraph with parallel edges. If you want a graph with no parallel edges use create_using=Graph() but then the resulting degree sequences might not be exact. The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.alternating_havel_hakimi_graph rr5rr7r8Nr(bipartite_alternating_havel_hakimi_graph)r!r"r=r#r$r)r>r?r@rArPrQzipappendrRrSr )rCrDr.r/rTrUrHrIrr:r;rVrsmalllargezrLrJrWs rr r #sD q, >A}}=>> IE IE t9D t9D <=dV1TF K   (%8A 4yA~Ta$)%L 1LqAwlLF 1,1%,G H,GqAI",GF H  jjl  Q;  q6Q;'&A+-01-9-qq!q-9 u:E SZ/ / LL %Fq A JJq  1INIayA~ f%  &$8AF H+2 H:sH$8H).H.c[R"SU[RS9nUR5(a[R"S5eUS:a[R"SUS35e[ U5n[ XES5n[U5Vs/sH of/X-PM nnU(GaUS(aUSSnUSRU5 UR5U:d[ U5U:Xa-[ U5n URU SS9 URX5 Ov[U[ U55V s/sHo/URU 5-PM n n [SU 5n URU 5n URU SS9 URX5 US(aMURUS5 U(aGMS UlU$s snfs sn f) aCreate a bipartite graph with a preferential attachment model from a given single degree sequence. The graph is composed of two partitions. Set A has nodes 0 to (len(aseq) - 1) and set B has nodes starting with node len(aseq). The number of nodes in set B is random. Parameters ---------- aseq : list Degree sequence for node set A. p : float Probability that a new bottom node is added. create_using : NetworkX graph instance, optional Return graph of this type. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. References ---------- .. [1] Guillaume, J.L. and Latapy, M., Bipartite graphs as models of complex networks. Physica A: Statistical Mechanics and its Applications, 2006, 371(2), pp.795-813. .. [2] Jean-Loup Guillaume and Matthieu Latapy, Bipartite structure of all complex networks, Inf. Process. Lett. 90, 2004, pg. 215-221 https://doi.org/10.1016/j.ipl.2004.03.007 Notes ----- The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.preferential_attachment_graph rr5rrz probability z > 1rc X-$rr)rLys r/preferential_attachment_graph..sae'bipartite_preferential_attachment_model)r!r"r=r#r$r)r?rArSrandomadd_noderRrVrchoicer ) rCpr.rEr/rTrvvsourcerWbbbbbstubss rr r qsR q, >A}}=>>1uaS566 IE'!4A!&u .A#-B . eU1XF qELL {{}q CFeOQ 6Q / 6*16uc!f1EF1EAcAHHQK'1EF !3R8W- 6Q / 6*ee "Q%! ""7AF H' /Gs G<Gc4[R"5n[XPU5nU(a[R"U5nSUSUSUS3UlUS::aU$US:a[R "X5$[ R"SU- 5nSnSnXp:ay[ R"SUR5- 5n US-[X- 5-nX:aXp:aX- nUS-nX:aXp:aMXp:aURXpU-5 Xp:aMyU(aSnSnXp:ay[ R"SUR5- 5n US-[X- 5-nX:aXp:aX- nUS-nX:aXp:aMXp:aURX-U5 Xp:aMyU$)uReturns a bipartite random graph. This is a bipartite version of the binomial (Erdős-Rényi) graph. The graph is composed of two partitions. Set A has nodes 0 to (n - 1) and set B has nodes n to (n + m - 1). Parameters ---------- n : int The number of nodes in the first bipartite set. m : int The number of nodes in the second bipartite set. 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 return a directed graph Notes ----- The bipartite random graph algorithm chooses each of the n*m (undirected) or 2*nm (directed) possible edges with probability p. This algorithm is $O(n+m)$ where $m$ is the expected number of edges. The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.random_graph See Also -------- gnp_random_graph, configuration_model References ---------- .. [1] Vladimir Batagelj and Ulrik Brandes, "Efficient generation of large random networks", Phys. Rev. E, 71, 036113, 2005. zfast_gnp_random_graph(r8rrrg?) r!Graphr?DiGraphr r mathlogrjintrR) nmrmrEdirectedr/lprwlrs rr r s\  A'a0A JJqM%aS!AaS 2AFAvAv**100 #' B A A % XXcDKKM) * ECL fAAAf 5 JJqa%  %  e# -.BABG $A&QUEE&QUu 15!$e HrhcD[R"5n[XPU5nU(a[R"U5nSUSUSUS3UlUS:XdUS:XaU$X-nX&:a[R "XUS9$UR SS9VVs/sHupUSS :XdMUPM nnn[[U5[U5- 5n S n X:aIURU5n URU 5n XU ;aM1URX5 U S- n X:aMIU$s snnf) aqReturns a random bipartite graph G_{n,m,k}. Produces a bipartite graph chosen randomly out of the set of all graphs with n top nodes, m bottom nodes, and k edges. The graph is composed of two sets of nodes. Set A has nodes 0 to (n - 1) and set B has nodes n to (n + m - 1). Parameters ---------- n : int The number of nodes in the first bipartite set. m : int The number of nodes in the second bipartite set. k : 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 Examples -------- >>> G = nx.bipartite.gnmk_random_graph(10, 20, 50) See Also -------- gnm_random_graph Notes ----- If k > m * n then a complete bipartite graph is returned. This graph is a bipartite version of the `G_{nm}` random graph model. The nodes are assigned the attribute 'bipartite' with the value 0 or 1 to indicate which bipartite set the node belongs to. This function is not imported in the main namespace. To use it use nx.bipartite.gnmk_random_graph zbipartite_gnm_random_graph(r8rr)r.T)datarr) r!rur?rvr r nodeslistsetrlrR) rzr{krEr|r/ max_edgesdr0r edge_countrrs rr r sX  A'a0A JJqM*1#Qqc1#Q 7AFAvaI~**1a@@d+ C+q~/B1+C C #a&3s8# $FJ . KK  KK  !9  JJq  !OJ . H Ds D!Dc UR[X-55 [[[U5S/U-55nUR [[[XU-5S/U-555 [ R "XS5 U$)Nrrr)r(rAdictr^updater!set_node_attributes)r/rFrGrps rr?r?VsnU4;'( StqcDj )*AHHT#eD+.d ; <=1- Hrhr)NN)NF)__doc__rwr& functoolsrnetworkxr!networkx.utilsrr__all__ _dispatchabler rrrr r r r r?rrhrrs ; T2!Q) 3) X6tSWXC YC L5dRVWG XG TT2F 3F RT2J 3J ZT2C 3C LT2R 3R jT2A 3A H rh