hSrSSKrSSKrSSKJr /SQrSSjr\R"SS9SSj5r \R"SS9SS j5r \RSS j5r \R"SS9SS j5r \R"SS9SS j5r \R"SS9SS j5r\R"SSS0S9SSj5r\"S5\R"SS9SSj55r\"S5\R"SS9SSj55r\R$R S5\R"SS9SS.Sj55rg)z:Graph diameter, radius, eccentricity and other properties.N)not_implemented_for) eccentricitydiameterharmonic_diameterradius peripherycenter barycenterresistance_distancekemeny_constanteffective_graph_resistancec ^^[UR55n[X3RS9n[ U5nSn[R US5m[R X5m[ U5nUnSn Un Sn U(GagU(aW n OUn U(+n[R"X US9n[ U5U:waSn[R"U5e[UR55nSn SnUH|nUUn[TU[UUU- 55=TU'n[TUUU-5=TU'n[TUU5n[TUU 5n [TUU 5n [TUU 5n M~ US:Xa,UVs1sHnTUU ::dMSTU-U :dMUiM nnOUS :Xa/UVs1sH!nTUU :dMTUS -SU-::dMUiM# nnOUS :Xa.UVs1sH nTUU :dMX:Xd TUU :dMUiM" nnOXUS :Xa4UVs1sH&nTUU :dMX:XdTUS -SU-:dM$UiM( nnOUS :Xa [ 5nO Sn[U5eURUU4SjU55 UU-nUHUnUb#TUTU:Xa UUX4:d TUTU:aUnU b%TUTU :Xa UUX<:dTUTU :dMSUn MW U(aGMgUS:XaU $US :XaU $US :XaUVs/sHnTUU :XdMUPM nnU$US :XaUVs/sHnTUU :XdMUPM nnU$US :XaT$gs snfs snfs snfs snfs snfs snf)a Compute requested extreme distance metric of undirected graph G Computation is based on smart lower and upper bounds, and in practice linear in the number of nodes, rather than quadratic (except for some border cases such as complete graphs or circle shaped graphs). Parameters ---------- G : NetworkX graph An undirected graph compute : string denoting the requesting metric "diameter" for the maximal eccentricity value, "radius" for the minimal eccentricity value, "periphery" for the set of nodes with eccentricity equal to the diameter, "center" for the set of nodes with eccentricity equal to the radius, "eccentricities" for the maximum distance from each node to all other nodes in G weight : string, function, or None 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. If this is None, every edge has weight/distance/cost 1. Weights stored as floating point values can lead to small round-off errors in distances. Use integer weights to avoid this. Weights should be positive, since they are distances. Returns ------- value : value of the requested metric int for "diameter" and "radius" or list of nodes for "center" and "periphery" or dictionary of eccentricity values keyed by node for "eccentricities" Raises ------ NetworkXError If the graph consists of multiple components ValueError If `compute` is not one of "diameter", "radius", "periphery", "center", or "eccentricities". Notes ----- This algorithm was proposed in [1]_ and discussed further in [2]_ and [3]_. References ---------- .. [1] F. W. Takes, W. A. Kosters, "Determining the diameter of small world networks." Proceedings of the 20th ACM international conference on Information and knowledge management, 2011 https://dl.acm.org/doi/abs/10.1145/2063576.2063748 .. [2] F. W. Takes, W. A. Kosters, "Computing the Eccentricity Distribution of Large Graphs." Algorithms, 2013 https://www.mdpi.com/1999-4893/6/1/100 .. [3] M. Borassi, P. Crescenzi, M. Habib, W. A. Kosters, A. Marino, F. W. Takes, "Fast diameter and radius BFS-based computation in (weakly connected) real-world graphs: With an application to the six degrees of separation games. " Theoretical Computer Science, 2015 https://www.sciencedirect.com/science/article/pii/S0304397515001644 )keyFrsourceweightz5Cannot compute metric because graph is not connected.Nrrrr eccentricitieszTcompute must be one of 'diameter', 'radius', 'periphery', 'center', 'eccentricities'c3D># UHnTUTU:XdMUv M g7fN).0i ecc_lower ecc_uppers W/var/www/html/env/lib/python3.13/site-packages/networkx/algorithms/distance_measures.py $_extrema_bounding..s"OJq)A,)A,2NJs  )dictdegreemaxgetlenfromkeyssetnxshortest_path_length NetworkXErrorvaluesmin ValueErrorupdate)Gcomputerdegrees minlowernodeNhigh candidatesminlowermaxlowerminuppermaxupper maxuppernodecurrentdistmsg current_eccrdlowupp ruled_outvpcrrs @@r_extrema_boundingrEs6R188:GwKK0L G A D a#I a#IQJHHHH  "G"Gx&&qH t9>IC""3' '$++-(   AQA!$Yq\3q;?3L!M MIaL3!$Yq\;?!C CIaL39Q<2H9Q<2H9Q<2H9Q<2H j $#AQ<8+01IaL0@H0L# I  $#AQ<8+09! q0@AL0P# I  #$#AQ<(*)Yq\H-D# I  $#AQ<(*)Yq\A-=H -L# I ( (IhCS/ !OJOOi A$aLIl$;; W%::aL9\#:: $aLIl$;; W%::aL9\#:: 'k *h*(+ 61Yq\X5Q 6( 61Yq\X5Q 6"" q  | 7 7s`: M  M M , M= MM! M2 MM M&M<M M M ( M%9M%r) edge_attrscUR5n0nURU5HnUc![R"XUS9n[ U5nOX&n[ U5nX:wa0UR5(aSn OSn [R "U 5e[UR55XV'M X;aXQ$U$![ an [R "S5U eSn A ff=f)a Returns the eccentricity of nodes in G. The eccentricity of a node v is the maximum distance from v to all other nodes in G. Parameters ---------- G : NetworkX graph A graph v : node, optional Return value of specified node sp : dict of dicts, optional All pairs shortest path lengths as a dictionary of dictionaries weight : string, function, or None (default=None) 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. If this is None, every edge has weight/distance/cost 1. Weights stored as floating point values can lead to small round-off errors in distances. Use integer weights to avoid this. Weights should be positive, since they are distances. Returns ------- ecc : dictionary A dictionary of eccentricity values keyed by node. Examples -------- >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)]) >>> dict(nx.eccentricity(G)) {1: 2, 2: 3, 3: 2, 4: 2, 5: 3} >>> dict( ... nx.eccentricity(G, v=[1, 5]) ... ) # This returns the eccentricity of node 1 & 5 {1: 2, 5: 3} NrFormat of "sp" is invalid.zHFound infinite path length because the digraph is not strongly connectedz=Found infinite path length because the graph is not connected) order nbunch_iterr'r(r$ TypeErrorr) is_directedr"r*) r.rBsprrIenlengthLerrr<s rrrsz GGIE A ]]1  :,,QHFF A NK :}}* Y""3' '6==?#+. vt H! N&&'CD#M Ns B:: C CC cUSLa#Uc UR5(d [USUS9$Uc [XS9n[UR 55$)aReturns the diameter of the graph G. The diameter is the maximum eccentricity. Parameters ---------- G : NetworkX graph A graph e : eccentricity dictionary, optional A precomputed dictionary of eccentricities. weight : string, function, or None 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. If this is None, every edge has weight/distance/cost 1. Weights stored as floating point values can lead to small round-off errors in distances. Use integer weights to avoid this. Weights should be positive, since they are distances. Returns ------- d : integer Diameter of graph Examples -------- >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)]) >>> nx.diameter(G) 3 See Also -------- eccentricity Trr/rrrLrErr"r*r.rN useboundsrs rrrNsIbDQYq}} JvFFy  * qxxz?cUR5nSnUHTnUc[R"X5nOXn[U5nUR 5HnUS:wdM USU- - nM MV US:wa X"S- -U- $US:a[R$[R$![an[R "S5UeSnAff=f)ajReturns the harmonic diameter of the graph G. The harmonic diameter of a graph is the harmonic mean of the distances between all pairs of distinct vertices. Graphs that are not strongly connected have infinite diameter and mean distance, making such measures not useful. Restricting the diameter or mean distance to finite distances yields paradoxical values (e.g., a perfect match would have diameter one). The harmonic mean handles gracefully infinite distances (e.g., a perfect match has harmonic diameter equal to the number of vertices minus one), making it possible to assign a meaningful value to all graphs. Note that in [1] the harmonic diameter is called "connectivity length": however, "harmonic diameter" is a more standard name from the theory of metric spaces. The name "harmonic mean distance" is perhaps a more descriptive name, but is not used in the literature, so we use the name "harmonic diameter" here. Parameters ---------- G : NetworkX graph A graph sp : dict of dicts, optional All-pairs shortest path lengths as a dictionary of dictionaries Returns ------- hd : float Harmonic diameter of graph References ---------- .. [1] Massimo Marchiori and Vito Latora, "Harmony in the small-world". *Physica A: Statistical Mechanics and Its Applications* 285(3-4), pages 539-546, 2000. rNrHr) rIr'"single_source_shortest_path_lengthr$rKr)r*mathinfnan) r.rMrIsum_invdrOrPrQrRr>s rrrsP GGIEH  :::1@F NKAAvAE! ! 1} "X-- qyxx 88O N&&'CD#M NsB## C -CC cUSLa#Uc UR5(d [USUS9$Uc [XS9n[UR 55nUVs/sHoQUU:XdM UPM nnU$s snf)aReturns the periphery of the graph G. The periphery is the set of nodes with eccentricity equal to the diameter. Parameters ---------- G : NetworkX graph A graph e : eccentricity dictionary, optional A precomputed dictionary of eccentricities. weight : string, function, or None 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. If this is None, every edge has weight/distance/cost 1. Weights stored as floating point values can lead to small round-off errors in distances. Use integer weights to avoid this. Weights should be positive, since they are distances. Returns ------- p : list List of nodes in periphery Examples -------- >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)]) >>> nx.periphery(G) [2, 5] See Also -------- barycenter center TrrTrUrV)r.rNrXrrrBrCs rrrsodDQYq}} KGGy  *188:H*Aq1)AA* H +  A,"A,cUSLa#Uc UR5(d [USUS9$Uc [XS9n[UR 55$)aReturns the radius of the graph G. The radius is the minimum eccentricity. Parameters ---------- G : NetworkX graph A graph e : eccentricity dictionary, optional A precomputed dictionary of eccentricities. weight : string, function, or None 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. If this is None, every edge has weight/distance/cost 1. Weights stored as floating point values can lead to small round-off errors in distances. Use integer weights to avoid this. Weights should be positive, since they are distances. Returns ------- r : integer Radius of graph Examples -------- >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)]) >>> nx.radius(G) 2 TrrTrUrLrErr+r*rWs rrrsI\DQYq}} HVDDy  * qxxz?rYcUSLa#Uc UR5(d [USUS9$Uc [XS9n[UR 55nUVs/sHoQUU:XdM UPM nnU$s snf)aReturns the center of the graph G. The center is the set of nodes with eccentricity equal to radius. Parameters ---------- G : NetworkX graph A graph e : eccentricity dictionary, optional A precomputed dictionary of eccentricities. weight : string, function, or None 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. If this is None, every edge has weight/distance/cost 1. Weights stored as floating point values can lead to small round-off errors in distances. Use integer weights to avoid this. Weights should be positive, since they are distances. Returns ------- c : list List of nodes in center Examples -------- >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)]) >>> list(nx.center(G)) [1, 3, 4] See Also -------- barycenter periphery Tr rTrUrc)r.rNrXrrrBrCs rr r 8sndDQYq}} HVDDy  * _F(Aq1AA( H )raattrr)rF mutates_inputcUc[R"XS9nOUR5nUb [S5e[ S5/[ U5penUHupx[ U5U:a[R "SUS35e[UR55n UbXRUU'X:aU nU/nMgX:XdMnURU5 M Ub[R"U5 U$)aCalculate barycenter of a connected graph, optionally with edge weights. The :dfn:`barycenter` a :func:`connected ` graph :math:`G` is the subgraph induced by the set of its nodes :math:`v` minimizing the objective function .. math:: \sum_{u \in V(G)} d_G(u, v), where :math:`d_G` is the (possibly weighted) :func:`path length `. The barycenter is also called the :dfn:`median`. See [West01]_, p. 78. Parameters ---------- G : :class:`networkx.Graph` The connected graph :math:`G`. weight : :class:`str`, optional Passed through to :func:`~networkx.algorithms.shortest_paths.generic.shortest_path_length`. attr : :class:`str`, optional If given, write the value of the objective function to each node's `attr` attribute. Otherwise do not store the value. sp : dict of dicts, optional All pairs shortest path lengths as a dictionary of dictionaries Returns ------- list Nodes of `G` that induce the barycenter of `G`. Raises ------ NetworkXNoPath If `G` is disconnected. `G` may appear disconnected to :func:`barycenter` if `sp` is given but is missing shortest path lengths for any pairs. ValueError If `sp` and `weight` are both given. Examples -------- >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)]) >>> nx.barycenter(G) [1, 3, 4] See Also -------- center periphery rUz-Cannot use both sp, weight arguments togetherr]z Input graph zH is disconnected, so every induced subgraph has infinite barycentricity.) r'r(itemsr,floatr$NetworkXNoPathsumr*nodesappend _clear_cache) r.rrerMsmallestbarycenter_verticesrOrBdistsbarycentricitys rr r ssn z  $ $Q 6 XXZ  LM M',U|RQ1H u:>##qc"// U\\^,  -GGAJt   $%H#$#   '  & &q )   rYdirectedcSSKn[U5S:Xa[R"S5e[R"U5(d[R"S5eUbX;a[R"S5eUbX ;a[R"S5eUR 5n[ U5nU(a^Ub[UR5(a$URSSS9HupxpS X- X'M O"URSS 9Hupxn S X- X'M [R"XS 9R5n URRU SS 9n UblUbiURU5n URU5nU RX5U RX5-U RX5- U RX5- $UbxURU5n 0n UH]nURU5nU RX5U RX5-U RX5- U RX5- X'M_ U $UbxURU5n0n UH]nURU5n U RX5U RX5-U RX5- U RX5- X'M_ U $0n UH~nURU5n 0X'UH`nURU5nU RX5U RX5-U RX5- U RX5- XU'Mb M U $) aReturns the resistance distance between pairs of nodes in graph G. The resistance distance between two nodes of a graph is akin to treating the graph as a grid of resistors with a resistance equal to the provided weight [1]_, [2]_. If weight is not provided, then a weight of 1 is used for all edges. If two nodes are the same, the resistance distance is zero. Parameters ---------- G : NetworkX graph A graph nodeA : node or None, optional (default=None) A node within graph G. If None, compute resistance distance using all nodes as source nodes. nodeB : node or None, optional (default=None) A node within graph G. If None, compute resistance distance using all nodes as target nodes. weight : string or None, optional (default=None) The edge data key used to compute the resistance distance. If None, then each edge has weight 1. invert_weight : boolean (default=True) Proper calculation of resistance distance requires building the Laplacian matrix with the reciprocal of the weight. Not required if the weight is already inverted. Weight cannot be zero. Returns ------- rd : dict or float If `nodeA` and `nodeB` are given, resistance distance between `nodeA` and `nodeB`. If `nodeA` or `nodeB` is unspecified (the default), a dictionary of nodes with resistance distances as the value. Raises ------ NetworkXNotImplemented If `G` is a directed graph. NetworkXError If `G` is not connected, or contains no nodes, or `nodeA` is not in `G` or `nodeB` is not in `G`. Examples -------- >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)]) >>> round(nx.resistance_distance(G, 1, 3), 10) 0.625 Notes ----- The implementation is based on Theorem A in [2]_. Self-loops are ignored. Multi-edges are contracted in one edge with weight equal to the harmonic sum of the weights. References ---------- .. [1] Wikipedia "Resistance distance." https://en.wikipedia.org/wiki/Resistance_distance .. [2] D. J. Klein and M. Randic. Resistance distance. J. of Math. Chem. 12:81-95, 1993. rN'Graph G must contain at least one node.z#Graph G must be strongly connected.zNode A is not in graph G.zNode B is not in graph G.TkeysdatarrxrU) hermitian)numpyr$r'r) is_connectedcopylist is_multigraphedgeslaplacian_matrixtodenselinalgpinvindexitem)r.nodeAnodeBr invert_weightnp node_listurBkr>rQLinvrjrOn2s rr r sN 1v{HII ??1  DEE U^:;; U^:;; AQI+ ??  gg4dg; a M <777-a M . A-557A 99>>!t> ,D U. OOE " OOE "yy10499Q?BTYYq_TT   OOE " A"A99Q?TYYq_4tyyFSTXAD   OOE " A"A99Q?TYYq_4tyyFSTXAD A"AADOOB'IIaOiio&iio&iio&RrYc2SSKn[U5S:Xa[R"S5e[R"U5(d [ S5$UR 5nU(a^Ub[UR5(a$URSSS9HupEpgSXq- Xq'M O"URSS9HupEnSXq- Xq'M UR[R"XS 95n[ URSUSS- 5UR5-5$) aReturns the Effective graph resistance of G. Also known as the Kirchhoff index. The effective graph resistance is defined as the sum of the resistance distance of every node pair in G [1]_. If weight is not provided, then a weight of 1 is used for all edges. The effective graph resistance of a disconnected graph is infinite. Parameters ---------- G : NetworkX graph A graph weight : string or None, optional (default=None) The edge data key used to compute the effective graph resistance. If None, then each edge has weight 1. invert_weight : boolean (default=True) Proper calculation of resistance distance requires building the Laplacian matrix with the reciprocal of the weight. Not required if the weight is already inverted. Weight cannot be zero. Returns ------- RG : float The effective graph resistance of `G`. Raises ------ NetworkXNotImplemented If `G` is a directed graph. NetworkXError If `G` does not contain any nodes. Examples -------- >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)]) >>> round(nx.effective_graph_resistance(G), 10) 10.25 Notes ----- The implementation is based on Theorem 2.2 in [2]_. Self-loops are ignored. Multi-edges are contracted in one edge with weight equal to the harmonic sum of the weights. References ---------- .. [1] Wolfram "Kirchhoff Index." https://mathworld.wolfram.com/KirchhoffIndex.html .. [2] W. Ellens, F. M. Spieksma, P. Van Mieghem, A. Jamakovic, R. E. Kooij. Effective graph resistance. Lin. Alg. Appl. 435:2491-2506, 2011. rNrur]TrvrryrU) r{r$r'r)r|rir}rrsortlaplacian_spectrumrknumber_of_nodes) r.rrrrrBrr>mus rr r Msz 1v{HII ??1  U| A+ ??  gg4dg; a M <777-a M . &&q8 9B BqrF #a&7&7&99 ::rYrUc NSSKnSSKn[U5S:Xa[R"S5e[R "U5(d[R"S5e[R "XS9(a[R"S5e[R"XS9nURupVURSS9nURS S 9 S URU5- nSSS5 SWURU5'URRURRUSXeS S 95n XU --n UR!UR"R%U R'555n [)URSSU SS- - 55$!,(df  N=f)uReturns the Kemeny constant of the given graph. The *Kemeny constant* (or Kemeny's constant) of a graph `G` can be computed by regarding the graph as a Markov chain. The Kemeny constant is then the expected number of time steps to transition from a starting state i to a random destination state sampled from the Markov chain's stationary distribution. The Kemeny constant is independent of the chosen initial state [1]_. The Kemeny constant measures the time needed for spreading across a graph. Low values indicate a closely connected graph whereas high values indicate a spread-out graph. If weight is not provided, then a weight of 1 is used for all edges. Since `G` represents a Markov chain, the weights must be positive. Parameters ---------- G : NetworkX graph weight : string or None, optional (default=None) The edge data key used to compute the Kemeny constant. If None, then each edge has weight 1. Returns ------- float The Kemeny constant of the graph `G`. Raises ------ NetworkXNotImplemented If the graph `G` is directed. NetworkXError If the graph `G` is not connected, or contains no nodes, or has edges with negative weights. Examples -------- >>> G = nx.complete_graph(5) >>> round(nx.kemeny_constant(G), 10) 3.2 Notes ----- The implementation is based on equation (3.3) in [2]_. Self-loops are allowed and indicate a Markov chain where the state can remain the same. Multi-edges are contracted in one edge with weight equal to the sum of the weights. References ---------- .. [1] Wikipedia "Kemeny's constant." https://en.wikipedia.org/wiki/Kemeny%27s_constant .. [2] Lovász L. Random walks on graphs: A survey. Paul Erdös is Eighty, vol. 2, Bolyai Society, Mathematical Studies, Keszthely, Hungary (1993), pp. 1-46 rNruzGraph G must be connected.rUz+The weights of graph G must be nonnegative.r)axisignore)divideg?csr)format)r{scipyr$r'r)r|is_negatively_weightedadjacency_matrixshaperkerrstatesqrtisinfsparse csr_arrayspdiagsrreigvalshrri) r.rrrMArOmdiags diags_sqrtDHHeigs rr r sWB 1v{HII ??1  ;<<   2LMM A-A 77DA EEqEME H %2775>)  &'(Jrxx #$   RYY..z1a5.Q RB "f A ''"))$$QYY[1 2C QSb\*+ ,, & %s F F$)rN)NNN)NFNr)NNNT)NT)__doc__r\networkxr'networkx.utilsr__all__rE _dispatchablerrrrrr r r r utilsr rrYrrs@ . ZzX&W 'W tX&4'4n>>BX&7 '7 tX&1'1hX&7 '7 tXfa[AMBM`Z X&D'!DNZ X&S;'!S;lj)X&!%W-'*W-rY