9i/SrSSKrSSKJr SSKJr SSKr/SQrSr \RRS5\RRS5\R"S S 9SS j555r\RRS5\RRS 5S55r\RRS 5SS S.Sj5rg)zOFunctions for splitting a network into two communities (finding a bipartition).N)deepcopy)count)kernighan_lin_bisectionspectral_modularity_bipartitiongreedy_node_swap_bipartitionc#P^^^ # [RR5[RR54=up#m TR5HWupE[ U4SjUR555nTU(aUR XF5 MEUR XF*5 MY U UU4SjnSnSn U(aaU(aYUR 5upFU"U5 UR 5upU"U 5 XU -- n US- nXXJ44v U(a U(aMWgggg7f)z This is a modified form of Kernighan-Lin, which moves single nodes at a time, alternating between sides to keep the bisection balanced. We keep two min-heaps of swap costs to make optimal-next-move selection fast. c3F># UHupTU(aUOU*v M g7fN).0vwtsides j/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/networkx/algorithms/community/bipartitions.py '_kernighan_lin_sweep..s F47R+!c>T UnTUR5HEup#T UnXA:XaU*nTUnX%;dMURU5SU--nURX&SS9 MG g)NT)allow_increase)itemsgetinsert) node side_nodenbrrside_nbrheap_nbrcost_nbr cost_heaps edge_infors r_update_heap_values1_kernighan_lin_sweep.._update_heap_valuessqJ  ,,.GCCyH$S!(+H#<<,q2v5dC/rN)nxutils BinaryHeaprsumrpop) r!rheap0heap1unbrscost_ur"itotcostr cost_vr s `` @r_kernighan_lin_sweepr3s !# 3 3 5rxx7J7J7L LLLE:??$FFF 7 LL # LLG $ % D AG EIIK AIIK AF?" Q1&   EE%E%s DD&"D&directedweight) edge_attrs cV^[U5nUc(URU5 [U5S-nUSUXVSpOAUupx[ RRXU/5(d[ R "S5eUV s0sHoX;_M n n [T5(aTn O"UR5(aU4Sjn OU4Sjn URR5V VVVs0sH:upXR5VVs0sHunnU "XU5=ncMUU_M snn_M< nnnn n[U5HIn[[UU 55n[U5unnnUS:a OUSUHu nupSX'SX'M MK U R5V Vs1sHun nUS:XdMU iM nn nU R5V Vs1sHun nUS:XdMU iM nn nUU4$![[4an [ R "S5U eSn A ff=fs sn fs snnfs snnnn fs snn fs snn f) u Partition a graph into two blocks using the Kernighan–Lin algorithm. This algorithm partitions a network into two sets by iteratively swapping pairs of nodes to reduce the edge cut between the two sets. The pairs are chosen according to a modified form of Kernighan-Lin [1]_, which moves nodes individually, alternating between sides to keep the bisection balanced. Kernighan-Lin is an approximate algorithm for maximal modularity bisection. In [2]_ they suggest that fine-tuned improvements can be made using greedy node swapping, (see `greedy_node_swap_bipartition`). The improvements are typically only a few percent of the modularity value. But they claim that can make a difference between a good and excellent method. This function does not perform any improvements. But you can do that yourself. Parameters ---------- G : NetworkX graph Graph must be undirected. partition : tuple Pair of iterables containing an initial partition. If not specified, a random balanced partition is used. max_iter : int Maximum number of times to attempt swaps to find an improvement before giving up. weight : string or function (default: "weight") If this is a string, then edge weights will be accessed via the edge attribute with this key (that is, the weight of the edge joining `u` to `v` will be ``G.edges[u, v][weight]``). If no such edge attribute exists, the weight of the edge is assumed to be one. If this is a function, the weight of an edge is the value returned by the function. The function must accept exactly three positional arguments: the two endpoints of an edge and the dictionary of edge attributes for that edge. The function must return a number or None to indicate a hidden edge. seed : integer, random_state, or None (default) Indicator of random number generation state. See :ref:`Randomness`. Only used if partition is None Returns ------- partition : tuple A pair of sets of nodes representing the bipartition. Raises ------ NetworkXError If `partition` is not a valid partition of the nodes of the graph. References ---------- .. [1] Kernighan, B. W.; Lin, Shen (1970). "An efficient heuristic procedure for partitioning graphs." *Bell Systems Technical Journal* 49: 291--307. Oxford University Press 2011. .. [2] M. E. J. Newman, "Modularity and community structure in networks", PNAS, 103 (23), p. 8577-8582, https://doi.org/10.1073/pnas.0601602103 Nrzpartition must be two setszpartition invalidcJ>[U4SjUR555$)Nc3F># UHoRTS5v M g7f)r%Nr)r ddr6s rr...s(PZr):):Zr)r)valuesr-r dr6s r)kernighan_lin_bisection..sS(PQXXZ(P%Pr$c(>URTS5$)Nr%r<r@s rrBrCsQUU61%5r$rr%)listshufflelen TypeError ValueErrorr& NetworkXError community is_partitioncallable is_multigraph_adjrranger3min)G partitionmax_iterr6seednodesmidABerrrr sum_weightr-r.r rArr!r0costsmin_costmin_i_spart1part2s ` rrr7sP GE U%jAoTc{E$K1 JDA||((F33""#67 7*/ 0%$49 %D 0   P 5 vv||~%GA jjl VldaZa5H/HrEArEl VV% 8_))T:; Z% q= !&5MLAq&1DGDG* ::< 2<41a16Q>> G = nx.karate_club_graph() >>> MrHi, Officer = nx.community.spectral_modularity_bipartition(G) >>> MrHi, Officer = sorted([sorted(MrHi), sorted(Officer)]) >>> MrHi [0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 16, 17, 19, 21] >>> Officer [8, 9, 14, 15, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33] References ---------- .. [1] M. E. J. Newman *Networks: An Introduction*, pages 373--378 Oxford University Press 2011. .. [2] M. E. J. Newman, "Modularity and community structure in networks", PNAS, 103 (23), p. 8577-8582, https://doi.org/10.1073/pnas.0601602103 rN) numpyr&linalgmodularity_matrixeigargsortziprealsetadd) rRnprY eigenvalues eigenvectorsindexv2leftrightr-ns rrrsd ##A&A " a 0K JJ{ #B 'E RWW\!U(+ ,a 0B%% q5 HHQK IIaL  ;r$) init_splitrTc^"Ucb[U5S-n[U5U- n[[R"[ U5U55nUVs1sH ofU;dM UiM nnXW4nOj[ R RX5(d[ R"S5e[U5S:Xd[ R"S5e[U5n[ R RX5n XpSn UR5n [UR5m"X:GaXX:GaRU nU n [U 5nU n[U5nU(GaSnSnSnUunn[U"4SjU55n[U"4SjU55nUHnUU;a UUnnUUnnOUUnnUUnn[XR5U-5*U - n[XR5U-5U - nT"UnUSU S--- UU- U- -nUU-U-n U U:dMU nUnUnUn!M UR!U5 W!R#U5 UU- nX:a [U5UpUR!U5 U(aGMU S - n X:aX:aGMRU$s snf) aSplit the nodes into two communities based on greedy modularity maximization. The algorithm works by selecting a node to change communities which will maximize the modularity. The swap is made and the community structure with the highest modularity is kept. Parameters ---------- G : NetworkX graph init_split : 2-tuple of sets of nodes Pair of sets of nodes in ``G`` providing an initial bipartition for the algorithm. If not specified, a random balanced partition is used. If this pair of sets is not a partition of the nodes of `G`, :exc:`NetworkXException` is raised. max_iter : int Maximum number of iterations of attempting swaps to find an improvement. Returns ------- max_split : 2-tuple of sets of nodes Pair of sets of nodes of ``G``, partitioned according to a node swap greedy modularity maximization algorithm. Raises ------ NetworkXError if init_split is not a valid partition of the graph into two communities or if G is a MultiGraph Examples -------- >>> G = nx.barbell_graph(3, 0) >>> left, right = nx.community.greedy_node_swap_bipartition(G) >>> # Sort the communities so the nodes appear in increasing order. >>> left, right = sorted([sorted(left), sorted(right)]) >>> sorted(left) [0, 1, 2] >>> sorted(right) [3, 4, 5] Notes ----- This function is not implemented for multigraphs. References ---------- .. [1] M. E. J. Newman "Networks: An Introduction", pages 373--375. Oxford University Press 2011. Nrz"init_split is not a partition of Gz init_split must be a bipartitionrrec3.># UH nTUv M g7fr r r rvG_degrees rr/greedy_node_swap_bipartition..Ds2T Tc3.># UH nTUv M g7fr r rzs rrr|Es4e!er}r%)rGrmrandomsamplerEr&rKrLrJr modularitynumber_of_edgesdictdegreer)keysremovern)#rRrwrTm1m2 some_nodesrv other_nodesbest_split_so_farbest_mod max_splitmax_moditsm next_splitnext_modrVmax_swapmax_node max_node_commrtruleftdrightdin_commout_commin_degout_degd_eiid_ejjdegd_sum_ai swap_changenon_max_node_commr{s# @rrrsn Vq[ Vb[tAw34 "#;!Q ':q! ;'5||((77""#GH H:!#""#EF F$Z0||&&qrsU  $!Nj)!X&p'*pfj)l+<,*<~l+26s,sr$