a
    ¬ˆcT  ã                   @   s´   d dl Z d dlmZmZ d dlmZ d dlmZ d dlm	Z	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dlZddlmZ ddlmZ d	gZG d
d	„ d	ƒZ dS )é    N)ÚlinalgÚspecial)Ú	logsumexp)Úcheck_random_state)ÚasarrayÚ
atleast_2dÚreshapeÚzerosÚnewaxisÚdotÚexpÚpiÚsqrtÚravelÚpowerÚ
atleast_1dÚsqueezeÚsumÚ	transposeÚonesÚcové   )Ú_mvn)Úgaussian_kernel_estimateÚgaussian_kdec                   @   s¦   e Zd ZdZd"dd„Zdd„ ZeZdd„ Zd	d
„ Zd#dd„Z	dd„ Z
d$dd„Zdd„ Zdd„ ZeZde_d%dd„Zdd„ Zdd„ Zdd„ Zedd„ ƒZed d!„ ƒZdS )&r   aë  Representation of a kernel-density estimate using Gaussian kernels.

    Kernel density estimation is a way to estimate the probability density
    function (PDF) of a random variable in a non-parametric way.
    `gaussian_kde` works for both uni-variate and multi-variate data.   It
    includes automatic bandwidth determination.  The estimation works best for
    a unimodal distribution; bimodal or multi-modal distributions tend to be
    oversmoothed.

    Parameters
    ----------
    dataset : array_like
        Datapoints to estimate from. In case of univariate data this is a 1-D
        array, otherwise a 2-D array with shape (# of dims, # of data).
    bw_method : str, scalar or callable, optional
        The method used to calculate the estimator bandwidth.  This can be
        'scott', 'silverman', a scalar constant or a callable.  If a scalar,
        this will be used directly as `kde.factor`.  If a callable, it should
        take a `gaussian_kde` instance as only parameter and return a scalar.
        If None (default), 'scott' is used.  See Notes for more details.
    weights : array_like, optional
        weights of datapoints. This must be the same shape as dataset.
        If None (default), the samples are assumed to be equally weighted

    Attributes
    ----------
    dataset : ndarray
        The dataset with which `gaussian_kde` was initialized.
    d : int
        Number of dimensions.
    n : int
        Number of datapoints.
    neff : int
        Effective number of datapoints.

        .. versionadded:: 1.2.0
    factor : float
        The bandwidth factor, obtained from `kde.covariance_factor`. The square
        of `kde.factor` multiplies the covariance matrix of the data in the kde
        estimation.
    covariance : ndarray
        The covariance matrix of `dataset`, scaled by the calculated bandwidth
        (`kde.factor`).
    inv_cov : ndarray
        The inverse of `covariance`.

    Methods
    -------
    evaluate
    __call__
    integrate_gaussian
    integrate_box_1d
    integrate_box
    integrate_kde
    pdf
    logpdf
    resample
    set_bandwidth
    covariance_factor

    Notes
    -----
    Bandwidth selection strongly influences the estimate obtained from the KDE
    (much more so than the actual shape of the kernel).  Bandwidth selection
    can be done by a "rule of thumb", by cross-validation, by "plug-in
    methods" or by other means; see [3]_, [4]_ for reviews.  `gaussian_kde`
    uses a rule of thumb, the default is Scott's Rule.

    Scott's Rule [1]_, implemented as `scotts_factor`, is::

        n**(-1./(d+4)),

    with ``n`` the number of data points and ``d`` the number of dimensions.
    In the case of unequally weighted points, `scotts_factor` becomes::

        neff**(-1./(d+4)),

    with ``neff`` the effective number of datapoints.
    Silverman's Rule [2]_, implemented as `silverman_factor`, is::

        (n * (d + 2) / 4.)**(-1. / (d + 4)).

    or in the case of unequally weighted points::

        (neff * (d + 2) / 4.)**(-1. / (d + 4)).

    Good general descriptions of kernel density estimation can be found in [1]_
    and [2]_, the mathematics for this multi-dimensional implementation can be
    found in [1]_.

    With a set of weighted samples, the effective number of datapoints ``neff``
    is defined by::

        neff = sum(weights)^2 / sum(weights^2)

    as detailed in [5]_.

    References
    ----------
    .. [1] D.W. Scott, "Multivariate Density Estimation: Theory, Practice, and
           Visualization", John Wiley & Sons, New York, Chicester, 1992.
    .. [2] B.W. Silverman, "Density Estimation for Statistics and Data
           Analysis", Vol. 26, Monographs on Statistics and Applied Probability,
           Chapman and Hall, London, 1986.
    .. [3] B.A. Turlach, "Bandwidth Selection in Kernel Density Estimation: A
           Review", CORE and Institut de Statistique, Vol. 19, pp. 1-33, 1993.
    .. [4] D.M. Bashtannyk and R.J. Hyndman, "Bandwidth selection for kernel
           conditional density estimation", Computational Statistics & Data
           Analysis, Vol. 36, pp. 279-298, 2001.
    .. [5] Gray P. G., 1969, Journal of the Royal Statistical Society.
           Series A (General), 132, 272

    Examples
    --------
    Generate some random two-dimensional data:

    >>> from scipy import stats
    >>> def measure(n):
    ...     "Measurement model, return two coupled measurements."
    ...     m1 = np.random.normal(size=n)
    ...     m2 = np.random.normal(scale=0.5, size=n)
    ...     return m1+m2, m1-m2

    >>> m1, m2 = measure(2000)
    >>> xmin = m1.min()
    >>> xmax = m1.max()
    >>> ymin = m2.min()
    >>> ymax = m2.max()

    Perform a kernel density estimate on the data:

    >>> X, Y = np.mgrid[xmin:xmax:100j, ymin:ymax:100j]
    >>> positions = np.vstack([X.ravel(), Y.ravel()])
    >>> values = np.vstack([m1, m2])
    >>> kernel = stats.gaussian_kde(values)
    >>> Z = np.reshape(kernel(positions).T, X.shape)

    Plot the results:

    >>> import matplotlib.pyplot as plt
    >>> fig, ax = plt.subplots()
    >>> ax.imshow(np.rot90(Z), cmap=plt.cm.gist_earth_r,
    ...           extent=[xmin, xmax, ymin, ymax])
    >>> ax.plot(m1, m2, 'k.', markersize=2)
    >>> ax.set_xlim([xmin, xmax])
    >>> ax.set_ylim([ymin, ymax])
    >>> plt.show()

    Nc                 C   s®   t t|ƒƒ| _| jjdks"tdƒ‚| jj\| _| _|d uržt|ƒ 	t
¡| _|  jt| jƒ  _| jjdkrrtdƒ‚t| jƒ| jkrŠtdƒ‚dt| jd ƒ | _| j|d� d S )Nr   z.`dataset` input should have multiple elements.z*`weights` input should be one-dimensional.z%`weights` input should be of length né   ©Ú	bw_method)r   r   ÚdatasetÚsizeÚ
ValueErrorÚshapeÚdÚnr   ZastypeÚfloatÚ_weightsr   ÚweightsÚndimÚlenÚ_neffÚset_bandwidth)Úselfr   r   r&   © r,   úS/home/yuhw/wc/wire-cell-python/wcpy/lib/python3.9/site-packages/scipy/stats/_kde.pyÚ__init__¿   s    zgaussian_kde.__init__c           	      C   sì   t t|ƒƒ}|j\}}|| jkr^|dkrH|| jkrHt|| jdfƒ}d}nd|| jf }t|ƒ‚t | j|¡}t 	|¡j
}|dkr†d}n,|dkr”d}n|dv r¢d}ntd	||f ƒ‚t| | jj| jd
d
…d
f |j| j|ƒ}|d
d
…df S )a  Evaluate the estimated pdf on a set of points.

        Parameters
        ----------
        points : (# of dimensions, # of points)-array
            Alternatively, a (# of dimensions,) vector can be passed in and
            treated as a single point.

        Returns
        -------
        values : (# of points,)-array
            The values at each point.

        Raises
        ------
        ValueError : if the dimensionality of the input points is different than
                     the dimensionality of the KDE.

        r   ú2points have dimension %s, dataset has dimension %sé   r$   é   Údouble)é   é   zlong doublez%s has unexpected item size %dNr   )r   r   r!   r"   r   r    ÚnpZcommon_typeÚ
covarianceÚdtypeÚitemsizeÚ	TypeErrorr   r   ÚTr&   Úinv_cov)	r+   Úpointsr"   ÚmÚmsgZoutput_dtyper8   ÚspecÚresultr,   r,   r-   ÚevaluateÑ   s2    

