
    fi                         d Z ddlZddlmZ dgZ ed           ej        d          dd                        Zd	 Zd
 Z	dS )z'Distance measures approximated metrics.    N)py_random_statediameter   approximate_diameter)namec                     | st          j        d          |                                 dk    rdS |                                 rt	          | |          S t          | |          S )uu	  Returns a lower bound on the diameter of the graph G.

    The function computes a lower bound on the diameter (i.e., the maximum eccentricity)
    of a directed or undirected graph G. The procedure used varies depending on the graph
    being directed or not.

    If G is an `undirected` graph, then the function uses the `2-sweep` algorithm [1]_.
    The main idea is to pick the farthest node from a random node and return its eccentricity.

    Otherwise, if G is a `directed` graph, the function uses the `2-dSweep` algorithm [2]_,
    The procedure starts by selecting a random source node $s$ from which it performs a
    forward and a backward BFS. Let $a_1$ and $a_2$ be the farthest nodes in the forward and
    backward cases, respectively. Then, it computes the backward eccentricity of $a_1$ using
    a backward BFS and the forward eccentricity of $a_2$ using a forward BFS.
    Finally, it returns the best lower bound between the two.

    In both cases, the time complexity is linear with respect to the size of G.

    Parameters
    ----------
    G : NetworkX graph

    seed : integer, random_state, or None (default)
        Indicator of random number generation state.
        See :ref:`Randomness<randomness>`.

    Returns
    -------
    d : integer
       Lower Bound on the Diameter of G

    Examples
    --------
    >>> G = nx.path_graph(10)  # undirected graph
    >>> nx.diameter(G)
    9
    >>> G = nx.cycle_graph(3, create_using=nx.DiGraph)  # directed graph
    >>> nx.diameter(G)
    2

    Raises
    ------
    NetworkXError
        If the graph is empty or
        If the graph is undirected and not connected or
        If the graph is directed and not strongly connected.

    See Also
    --------
    networkx.algorithms.distance_measures.diameter

    References
    ----------
    .. [1] Magnien, Clémence, Matthieu Latapy, and Michel Habib.
       *Fast computation of empirically tight bounds for the diameter of massive graphs.*
       Journal of Experimental Algorithmics (JEA), 2009.
       https://arxiv.org/pdf/0904.2728.pdf
    .. [2] Crescenzi, Pierluigi, Roberto Grossi, Leonardo Lanzi, and Andrea Marino.
       *On computing the diameter of real-world directed (weighted) graphs.*
       International Symposium on Experimental Algorithms. Springer, Berlin, Heidelberg, 2012.
       https://courses.cs.ut.ee/MTAT.03.238/2014_fall/uploads/Main/diameter.pdf
    z"Expected non-empty NetworkX graph!r   r   )nxNetworkXErrornumber_of_nodesis_directed_two_sweep_directed_two_sweep_undirected)Gseeds     /var/www/development/aibuddy-work/election-extract/venv/lib/python3.11/site-packages/networkx/algorithms/approximation/distance_measures.pyr   r   	   sl    D  ECDDDaq}} ,"1d+++ D)))    c                    |                     t          |                     }t          j        | |          }t	          |          t	          |           k    rt          j        d          |^ }}t          j        | |          S )aL  Helper function for finding a lower bound on the diameter
        for undirected Graphs.

        The idea is to pick the farthest node from a random node
        and return its eccentricity.

        ``G`` is a NetworkX undirected graph.

    .. note::

        ``seed`` is a random.Random or numpy.random.RandomState instance
    zGraph not connected.)choicelistr	   shortest_path_lengthlenr
   eccentricity)r   r   source	distances_nodes         r   r   r   W   sq     [[a!!F'622I
9~~Q5666HQ?1d###r   c                    |                                  }|                    t          |                     }t          j        | |          }t          j        ||          }t          |           }t          |          |k    st          |          |k    rt          j        d          |^ }}|^ }}	t          t          j        ||          t          j        | |	                    S )a   Helper function for finding a lower bound on the diameter
        for directed Graphs.

        It implements 2-dSweep, the directed version of the 2-sweep algorithm.
        The algorithm follows the following steps.
        1. Select a source node $s$ at random.
        2. Perform a forward BFS from $s$ to select a node $a_1$ at the maximum
        distance from the source, and compute $LB_1$, the backward eccentricity of $a_1$.
        3. Perform a backward BFS from $s$ to select a node $a_2$ at the maximum
        distance from the source, and compute $LB_2$, the forward eccentricity of $a_2$.
        4. Return the maximum between $LB_1$ and $LB_2$.

        ``G`` is a NetworkX directed graph.

    .. note::

        ``seed`` is a random.Random or numpy.random.RandomState instance
    zDiGraph not strongly connected.)	reverser   r   r	   r   r   r
   maxr   )
r   r   
G_reversedr   forward_distancesbackward_distancesnr   a_1a_2s
             r   r   r   q   s    ( J[[a!!F/6::0VDD 	AA
""c*<&=&=&B&B@AAAGQ GQrz3//C1H1HIIIr   )N)
__doc__networkxr	   networkx.utils.decoratorsr   __all___dispatchabler   r   r    r   r   <module>r,      s    - -     5 5 5 5 5 5, -...I* I* I* /. I*X$ $ $4%J %J %J %J %Jr   