o
    h                     @   sV   d Z ddlmZ ddlZddlmZ dgZededejdd
dZ	dd Z
dS )z/Functions for computing rich-club coefficients.    )
accumulateN)not_implemented_forrich_club_coefficientdirected
multigraphTd   c                    sr   t | dkrtdt| }|r7|  }| }t j||| || d |d t|  fdd| D }|S )u
  Returns the rich-club coefficient of the graph `G`.

    For each degree *k*, the *rich-club coefficient* is the ratio of the
    number of actual to the number of potential edges for nodes with
    degree greater than *k*:

    .. math::

        \phi(k) = \frac{2 E_k}{N_k (N_k - 1)}

    where `N_k` is the number of nodes with degree larger than *k*, and
    `E_k` is the number of edges among those nodes.

    Parameters
    ----------
    G : NetworkX graph
        Undirected graph with neither parallel edges nor self-loops.
    normalized : bool (optional)
        Normalize using randomized network as in [1]_
    Q : float (optional, default=100)
        If `normalized` is True, perform `Q * m` double-edge
        swaps, where `m` is the number of edges in `G`, to use as a
        null-model for normalization.
    seed : integer, random_state, or None (default)
        Indicator of random number generation state.
        See :ref:`Randomness<randomness>`.

    Returns
    -------
    rc : dictionary
       A dictionary, keyed by degree, with rich-club coefficient values.

    Raises
    ------
    NetworkXError
        If `G` has fewer than four nodes and ``normalized=True``.
        A randomly sampled graph for normalization cannot be generated in this case.

    Examples
    --------
    >>> G = nx.Graph([(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (4, 5)])
    >>> rc = nx.rich_club_coefficient(G, normalized=False, seed=42)
    >>> rc[0]
    0.4

    Notes
    -----
    The rich club definition and algorithm are found in [1]_.  This
    algorithm ignores any edge weights and is not defined for directed
    graphs or graphs with parallel edges or self loops.

    Normalization is done by computing the rich club coefficient for a randomly
    sampled graph with the same degree distribution as `G` by
    repeatedly swapping the endpoints of existing edges. For graphs with fewer than 4
    nodes, it is not possible to generate a random graph with a prescribed
    degree distribution, as the degree distribution fully determines the graph
    (hence making the coefficients trivially normalized to 1).
    This function raises an exception in this case.

    Estimates for appropriate values of `Q` are found in [2]_.

    References
    ----------
    .. [1] Julian J. McAuley, Luciano da Fontoura Costa,
       and Tibério S. Caetano,
       "The rich-club phenomenon across complex network hierarchies",
       Applied Physics Letters Vol 91 Issue 8, August 2007.
       https://arxiv.org/abs/physics/0701290
    .. [2] R. Milo, N. Kashtan, S. Itzkovitz, M. E. J. Newman, U. Alon,
       "Uniform generation of random graphs with arbitrary degree
       sequences", 2006. https://arxiv.org/abs/cond-mat/0312028
    r   zDrich_club_coefficient is not implemented for graphs with self loops.
   )	max_triesseedc                    s   i | ]\}}|| |  qS  r   ).0kvrcranr   p/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/networkx/algorithms/richclub.py
<dictcomp>c   s    z)rich_club_coefficient.<locals>.<dictcomp>)nxnumber_of_selfloops	Exception_compute_rccopynumber_of_edgesdouble_edge_swapitems)G
normalizedQr
   rcREr   r   r   r      s   Lc           
         s   t  }t|fddt|D }t fdd  D dd}  }|dkr-i S | \}}i }t|D ]+\}}	||krXt	|dkrJd}n| \}}|d8 }||ksAd| |	|	d   ||< q9|S )	zReturns the rich-club coefficient for each degree in the graph
    `G`.

    `G` is an undirected graph without multiedges.

    Returns a dictionary mapping degree to rich-club coefficient for
    that degree.

    c                 3   s$    | ]} | d kr | V  qdS )   Nr   )r   cs)totalr   r   	<genexpr>u   s   " z_compute_rc.<locals>.<genexpr>c                 3   s     | ]}t t j|V  qd S )N)sortedmapdegree)r   e)r   r   r   r$   {   s    T)reverser   r!      )
r   degree_histogramsumr   r%   edgesr   pop	enumeratelen)
r   deghistnksedge_degreesekk1k2r   dnkr   )r   r#   r   r   g   s&   

r   )Tr   N)__doc__	itertoolsr   networkxr   networkx.utilsr   __all___dispatchabler   r   r   r   r   r   <module>   s    Y