ÿÿ
ÿzgaussian_kde.evaluatec                 C   sî   t t|ƒƒ}t|ƒ}|j| jfkr0td| j ƒ‚|j| j| jfkrPtd| j ƒ‚|dd…tf }| j| }t 	|¡}| j
| }t ||¡}t t |d ¡¡}tdt |jd d ƒ| }t|| dd�d }	tt|	 ƒ| j dd�| }
|
S )aW  
        Multiply estimated density by a multivariate Gaussian and integrate
        over the whole space.

        Parameters
        ----------
        mean : aray_like
            A 1-D array, specifying the mean of the Gaussian.
        cov : array_like
            A 2-D array, specifying the covariance matrix of the Gaussian.

        Returns
        -------
        result : scalar
            The value of the integral.

        Raises
        ------
        ValueError
            If the mean or covariance of the input Gaussian differs from
            the KDE's dimensionality.

        zmean does not have dimension %sz%covariance does not have dimension %sNr   r   ç       @©Zaxis)r   r   r   r!   r"   r    r
   r6   r   Ú
cho_factorr   Ú	cho_solver5   ÚprodÚdiagonalr   r   r   r   r&   )r+   Úmeanr   Úsum_covÚsum_cov_cholÚdiffÚtdiffÚsqrt_detÚ
norm_constÚenergiesr@   r,   r,   r-   Úintegrate_gaussian  s     


