
    0Ph@              
           d Z ddlZddlmZ ddlmZ ddlmZm	Z	m
Z
  e
dd	g e	eddd
          g e	eddd
          dgdd          ddd            Z	 	 ddZdS )zGraph utilities and algorithms.    N)sparse   )pairwise_distances   )IntegralIntervalvalidate_paramsz
array-likezsparse matrixleft)closed)graphsourcecutoffT)prefer_skip_nested_validation)r   c                .   t          j        |           r|                                 } nt          j        |           } i }d}|g}|rN|}t	                      }|D ]+}||vr%|||<   |                    | j        |                    ,|||k    rn|dz  }|N|S )aD  Return the length of the shortest path from source to all reachable nodes.

    Parameters
    ----------
    graph : {array-like, sparse matrix} of shape (n_nodes, n_nodes)
        Adjacency matrix of the graph. Sparse matrix of format LIL is
        preferred.

    source : int
       Start node for path.

    cutoff : int, default=None
        Depth to stop the search - only paths of length <= cutoff are returned.

    Returns
    -------
    paths : dict
        Reachable end nodes mapped to length of path from source,
        i.e. `{end: path_length}`.

    Examples
    --------
    >>> from sklearn.utils.graph import single_source_shortest_path_length
    >>> import numpy as np
    >>> graph = np.array([[ 0, 1, 0, 0],
    ...                   [ 1, 0, 1, 0],
    ...                   [ 0, 1, 0, 0],
    ...                   [ 0, 0, 0, 0]])
    >>> single_source_shortest_path_length(graph, 0)
    {0: 0, 1: 1, 2: 2}
    >>> graph = np.ones((6, 6))
    >>> sorted(single_source_shortest_path_length(graph, 2).items())
    [(0, 1), (1, 1), (2, 0), (3, 1), (4, 1), (5, 1)]
    r   Nr   )r   issparsetolil
lil_matrixsetupdaterows)r   r   r   seenlevel
next_level
this_levelvs           S/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/utils/graph.py"single_source_shortest_path_lengthr      s    V u )!%((DEJ
 	
UU
 	1 	1A}}Q!!%*Q-000&E//
  	 K    distance	euclideanc                    |dk    r#t          j        |           rt          d          t          |          D ]4}t	          j        ||k              }| |         }	t          |          D ] }
t	          j        ||
k              }| |         }|dk    r| t	          j        ||                   }nt          |	|fd|i|}t	          j        |	                    d          |j
                  \  }}|dk    r'd|||         ||         f<   d|||         ||         f<   |dk    r7|||f         |||         ||         f<   |||f         |||         ||         f<   t          d	|z            6|S )
a  Add connections to sparse graph to connect unconnected components.

    For each pair of unconnected components, compute all pairwise distances
    from one component to the other, and add a connection on the closest pair
    of samples. This is a hacky way to get a graph with a single connected
    component, which is necessary for example to compute a shortest path
    between all pairs of samples in the graph.

    Parameters
    ----------
    X : array of shape (n_samples, n_features) or (n_samples, n_samples)
        Features to compute the pairwise distances. If `metric =
        "precomputed"`, X is the matrix of pairwise distances.

    graph : sparse matrix of shape (n_samples, n_samples)
        Graph of connection between samples.

    n_connected_components : int
        Number of connected components, as computed by
        `scipy.sparse.csgraph.connected_components`.

    component_labels : array of shape (n_samples)
        Labels of connected components, as computed by
        `scipy.sparse.csgraph.connected_components`.

    mode : {'connectivity', 'distance'}, default='distance'
        Type of graph matrix: 'connectivity' corresponds to the connectivity
        matrix with ones and zeros, and 'distance' corresponds to the distances
        between neighbors according to the given metric.

    metric : str
        Metric used in `sklearn.metrics.pairwise.pairwise_distances`.

    kwargs : kwargs
        Keyword arguments passed to
        `sklearn.metrics.pairwise.pairwise_distances`.

    Returns
    -------
    graph : sparse matrix of shape (n_samples, n_samples)
        Graph of connection between samples, with a single connected component.
    precomputedz_fix_connected_components with metric='precomputed' requires the full distance matrix in X, and does not work with a sparse neighbors graph.metricN)axisconnectivityr   r   z?Unknown mode=%r, should be one of ['connectivity', 'distance'].)r   r   RuntimeErrorrangenpflatnonzeroix_r   unravel_indexargminshape
ValueError)Xr   n_connected_componentscomponent_labelsmoder#   kwargsiidx_iXijidx_jXjDiijjs                   r   _fix_connected_componentsr=   O   s   f 6?1#5#5
 
 	
 )**  /1455uXq 	 	AN#3q#899E5B&&bfUE**+&r2GGfGGG%ahhDh&9&917CCFB~%%./eBir*+./eBir*++##./BieBir*+./BieBir*++ U  #	, Lr   )r   r    )__doc__numpyr(   scipyr   metrics.pairwiser   _param_validationr   r   r	   r   r=    r   r   <module>rD      s   % %
           1 1 1 1 1 1 B B B B B B B B B B 08Haf===>8Haf===tD 
 #'   AE 4 4 4 4 4x 
S S S S S Sr   