h`"SrSSKrSSKJr /SQr\R "SS9S5rSSjr\"S5\R "SS S 9SS j55r \R "SS9S 5r S r Sr \"S5\R "SS S 9SSj55r g)zCGenerate graphs with a given joint degree and directed joint degreeN)py_random_state)is_valid_joint_degreeis_valid_directed_joint_degreejoint_degree_graphdirected_joint_degree_graph)graphsc0nUHDnUS:dM [XR55U- nUR5(d gX1U'MF UH~nXHsn[XU5R5(d gX$:waXUXX-:a gX$:XdMJXUXXS- -:a gXUS-S:wdMr g M g)aChecks whether the given joint degree dictionary is realizable. A *joint degree dictionary* is a dictionary of dictionaries, in which entry ``joint_degrees[k][l]`` is an integer representing the number of edges joining nodes of degree *k* with nodes of degree *l*. Such a dictionary is realizable as a simple graph if and only if the following conditions are satisfied. - each entry must be an integer, - the total number of nodes of degree *k*, computed by ``sum(joint_degrees[k].values()) / k``, must be an integer, - the total number of edges joining nodes of degree *k* with nodes of degree *l* cannot exceed the total number of possible edges, - each diagonal entry ``joint_degrees[k][k]`` must be even (this is a convention assumed by the :func:`joint_degree_graph` function). Parameters ---------- joint_degrees : dictionary of dictionary of integers A joint degree dictionary in which entry ``joint_degrees[k][l]`` is the number of edges joining nodes of degree *k* with nodes of degree *l*. Returns ------- bool Whether the given joint degree dictionary is realizable as a simple graph. References ---------- .. [1] M. Gjoka, M. Kurant, A. Markopoulou, "2.5K Graphs: from Sampling to Generation", IEEE Infocom, 2013. .. [2] I. Stanton, A. Pinar, "Constructing and sampling graphs with a prescribed joint degree distribution", Journal of Experimental Algorithmics, 2012. rFT)sumvalues is_integerfloat) joint_degrees degree_countkk_sizels V/var/www/html/env/lib/python3.13/site-packages/networkx/generators/joint_degree_seq.pyrrsRL  q5)0023a7F$$&&$O !A)!,-88::]-a0`. Returns ------- G : Graph A graph with the specified joint degree dictionary. Raises ------ NetworkXError If *joint_degrees* dictionary is not realizable. Notes ----- In each iteration of the "while loop" the algorithm picks two disconnected nodes *v* and *w*, of degree *k* and *l* correspondingly, for which ``joint_degrees[k][l]`` has not reached its target yet. It then adds edge (*v*, *w*) and increases the number of edges in graph G by one. The intelligence of the algorithm lies in the fact that it is always possible to add an edge between such disconnected nodes *v* and *w*, even if one or both nodes do not have free stubs. That is made possible by executing a "neighbor switch", an edge rewiring move that releases a free stub while keeping the joint degree of G the same. The algorithm continues for E (number of edges) iterations of the "while loop", at the which point all entries of the given ``joint_degrees[k][l]`` have reached their target values and the construction is complete. References ---------- .. [1] M. Gjoka, B. Tillman, A. Markopoulou, "Construction of Simple Graphs with a Target Joint Degree Matrix and Beyond", IEEE Infocom, '15 Examples -------- >>> joint_degrees = { ... 1: {4: 1}, ... 2: {2: 2, 3: 2, 4: 2}, ... 3: {2: 2, 4: 1}, ... 4: {1: 1, 2: 2, 3: 1}, ... } >>> G = nx.joint_degree_graph(joint_degrees) >>> z8Input joint degree dict not realizable as a simple graphrr )r!r )rnx NetworkXErroritemsr r empty_graphrangeint randrangehas_edger'rdiscard)rseedmsgrrrNrh_degree_nodelistr nodeiddegree num_nodesr% n_edges_addrl_sizek_nodesl_nodesk_unsatrl_unsats rrrsv ! / /Hs##9F8K8K8MW8MQRUVQV+As188:!++8MLW L   !"A qAOF)//1$)&92D$E!"*A!'A +#i.  2!A(*1-Kaaf%%,.+.'.Hg1Ca1G1gH6*1L'Q_Q5G!5Kq'GLG%G"/"21"5":K!Aov 67Av 67A::a++a*-2,Q7OL+1-2 v 0Aw P 0$%q'?!"  1a('*a/*'*a/*#q( *-2#OOA.*1-2#OOA.;"Aoo1"n H[XNIMs# I, !I,# I23I2 I7I7c^ ^ 0m 0n[U5[U5:wag[[U55H]nXnXnT RUS4S5S-T US4'T RUS4S5S-T US4'URXe4S5S-X6U4'M_ 0m UHnX'HnX'Un [U 5R 5(d gU S:dM3T RUS4S5U -T US4'T RUS4S5U -T US4'XRXx4S5-T US4T US4-:dM g M [ U U 4SjT 55$)aChecks whether the given directed joint degree input is realizable Parameters ---------- in_degrees : list of integers in degree sequence contains the in degrees of nodes. out_degrees : list of integers out degree sequence contains the out degrees of nodes. nkk : dictionary of dictionary of integers directed joint degree dictionary. for nodes of out degree k (first level of dict) and nodes of in degree l (second level of dict) describes the number of edges. Returns ------- boolean returns true if given input is realizable, else returns false. Notes ----- Here is the list of conditions that the inputs (in/out degree sequences, nkk) need to satisfy for simple directed graph realizability: - Condition 0: in_degrees and out_degrees have the same length - Condition 1: nkk[k][l] is integer for all k,l - Condition 2: sum(nkk[k])/k = number of nodes with partition id k, is an integer and matching degree sequence - Condition 3: number of edges and non-chords between k and l cannot exceed maximum possible number of edges References ---------- [1] B. Tillman, A. Markopoulou, C. T. Butts & M. Gjoka, "Construction of Directed 2K Graphs". In Proc. of KDD 2017. Frr c3F># UHnTUUS- TU:Hv M g7f)rN).0sSVs r 1is_valid_directed_joint_degree..as&.Aqqtad{ad"As!)lenr.getrrall) in_degrees out_degreesnkk forbiddenidxiorrvalrErFs @@rrr spL AI :#k**S_% O  EE1a&!$q(1a& EE1a&!$q(1a& %MM1&!4q8 a& & A A&)C:((**QwEE1a&!,s21a& EE1a&!,s21a& vq11Aq!fI1a& 4II  .A. ..rcUR5nURU5 [URU55n[URU55n UHn X;dM Xz:wdMUR X5 UR Xz5 XZU:Xa$URX45 UR Xz45 X1==S- ss'X7==S-ss'X7S:XaURU5 g U$)aReleases one free stub for node w, while preserving joint degree in G. Parameters ---------- G : networkx directed graph graph within which the edge swap will take place. w : integer node id for which we need to perform a neighbor switch. unsat: set of integers set of node ids that have the same degree as w and are unsaturated. h_node_residual_out: dict of integers for a given node, keeps track of the remaining stubs to be added. chords: set of tuples keeps track of available positions to add edges. h_partition_in: dict of integers for a given node, keeps track of its partition id (in degree). partition: integer partition id to check if chords have to be updated. Notes ----- First, it selects node w_prime that (1) has the same degree as w and (2) is unsaturated. Then, it selects node v, a neighbor of w, that is not connected to w_prime and does an edge swap i.e. removes (w,v) and adds (w_prime,v). If neighbor switch is not possible for w using w_prime and v, then return w_prime; in [1] it's proven that such unsaturated nodes can be used. References ---------- [1] B. Tillman, A. Markopoulou, C. T. Butts & M. Gjoka, "Construction of Directed 2K Graphs". In Proc. of KDD 2017. r rN)popaddlist successorsrrr2r) rrrh_node_residual_outchordsh_partition_in partitionr" w_neighbsr$r%s r_directed_neighbor_switchr^dsHiikG IIgQ\\!_%I1<<01O  $', MM!  JJw " I- A6"|,  "a ' "  (A - ("+q0 W%" NrcUR5nURU5 [URU55n[URU55n UHn X;dM Xz:wdMUR X5 UR X5 XZU:Xa$URX45 UR X45 X1==S- ss'X7==S-ss'X7S:XaURU5 g U$)a!The reverse of directed_neighbor_switch. Parameters ---------- G : networkx directed graph graph within which the edge swap will take place. w : integer node id for which we need to perform a neighbor switch. unsat: set of integers set of node ids that have the same degree as w and are unsaturated. h_node_residual_in: dict of integers for a given node, keeps track of the remaining stubs to be added. chords: set of tuples keeps track of available positions to add edges. h_partition_out: dict of integers for a given node, keeps track of its partition id (out degree). partition: integer partition id to check if chords have to be updated. Notes ----- Same operation as directed_neighbor_switch except it handles this operation for incoming edges instead of outgoing. r rN)rUrVrW predecessorsrrr2r) rrrh_node_residual_inrZh_partition_outr\r"r]r$r%s r_directed_neighbor_switch_revrcs6iikG IIgQ^^A&'I1>>'23O  $', MM!  JJq "!Y. A6"|,  !Q & !  '1 , '!*a/ W% Nrc [XU5(dSn[R"U5e[R"5n0n0n0n0n 0n 0n 0n 0n 0n[ U5Huunn[ U5nUS:dMUR U/5 UR U[55 UURU5 UURU5 UX'UX'Mw [ U5HunnXnURUX4S5S-UUX4'[ U5nUS:a\UR U/5 U R U[55 UURU5 U URU5 UX'UX'URU5 M 0n0nUHn[UU5UU'M UHn[UU5UU'M UGHnUUGHnUUUnUS:dM[5nUUnUUnUR[UU-5UURUU4S5-5nSn[U5U:aKUUUUU-nUUUUU-nUS- nUU:waURUU45 [U5U:aMKU UnUUnUS:dMUR5un n!URU U!45 U U S:Xa[!UU UU UU U5n"U"bU"n U U!S:Xa[#UU!UU UU U5n#U#bU#n!UR%U U!5 U U ==S-ss'U U!==S-ss'US-nUR'U U!45 U U S:XaUR'U 5 U U!S:XaUR'U!5 US:aMGM GM U$)aGenerates a random simple directed graph with the joint degree. Parameters ---------- degree_seq : list of tuples (of size 3) degree sequence contains tuples of nodes with node id, in degree and out degree. nkk : dictionary of dictionary of integers directed joint degree dictionary, for nodes of out degree k (first level of dict) and nodes of in degree l (second level of dict) describes the number of edges. seed : hashable object, optional Seed for random number generator. Returns ------- G : Graph A directed graph with the specified inputs. Raises ------ NetworkXError If degree_seq and nkk are not realizable as a simple directed graph. Notes ----- Similarly to the undirected version: In each iteration of the "while loop" the algorithm picks two disconnected nodes v and w, of degree k and l correspondingly, for which nkk[k][l] has not reached its target yet i.e. (for given k,l): n_edges_add < nkk[k][l]. It then adds edge (v,w) and always increases the number of edges in graph G by one. The intelligence of the algorithm lies in the fact that it is always possible to add an edge between disconnected nodes v and w, for which nkk[degree(v)][degree(w)] has not reached its target, even if one or both nodes do not have free stubs. If either node v or w does not have a free stub, we perform a "neighbor switch", an edge rewiring move that releases a free stub while keeping nkk the same. The difference for the directed version lies in the fact that neighbor switches might not be able to rewire, but in these cases unsaturated nodes can be reassigned to use instead, see [1] for detailed description and proofs. The algorithm continues for E (number of edges in the graph) iterations of the "while loop", at which point all entries of the given nkk[k][l] have reached their target values and the construction is complete. References ---------- [1] B. Tillman, A. Markopoulou, C. T. Butts & M. Gjoka, "Construction of Directed 2K Graphs". In Proc. of KDD 2017. Examples -------- >>> in_degrees = [0, 1, 1, 2] >>> out_degrees = [1, 1, 1, 1] >>> nkk = {1: {1: 2, 2: 2}} >>> G = nx.directed_joint_degree_graph(in_degrees, out_degrees, nkk) >>> z)Input is not realizable as a simple graphrr )rr*r+DiGraph enumerater/ setdefaultsetappendrVrJadd_noderIsampler.rUr^rcrr2)$rLrMrNr3r4rh_degree_nodelist_inh_degree_nodelist_outh_degree_nodelist_in_unsath_degree_nodelist_out_unsatrYrarbr[ non_chordsrPrQrRnk_innk_outprrr:rZk_lenl_len chords_samplenumjr>r?r%r_v_ws$ rrrsD **3 G G9s## A!#"$ONJJ'Q#h q5 + +Ar 2 & 1 1!SU ;  # * *3 / &q ) - -c 2&'  #"#N (K(Q  +5>>1jo:NPQ+RUV+V Az'(#h q5 ! , ,Q 3 ' 2 21ce < !! $ + +C 0 ' * . .s 3'(  $#$O  3) E F !+A./a" "-a01q # QAa&)KQq a $ %%-(+ 1vq8Q*Q! &kK/-a0s1Ce1KLA,Q/ c0Be0KLA1HCAv Aq6* &kK/6a84Q7!Ao!:: "A*!,1:#."+> "AJJq!$'*a/*&q)Q.)1$KNNAq6**1-2*)!,1*U"Aoo7N Hr)N)__doc__networkxr*networkx.utilsr__all__ _dispatchablerr'rrr^rcrrBrrrsI* ??D<~T2K 3K \@/@/F<~1hT2 3 r