U 9v fe@sdZddlZddlmZdddddd d gZdd d Zdd dZdddZdddZ dddZ dddZ ddd Z ddZ edd dd ZdS)!z:Graph diameter, radius, eccentricity and other properties.N)not_implemented_for eccentricitydiameterradius peripherycenter barycenterresistance_distancecs t|}t||jd}t|}d}t|dt||t|}|d|d|r|rf|} n|} | }tj|| |d} t| |krd} t | t| } d}d}|D]~} | | }t| t|| || <}t | | || <}t | t| t | t| q|dkrVfdd |D}n|d krzfd d |D}nf|d krfd d |D}nB|dkr‡fdd |D}n|dkrt}n d} t | | fdd|D||8}|D]} |dksJ| |kr8|| ||ksJ| |krN| }|dks| |kr||| ||ks| |kr| }qqV|dkrS|d krS|d krևfdd|D}|S|dkrfdd|D}|S|dkrSdS)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.Nrcs,h|]$}|krd|kr|qS).0i ecc_lower ecc_uppermaxlowermaxupperrI/tmp/pip-unpacked-wheel-_lngutwb/networkx/algorithms/distance_measures.py s z$_extrema_bounding..rcs0h|](}|kr|ddkr|qSrrrrrminlowerminupperrrrs rcs0h|](}|krks(|kr|qSrrrrrrrs   rcs8h|]0}|krks0|ddkr|qSrrrrrrrs  ZeccentricitieszTcompute must be one of 'diameter', 'radius', 'periphery', 'center', 'eccentricities'c3s"|]}||kr|VqdS)Nrr)rrrr sz$_extrema_bounding..csg|]}|kr|qSrrrv)rrrr s z%_extrema_bounding..csg|]}|kr|qSrrr )rrrrr"s )dictZdegreemaxgetlenfromkeyssetnxshortest_path_length NetworkXErrorvaluesmin ValueErrorupdate)Gcomputer degreesZ minlowernodeNhigh candidatesZ maxuppernodecurrentdistmsgZ current_eccrdlowZuppZ ruled_outpcr)rrrrrrr_extrema_boundingsI                  r=c Cs|}i}||D]}|dkr>> 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 eccentrity of node 1 & 5 {1: 2, 5: 3} Nr zFormat 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) orderZ nbunch_iterr)r*r& TypeErrorr+ is_directedr$r,) r0r!spr r>enlengthLerrr8rrrrs*:   FcCsF|dkr&|dkr&|s&t|d|dS|dkr:t||d}t|S)awReturns 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 TNrr1r r r@r=rr$r,r0rB useboundsr rrrrFs 0 cs^|dkr&dkr&|s&t|d|dSdkr:t||dtfddD}|S)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 TNrrGrHcsg|]}|kr|qSrrr rrBrrr"s zperiphery..rIr0rBrKr r;rrLrr}s1  cCsF|dkr&|dkr&|s&t|d|dS|dkr:t||d}t|S)aDReturns 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 TNrrGrHr@r=rr-r,rJrrrrs - cs^|dkr&dkr&|s&t|d|dSdkr:t||dtfddD}|S)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 TNrrGrHcsg|]}|kr|qSrrr rBrrrr"!s zcenter..rNrMrrOrrs1  c Cs|dkrtj||d}n|}|dk r0tdtdgt|}}}|D]n\}}t||krrtd|dt|} |dk r| |j ||<| |kr| }|g}qL| |krL| |qL|S)aZCalculate 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 NrHz-Cannot use both sp, weight arguments togetherinfz Input graph zH is disconnected, so every induced subgraph has infinite barycentricity.) r)r*itemsr.floatr&ZNetworkXNoPathsumr,Znodesappend) r0r attrrAsmallestZbarycenter_verticesrCr!distsZbarycentricityrrrr%s(6     cCsTd}|}tt|D]6}|||kr|d7}||}||||<|||<q|S)z=Counts the number of permutations in SuperLU perm_c or perm_rrr)tolistranger&index)Z perm_arrayZperm_cntZarrrrCrrr_count_lu_permutationsss    r[ZdirectedTcCsddl}ddl}ddl}t|s2d}t|nF||krJd}t|n.||krbd}t|n||krxd}t||}t|} |r|dk r|r|j dddD]\} } } } d | || |<qn(|j dd D]\} } } d | || |<qtj || |d  d }tt |j d}|| |||ddfdd|f}|| |||ddfdd|f}|jjj|d did}|j}|||||j}|dt|j9}|dt|j9}||}||}|jjj|d did}|j}|||||j}|dt|j9}|dt|j9}||}||}||||d g|}|||}|S)avReturns the resistance distance between node A and node B on graph G. The resistance distance between two nodes of a graph is akin to treating the graph as a grid of resistorses with a resistance equal to the provided weight. If weight is not provided, then a weight of 1 is used for all edges. Parameters ---------- G : NetworkX graph A graph nodeA : node A node within graph G. nodeB : node A node within graph G, exclusive of Node A. 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 : float Value of effective resistance distance Examples -------- >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)]) >>> nx.resistance_distance(G, 1, 3) 0.625 Notes ----- Overviews are provided in [1]_ and [2]_. Additional details on computational methods, proofs of properties, and corresponding MATLAB codes are provided in [3]_. References ---------- .. [1] Wikipedia "Resistance distance." https://en.wikipedia.org/wiki/Resistance_distance .. [2] E. W. Weisstein "Resistance Distance." MathWorld--A Wolfram Web Resource https://mathworld.wolfram.com/ResistanceDistance.html .. [3] V. S. S. Vos, "Methods for determining the effective resistance." Mestrado, Mathematisch Instituut Universiteit Leiden, 2016 https://www.universiteitleiden.nl/binaries/content/assets/science/mi/scripties/master/vos_vaya_master.pdf rNz#Graph G must be strongly connected.zNode A is not in graph G.zNode B is not in graph G.z%Node A and Node B cannot be the same.T)keysdatar)r]rHZcscZ SymmetricMode)options)ZnumpyscipyZscipy.sparse.linalgr)Z is_connectedr+copylistZ is_multigraphedgesZlaplacian_matrixZasformatrYshaperemoverZsparseZlinalgZspluUZdiagonalproductsignrEr[Zperm_rZperm_cabsolutesortdividerT)r0ZnodeAZnodeBr Z invert_weightnprAr`r8Z node_listur!kr9rEindicesZL_aZL_abZlu_aZLdiagAZLdiagA_sZlu_abZLdiagABZ LdiagAB_sZLdetrdrrrr s\=               )rN)NNN)NFN)NFN)NFN)NFN)NNN)NT)__doc__Znetworkxr)Znetworkx.utilsr__all__r=rrrrrrr[r rrrrs*  ^ X 7 : 4 : N