zgaussian_kde.integrate_gaussianc                 C   sl   | j dkrtdƒ‚tt| jƒƒd }t|| j | ƒ}t|| j | ƒ}t | jt	 
|¡t	 
|¡  ¡}|S )a´  
        Computes the integral of a 1D pdf between two bounds.

        Parameters
        ----------
        low : scalar
            Lower bound of integration.
        high : scalar
            Upper bound of integration.

        Returns
        -------
        value : scalar
            The result of the integral.

        Raises
        ------
        ValueError
            If the KDE is over more than one dimension.

        r   z'integrate_box_1d() only handles 1D pdfsr   )r"   r    r   r   r6   r   r5   r   r&   r   Zndtr)r+   ÚlowÚhighÚstdevZnormalized_lowZnormalized_highÚvaluer,   r,   r-   Úintegrate_box_1d8  s    
ÿÿzgaussian_kde.integrate_box_1dc                 C   sZ   |durd|i}ni }t j||| j| j| jfi |¤Ž\}}|rVd| jd  }t |¡ |S )aõ  Computes the integral of a pdf over a rectangular interval.

        Parameters
        ----------
        low_bounds : array_like
            A 1-D array containing the lower bounds of integration.
        high_bounds : array_like
            A 1-D array containing the upper bounds of integration.
        maxpts : int, optional
            The maximum number of points to use for integration.

        Returns
        -------
        value : scalar
            The result of the integral.

        NÚmaxptsz6An integral in _mvn.mvnun requires more points than %siè  )r   Zmvnun_weightedr   r&   r6   r"   ÚwarningsÚwarn)r+   Z
low_boundsZhigh_boundsrV   Z
extra_kwdsrT   Zinformr>   r,   r,   r-   Úintegrate_box[  s    
þþ
ÿ
zgaussian_kde.integrate_boxc                 C   sü   |j | j krtdƒ‚|j| jk r*|}| }n| }|}|j|j }t |¡}d}t|jƒD ]h}|jdd…|tf }|j| }	t 	||	¡}
t
|	|
 dd�d }|t
