hFSrSSKJr SSKrSSKJr SSKJr SSK J r SS/r SS jr \R"S S 9SS j5r\"S 5\"S5\R"S S 9SSj555rg)z8Functions for detecting communities based on modularity.) defaultdictN) modularity)not_implemented_for) MappedQueuegreedy_modularity_communities#naive_greedy_modularity_communitiesc# # UR5nUR5nURU5nSU- nU(aMURUS9VVs0sH upxXxU-_M n nnUR US9VV s0sH upzXzU-_M n nn O+UR US9VV s0sH up|X|U-S-_M sn n=p[ S5n URUSS9H+upnX:XaM XU==U- ss'XU==U- ss'M- U R5HAunnUR5H'unnUU-X)UX-XX---- XU'M) MC UVVVs0sH7o[XR5VVs0sH unnX4U*_M snn5_M9 nnnn[UVs/sH)n[UU5S:dMUURSPM+ sn5nUVs0sHnU[U/5_M nnUR5v [U5S:GakUR5unpU*nUv UUR5 [UU5S:a!UR!UURS5 UURSX4:Xa[UR#X45 UUR#X45 [UU5S:a!UR!UURS5 OUUR#X45 [UUUU-5UU'UU [%X5n[%X5nUU-X1- nUU-nUGH(nUU;aXUXU-nOGUU;a!XUX)UU U-U UX---- nO XUX)UU U-U UX---- nUU4UU44HunnUUn UU UU'[U 5S:aU RSn!OSn!UU4n"U*n#UU;aU R'U"U"U#S9 OU R!U"U#S9 U!cUR!U"U#S9 MxU RSn$U!U$:wdU!R(U$R(:wdMUR'U!U$5 M GM+ XHnU UUn%U UU UU:wdMUU4UU44HunnUUn UU4n&U RSU&:XaSU R#U&5 UR#U&5 [U 5S:a UR!U RS5 MsMuU R#U&5 M M X [5UU'X==X- ss'SX'U(aX==X- ss'SX'UR5v [U5S:aGMjggs snnfs sn nfs sn nfs snnfs snnnfs snfs snf![a gf=f7f) a4Yield community partitions of G and the modularity change at each step. This function performs Clauset-Newman-Moore greedy modularity maximization [2]_ At each step of the process it yields the change in modularity that will occur in the next step followed by yielding the new community partition after that step. Greedy modularity maximization begins with each node in its own community and repeatedly joins the pair of communities that lead to the largest modularity until one community contains all nodes (the partition has one set). This function maximizes the generalized modularity, where `resolution` is the resolution parameter, often expressed as $\gamma$. See :func:`~networkx.algorithms.community.quality.modularity`. Parameters ---------- G : NetworkX graph weight : string or None, optional (default=None) The name of an edge attribute that holds the numerical value used as a weight. If None, then each edge has weight 1. The degree is the sum of the edge weights adjacent to the node. resolution : float (default=1) If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. Yields ------ Alternating yield statements produce the following two objects: communities: dict_values A dict_values of frozensets of nodes, one for each community. This represents a partition of the nodes of the graph into communities. The first yield is the partition with each node in its own community. dq: float The change in modularity when merging the next two communities that leads to the largest modularity. See Also -------- modularity References ---------- .. [1] Newman, M. E. J. "Networks: An Introduction", page 224 Oxford University Press 2011. .. [2] Clauset, A., Newman, M. E., & Moore, C. "Finding community structure in very large networks." Physical Review E 70(6), 2004. .. [3] Reichardt and Bornholdt "Statistical Mechanics of Community Detection" Phys. Rev. E74, 2006. .. [4] Newman, M. E. J."Analysis of weighted networks" Physical Review E 70(5 Pt 2):056131, 2004. )weightg?c [[5$)N)rfloat^/var/www/html/env/lib/python3.13/site-packages/networkx/algorithms/community/modularity_max.py:_greedy_modularity_communities_generator..[s +e"4r)datadefaultrN)priority) is_directednumber_of_nodessize out_degree in_degreedegreeredgesitemsrlenheap frozensetvaluespop IndexErrorpushremovesetupdater)'Gr resolutiondirectedNmq0nodedeg_outadeg_inbdegdq_dictuvwtnbrdictdqdq_heapnH communitiesnegdqu_nbrsv_nbrsall_nbrs both_nbrswdq_vwrowcol dq_heap_rowd_oldmaxdd_negdqrow_maxdq_oldd_olds' r(_greedy_modularity_communities_generatorrNsr}}H A vA QB 56\\\5P Q5PMDTR< 5P Q34;;f;3M N3M<4TB; 3M N78xxvx7NO7N)$Rx#~%7NOO45GGGG3b 6  1   1  4mmo 7]]_EArGjaD14K!$+4M&NNGJqM%& WXXVWQR+ 8H8H8JK8Juq"vs{8JKLLVWGXJAc'!*o6I'WQZ__Q'JKA/00a1in$aK0     a&1* %%'KE1V  wqz?Q  FF71:??1% & 1:??1 ! ' HHaV  AJ  qf %71:"wqzq)* AJ  qf %#;q>KN#BC A NWZWZVOv-VO AI~ 1  1 5f 1 dQqTkAaD14K6O(PP 1 dQqTkAaD14K6O(PPVaV,S%cl $) S!{#a'*//2H#H#J &;&&q!g&> $$Q$9#FF1wF/*..q1G7*h.?.?7CSCS.S737-NAQZ]F 1 Av"#Q!Q 0HC")#,K #JE"''*e3#**51{+a/FF;#3#3A#670$**51!1, J ]     DADLDAD  ""[ a&1**= R NO$LXJ1   sAWV #W8V WV3B+W V#>V V# W)V*V* W$V/;$W V43H&W4WC1W WV##W4 W>WWWr ) edge_attrsc<UR5(dUVs/sHoU1PM sn$US:dX0R5:a[S[U5SUS35eUb]US:dX@R5:a[S[U5SUS35eXC:a[SUSU35eUS:Xa [ U5/$OUR5n[ XUS9n[ U5n[U5U:a>[ U5nUS :a[U5U::aO[ U5n[U5U:aM>[U[S S 9$s snf![aN [U[S S 9n[U5U:a+Utpn X- /nURU 5 [U5U:aM+Us$f=f) a, Find communities in G using greedy modularity maximization. This function uses Clauset-Newman-Moore greedy modularity maximization [2]_ to find the community partition with the largest modularity. Greedy modularity maximization begins with each node in its own community and repeatedly joins the pair of communities that lead to the largest modularity until no further increase in modularity is possible (a maximum). Two keyword arguments adjust the stopping condition. `cutoff` is a lower limit on the number of communities so you can stop the process before reaching a maximum (used to save computation time). `best_n` is an upper limit on the number of communities so you can make the process continue until at most n communities remain even if the maximum modularity occurs for more. To obtain exactly n communities, set both `cutoff` and `best_n` to n. This function maximizes the generalized modularity, where `resolution` is the resolution parameter, often expressed as $\gamma$. See :func:`~networkx.algorithms.community.quality.modularity`. Parameters ---------- G : NetworkX graph weight : string or None, optional (default=None) The name of an edge attribute that holds the numerical value used as a weight. If None, then each edge has weight 1. The degree is the sum of the edge weights adjacent to the node. resolution : float, optional (default=1) If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. cutoff : int, optional (default=1) A minimum number of communities below which the merging process stops. The process stops at this number of communities even if modularity is not maximized. The goal is to let the user stop the process early. The process stops before the cutoff if it finds a maximum of modularity. best_n : int or None, optional (default=None) A maximum number of communities above which the merging process will not stop. This forces community merging to continue after modularity starts to decrease until `best_n` communities remain. If ``None``, don't force it to continue beyond a maximum. Raises ------ ValueError : If the `cutoff` or `best_n` value is not in the range ``[1, G.number_of_nodes()]``, or if `best_n` < `cutoff`. Returns ------- communities: list A list of frozensets of nodes, one for each community. Sorted by length with largest communities first. Examples -------- >>> G = nx.karate_club_graph() >>> c = nx.community.greedy_modularity_communities(G) >>> sorted(c[0]) [8, 14, 15, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33] See Also -------- modularity References ---------- .. [1] Newman, M. E. J. "Networks: An Introduction", page 224 Oxford University Press 2011. .. [2] Clauset, A., Newman, M. E., & Moore, C. "Finding community structure in very large networks." Physical Review E 70(6), 2004. .. [3] Reichardt and Bornholdt "Statistical Mechanics of Community Detection" Phys. Rev. E74, 2006. .. [4] Newman, M. E. J."Analysis of weighted networks" Physical Review E 70(5 Pt 2):056131, 2004. r zcutoff must be between 1 and z. Got .zbest_n must be between 1 and z Must have best_n >= cutoff. Got z < )r r)Tkeyreverser) rr ValueErrorrr&rNnext StopIterationsortedextend) r(r r)cutoffbest_nr; community_genr=r9comm1comm2rests rrrsl 6688QQ !2!2!448QvhaPQQ  QJF%6%6%882 EAFFFr* multigraphc UR5Vs/sHn[U/5PM nn/nSn[XXS9nUbXv:GaUn[U5nSn [ U5Hup[ U5HupX::d[ U5S:Xd[ U 5S:XaM*X<-X'[/5X'[XXS9n X:a<X:a U nXXv- 4n O.U (a'[ X5[ U SU S5:aU nXXv- 4n X8U 'XU 'M M U b0URU 5 U upnXJXKpX<-XK'[/5XJ'UcMXv:aGM[SU5[ SS9$s snf)aFind communities in G using greedy modularity maximization. This implementation is O(n^4), much slower than alternatives, but it is provided as an easy-to-understand reference implementation. Greedy modularity maximization begins with each node in its own community and joins the pair of communities that most increases modularity until no such pair exists. This function maximizes the generalized modularity, where `resolution` is the resolution parameter, often expressed as $\gamma$. See :func:`~networkx.algorithms.community.quality.modularity`. Parameters ---------- G : NetworkX graph Graph must be simple and undirected. resolution : float (default=1) If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. weight : string or None, optional (default=None) The name of an edge attribute that holds the numerical value used as a weight. If None, then each edge has weight 1. The degree is the sum of the edge weights adjacent to the node. Returns ------- list A list of sets of nodes, one for each community. Sorted by length with largest communities first. Examples -------- >>> G = nx.karate_club_graph() >>> c = nx.community.naive_greedy_modularity_communities(G) >>> sorted(c[0]) [8, 14, 15, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33] See Also -------- greedy_modularity_communities modularity N)r)r rr c3H# UHn[U5S:dMUv M g7f)rN)r).0cs r 6naive_greedy_modularity_communities..s8kSVaZ11ks" "TrR) nodesr rlist enumeraterminappendrX)r(r)r r5r=mergesold_modularitynew_modularitytrial_communitiesto_mergeijr6trial_modularityr9s rrresd,-77959a9aS>9K5 FN:UN  N$C' -k*DA!+.6SVq[CFaK'(u!$'0}!$#-Z$ $5'8)9$%.*I#J!c!i#hqk8A;2O&O)9$%.*I#J'(!$'(!$-/+0   MM( #HA">;>qUKN&r]KNI  N$CL 8k8c4 PPY6sE)Nr )Nr r N)r N)__doc__ collectionsrnetworkxnx%networkx.algorithms.community.qualityrnetworkx.utilsrnetworkx.utils.mapped_queuer__all__rN _dispatchablerrrrrr}s>#<.3$)  O#dX&   6'6DZ \"X&[Q'#![Qr