t| ƒ|j dd�|j|  7 }qVt t |d ¡¡}tdt |jd d ƒ| }|| }|S )aŸ  
        Computes the integral of the product of this  kernel density estimate
        with another.

        Parameters
        ----------
        other : gaussian_kde instance
            The other kde.

        Returns
        -------
        value : scalar
            The result of the integral.

        Raises
        ------
        ValueError
            If the KDEs have different dimensionality.

        z$KDEs are not the same dimensionalityg        Nr   rC   rB   r   )r"   r    r#   r6   r   rD   Úranger   r
   rE   r   r   r&   r5   rF   rG   r   r   r!   )r+   ÚotherÚsmallZlargerI   rJ   r@   ÚirH   rK   rL   rO   rM   rN   r,   r,   r-   Úintegrate_kde|  s(    

(zgaussian_kde.integrate_kdec                 C   sh   |du rt | jƒ}t|ƒ}t|jt| jftƒ| j|d�ƒ}|j	| j
|| jd�}| jdd…|f }|| S )aR  Randomly sample a dataset from the estimated pdf.

        Parameters
        ----------
        size : int, optional
            The number of samples to draw.  If not provided, then the size is
            the same as the effective number of samples in the underlying
            dataset.
        seed : {None, int, `numpy.random.Generator`,
                `numpy.random.RandomState`}, optional

            If `seed` is None (or `np.random`), the `numpy.random.RandomState`
            singleton is used.
            If `seed` is an int, a new ``RandomState`` instance is used,
            seeded with `seed`.
            If `seed` is already a ``Generator`` or ``RandomState`` instance then
            that instance is used.

        Returns
        -------
        resample : (self.d, `size`) ndarray
            The sampled dataset.

        N)r   )r   Úp)ÚintÚneffr   r   Zmultivariate_normalr	   r"   r$   r6   Úchoicer#   r&   r   )r+   r   ÚseedZrandom_stateZnormÚindicesZmeansr,   r,   r-   Úresample®  s    
ÿzgaussian_kde.resamplec                 C   s   t | jd| jd  ƒS )zoCompute Scott's factor.

        Returns
        -------
        s : float
            Scott's factor.
        ç      ð¿r0   ©r   ra   r"   ©r+   r,   r,   r-   Úscotts_factorÓ  s    zgaussian_kde.scotts_factorc                 C   s$   t | j| jd  d d| jd  ƒS )z{Compute the Silverman factor.

        Returns
        -------
        s : float
            The silverman factor.
        rB   g      @rf   r0   rg   rh   r,   r,   r-   Úsilverman_factorÝ  s    zgaussian_kde.silverman_factora0  Computes the coefficient (`kde.factor`) that
        multiplies the data covariance matrix to obtain the kernel covariance
        matrix. The default is `scotts_factor`.  A subclass can overwrite this
        method to provide a different method, or set it through a call to
        `kde.set_bandwidth`.c                    sŽ   ˆ du r
nxˆ dkrˆj ˆ_nfˆ dkr.ˆjˆ_nTt ˆ ¡rXtˆ tƒsXdˆ_‡ fdd„ˆ_n*tˆ ƒrvˆ ˆ_‡fdd„ˆ_nd}t	|ƒ‚ˆ 
¡  dS )	a9  Compute the estimator bandwidth with given method.

        The new bandwidth calculated after a call to `set_bandwidth` is used
        for subsequent evaluations of the estimated density.

        Parameters
        ----------
        bw_method : str, scalar or callable, optional
            The method used to calculate the estimator bandwidth.  This can be
            'scott', 'silverman', a scalar constant or a callable.  If a
            scalar, this will be used directly as `kde.factor`.  If a callable,
            it should take a `gaussian_kde` instance as only parameter and
            return a scalar.  If None (default), nothing happens; the current
            `kde.covariance_factor` method is kept.

        Notes
        -----
        .. versionadded:: 0.11

        Examples
        --------
        >>> import scipy.stats as stats
        >>> x1 = np.array([-7, -5, 1, 4, 5.])
        >>> kde = stats.gaussian_kde(x1)
        >>> xs = np.linspace(-10, 10, num=50)
        >>> y1 = kde(xs)
        >>> kde.set_bandwidth(bw_method='silverman')
        >>> y2 = kde(xs)
        >>> kde.set_bandwidth(bw_method=kde.factor / 3.)
        >>> y3 = kde(xs)

        >>> import matplotlib.pyplot as plt
        >>> fig, ax = plt.subplots()
        >>> ax.plot(x1, np.full(x1.shape, 1 / (4. * x1.size)), 'bo',
        ...         label='Data points (rescaled)')
        >>> ax.plot(xs, y1, label='Scott (default)')
        >>> ax.plot(xs, y2, label='Silverman')
        >>> ax.plot(xs, y3, label='Const (1/3 * Silverman)')
        >>> ax.legend()
        >>> plt.show()

        NZscottZ	silvermanzuse constantc                      s   ˆ S ©Nr,   r,   r   r,   r-   Ú<lambda>"  ó    z,gaussian_kde.set_bandwidth.<locals>.<lambda>c                      s
   ˆ   ˆ ¡S rk   )Ú
_bw_methodr,   rh   r,   r-   rl   %  rm   zC`bw_method` should be 'scott', 'silverman', a scalar or a callable.)ri   Úcovariance_factorrj   r5   ZisscalarÚ
isinstanceÚstrrn   Úcallabler    Ú_compute_covariance)r+   r   r>   r,   )r   r+   r-   r*   ï  s    +

zgaussian_kde.set_bandwidthc                 C   s’   |   ¡ | _t| dƒs<tt| jdd| jd�ƒ| _t 	| j¡| _
| j| jd  | _| j
| jd  | _t | jd t ¡}dt t |¡¡ ¡  | _dS )zcComputes the covariance matrix for each Gaussian kernel using
        covariance_factor().
        Ú_data_inv_covr   F)ZrowvarZbiasZaweightsr   N)ro   ZfactorÚhasattrr   r   r   r&   Z_data_covariancer   Úinvrt   r6   r;   Zcholeskyr   r5   ÚlogZdiagr   Úlog_det)r+   ÚLr,   r,   r-   rs   -  s    


þ
z gaussian_kde._compute_covariancec                 C   s
   |   |¡S )z×
        Evaluate the estimated pdf on a provided set of points.

        Notes
        -----
        This is an alias for `gaussian_kde.evaluate`.  See the ``evaluate``
        docstring for more details.

        )rA   )r+   Úxr,   r,   r-   Úpdf>  s    
zgaussian_kde.pdfc                 C   sp  t |ƒ}|j\}}|| jkrZ|dkrD|| jkrDt|| jdfƒ}d}nd|| jf }t|ƒ‚|| jkrîtj| j|ftd�}t	| jƒD ]<}| j
dd…|tf | }t| j|ƒ}	t||	 dd�||< q‚dt | j¡ | j |j }
td|
 dd�}n~tj|ftd�}t	|ƒD ]d}| j
|dd…|tf  }t| j|ƒ}	t||	 dd�}dt | j¡ | j | }
td|
 ƒ||< �q|S )	zT
        Evaluate the log of the estimated pdf on a provided set of points.
        r   r/   )r7   Nr   rC   rB   g      à?)r   r!   r"   r   r    r#   r5   Úemptyr$   rZ   r   r
   r   r;   r   rw   r&   rx   r:   r   )r+   rz   r<   r"   r=   r>   Zenergyr]   rK   rL   Z
log_to_sumr@   r,   r,   r-   ÚlogpdfJ  s4    

ÿ
zgaussian_kde.logpdfc                 C   s8   z| j W S  ty2   t| jƒ| j | _ | j  Y S 0 d S rk   )r%   ÚAttributeErrorr   r#   rh   r,   r,   r-   r&   p  s
    zgaussian_kde.weightsc                 C   s:   z| j W S  ty4   dt| jd ƒ | _ | j  Y S 0 d S )Nr   r   )r)   r~   r   r&   rh   r,   r,   r-   ra   x  s
    zgaussian_kde.neff)NN)N)NN)N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r.   rA   Ú__call__rP   rU   rY   r^   re   ri   rj   ro   r*   rs   r{   r}   Úpropertyr&   ra   r,   r,   r,   r-   r   )   s,    
05#
!2
%

>&
)!rW   Zscipyr   r   Zscipy.specialr   Zscipy._lib._utilr   Únumpyr   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r5   Ú r   Z_statsr   Ú__all__r   r,   r,   r,   r-   Ú<module>   s   L