403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.217.85
Web Server : Apache
System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64
User : sws1074145052 ( 1074145052)
PHP Version : 8.3.32
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /lib/python3/dist-packages/scipy/stats/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /lib/python3/dist-packages/scipy/stats/__pycache__/_kde.cpython-311.pyc
�

d�c�a���ddlZddlmZmZddlmZddlmZmZm	Z	m
Z
mZmZm
Z
mZmZmZmZmZmZmZmZmZddlZddlmZddlmZmZdgZGd	�d��Zd
�ZdS)�N)�linalg�special)�check_random_state)�asarray�
atleast_2d�reshape�zeros�newaxis�exp�pi�sqrt�ravel�power�
atleast_1d�squeeze�sum�	transpose�ones�cov�)�_mvn)�gaussian_kernel_estimate�gaussian_kernel_estimate_log�gaussian_kdec���eZdZdZdd�Zd�ZeZd�Zd�Zdd�Z	d�Z
dd	�Zd
�Zd�Z
eZde_dd
�Zd�Zed���Zd�Zd�Zd�Zed���Zed���ZdS)ra&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]_.

    `gaussian_kde` does not currently support data that lies in a
    lower-dimensional subspace of the space in which it is expressed. For such
    data, consider performing principle component analysis / dimensionality
    reduction and using `gaussian_kde` with the transformed data.

    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:

    >>> import numpy as np
    >>> 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��tt|����|_|jjdkst	d���|jj\|_|_|��t|���	t��|_|xjt|j��zc_|j
jdkrt	d���t|j��|jkrt	d���dt|jdz��z|_|j|jkrd}t	|���	|�|���dS#t$j$r}d}t%j|��|�d}~wwxYw)	Nrz.`dataset` input should have multiple elements.z*`weights` input should be one-dimensional.z%`weights` input should be of length n�a1Number of dimensions is greater than number of samples. This results in a singular data covariance matrix, which cannot be treated using the algorithms implemented in `gaussian_kde`. Note that `gaussian_kde` interprets each *column* of `dataset` to be a point; consider transposing the input to `dataset`.��	bw_methodabThe data appears to lie in a lower-dimensional subspace of the space in which it is expressed. This has resulted in a singular data covariance matrix, which cannot be treated using the algorithms implemented in `gaussian_kde`. Consider performing principle component analysis / dimensionality reduction and using `gaussian_kde` with the transformed data.)rr�dataset�size�
ValueError�shape�d�nr�astype�float�_weightsr�weights�ndim�len�_neff�
set_bandwidthr�LinAlgError)�selfr rr)�msg�es      �2/usr/lib/python3/dist-packages/scipy/stats/_kde.py�__init__zgaussian_kde.__init__�sk��!�'�'�"2�"2�3�3����|� �1�$�$��M�N�N�N���+��������&�w�/�/�6�6�u�=�=�D�M��M�M�S���/�/�/�M�M��|� �A�%�%� �!M�N�N�N��4�=�!�!�T�V�+�+� �!H�I�I�I��3�t�}�a�/�0�0�0�D�J��6�D�F�?�?�-�C��S�/�/�!�
	1������3�3�3�3�3���!�	1�	1�	1�?�C��$�S�)�)�q�0�����	1���s�6E�E9�E4�4E9c��tt|����}|j\}}||jkrG|dkr%||jkrt	||jdf��}d}nd|�d|j��}t|���t
|j|��\}}t||j	j
|jdd�df|j
|j|��}|dd�dfS)aEvaluate 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�points have dimension �, dataset has dimension Nr)
rrr#r$rr"�_get_output_dtype�
covariancerr �Tr)�cho_cov)r/�pointsr$�mr0�output_dtype�spec�results        r2�evaluatezgaussian_kde.evaluate�s���(�G�F�O�O�,�,���|���1����;�;��A�v�v�!�t�v�+�+� ��$�&�!��5�5������NO�a�a��F�F��� ��o�o�%�.�t���G�G���d�)�$�/��L�N�D�L����D��1��H�d�l�L�2�2���a�a�a��d�|��c���tt|����}t|��}|j|jfkrtd|jz���|j|j|jfkrtd|jz���|dd�tf}|j|z}tj	|��}|j
|z
}tj||��}tj
tj|d����}tdt z|jddz��|z}t#||zd���dz}	t#t%|	��|jzd���|z}
|
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.

        zmean does not have dimension %sz%covariance does not have dimension %sNrr�@��axis)rrrr#r$r"r
r8r�
cho_factorr �	cho_solve�np�prod�diagonalrrrrr))r/�meanr�sum_cov�sum_cov_chol�diff�tdiff�sqrt_det�
norm_const�energiesr?s           r2�integrate_gaussianzgaussian_kde.integrate_gaussiansL��0�'�$�-�-�(�(����o�o���:�$�&��"�"��>���G�H�H�H��9�����(�(�(��D�t�v�M�N�N�N��A�A�A�w�J����/�C�'��
�(��1�1���|�d�"��� ��t�4�4���7�2�;�|�A��7�7�8�8���1�r�6�7�=��#3�c�#9�:�:�X�E�
��t�e�|�!�,�,�,�s�2���S�(��^�^�D�L�0�q�9�9�9�J�F���
rAc�v�|jdkrtd���tt|j����d}t||jz
|z��}t||jz
|z��}t
j|jtj
|��tj
|��z
z��}|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.

        rz'integrate_box_1d() only handles 1D pdfsr)r$r"rr
r8r rHrr)r�ndtr)r/�low�high�stdev�normalized_low�normalized_high�values       r2�integrate_box_1dzgaussian_kde.integrate_box_1dIs���,�6�Q�;�;��F�G�G�G��d�4�?�+�+�,�,�Q�/����d�l� 2�e�;�<�<������!4�� =�>�>����t�|���_�5�5���^�4�4�5�6�7�7���rAc��|�d|i}ni}tj|||j|j|jfi|��\}}|r!d|jdzz}t
j|��|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�mvnun_weightedr r)r8r$�warnings�warn)r/�
low_bounds�high_boundsr^�
extra_kwdsr[�informr0s        r2�
integrate_boxzgaussian_kde.integrate_boxls���$��"�F�+�J�J��J��+�J��+/�<���+/�?�J�J�>H�J�J�
��v��	�K��F�T�M�#�C��M�#�����rAc��|j|jkrtd���|j|jkr|}|}n|}|}|j|jz}t	j|��}d}t
|j��D]�}|jdd�|tf}|j|z
}	t	j	||	��}
t|	|
zd���dz}|tt|��|jzd���|j|zz
}��tjtj|d����}t!dt"z|jddz��|z}
||
z}|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 dimensionalitygNrrDrCr)r$r"r%r8rrF�ranger r
rGrrr)rHrIrJrrr#)r/�other�small�largerLrMr?�irKrNrOrRrPrQs              r2�
integrate_kdezgaussian_kde.integrate_kde�sZ��*�7�d�f����C�D�D�D��7�T�V����E��E�E��E��E��"�U�%5�5���(��1�1�����u�w���	Q�	Q�A��=����A�w��/�D��=�4�'�D��$�\�4�8�8�E��4�%�<�a�0�0�0�3�6�H��c�#�x�i�.�.���6�Q�?�?�?��
�a�@P�P�P�F�F��7�2�;�|�A��7�7�8�8���1�r�6�7�=��#3�c�#9�:�:�X�E�
��*����
rAc�B�|�t|j��}t|��}t|�t|jft��|j|�����}|�	|j
||j���}|jdd�|f}||zS)aARandomly 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�neffrr�multivariate_normalr	r$r'r8�choicer%r)r )r/r!�seed�random_state�norm�indices�meanss       r2�resamplezgaussian_kde.resample�s���.�<��t�y�>�>�D�)�$�/�/����9�9��4�6�)�U�#�#�T�_�4�:�
�
�����%�%�d�f�4�4�<�%�H�H����Q�Q�Q��Z�(���t�|�rAc�B�t|jd|jdzz��S)zoCompute Scott's factor.

        Returns
        -------
        s : float
            Scott's factor.
        ����rrqr$�r/s r2�
scotts_factorzgaussian_kde.scotts_factor�s ���T�Y��T�V�A�X��/�/�/rAc�^�t|j|jdzzdzd|jdzz��S)z{Compute the Silverman factor.

        Returns
        -------
        s : float
            The silverman factor.
        rCg@r{r|r}r~s r2�silverman_factorzgaussian_kde.silverman_factor�s0���T�Y���s�
�+�C�/��d�f�Q�h��@�@�@rAa0Computes 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�^�����n��dkr
�j�_n��dkr
�j�_nmtj���r't�t��sd�_�fd��_n2t���r��_�fd��_nd}t|�����
��dS)aXCompute 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 numpy as np
        >>> 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()

        N�scott�	silvermanzuse constantc����S�N�rs�r2�<lambda>z,gaussian_kde.set_bandwidth.<locals>.<lambda>2s���Y�rAc�.�������Sr�)�
_bw_methodr~s�r2r�z,gaussian_kde.set_bandwidth.<locals>.<lambda>5s���T�_�_�T�-B�-B�rAzC`bw_method` should be 'scott', 'silverman', a scalar or a callable.)r�covariance_factorr�rH�isscalar�
isinstance�strr��callabler"�_compute_covariance)r/rr0s`` r2r-zgaussian_kde.set_bandwidth�s�����X���
�'�
!�
!�%)�%7�D�"�"�
�+�
%�
%�%)�%:�D�"�"�
�[��
#�
#�		"�J�y�#�,F�,F�		"�,�D�O�%6�%6�%6�%6�D�"�"�
�i�
 �
 �	"�'�D�O�%B�%B�%B�%B�D�"�"�#�C��S�/�/�!�� � �"�"�"�"�"rAc
�J�|���|_t|d��sOtt	|jdd|j�����|_tj	|jd���|_
|j|jdzz|_|j
|jz�tj��|_dtjtj|jtjdt&z��z�������z|_dS)	zcComputes the covariance matrix for each Gaussian kernel using
        covariance_factor().
        �
_data_cho_covrF��rowvar�bias�aweightsT)�lowerrN)r��factor�hasattrrrr r)�_data_covariancer�choleskyr�r8r&rH�float64r:�log�diagr
rr�log_detr~s r2r�z gaussian_kde._compute_covariance=s���,�,�.�.����t�_�-�-�	=�$.�s�4�<��49�8<��0F�0F�0F�%G�%G�D�!�"(���1F�7;�"=�"=�"=�D���/�$�+�q�.�@����*�T�[�8�@�@���L�L����������*,�'�!�B�$�-�-�)8�!9�!9�:�:�:=�#�%�%�@����rAc���|���|_tt|jdd|j�����|_tj|j��|jdzzS)NrFr�r)	r�r�rrr r)r�r�invr~s r2�inv_covzgaussian_kde.inv_covOsj���,�,�.�.��� *�3�t�|�A�05���,N�,N�,N�!O�!O����z�$�/�0�0�4�;��>�A�ArAc�,�|�|��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.

        )r@)r/�xs  r2�pdfzgaussian_kde.pdf[s���}�}�Q���rAc��t|��}|j\}}||jkrG|dkr%||jkrt||jdf��}d}nd|�d|j��}t	|���t|j|��\}}t||jj	|j
dd�df|j	|j|��}|dd�dfS)zT
        Evaluate the log of the estimated pdf on a provided set of points.
        rr5r6Nr)rr#r$rr"r7r8rr r9r)r:)	r/r�r;r$r<r0r=r>r?s	         r2�logpdfzgaussian_kde.logpdfgs����A�����|���1����;�;��A�v�v�!�t�v�+�+� ��$�&�!��5�5�����9��9�9�04��9�9�� ��o�o�%�.�t���G�G���d�-�d�3��L�N�D�L����D��1��H�d�l�L�2�2���a�a�a��d�|�rAc��tj|��}tj|jtj��sd}t|���t
|j��}|���}|||dkz||dk<t
tj	|����t
|��krd}t|���|dk||kz}tj
|��rd||�d|�d�}t|���|j|}|j}t||�
��|���S)a)Return a marginal KDE distribution

        Parameters
        ----------
        dimensions : int or 1-d array_like
            The dimensions of the multivariate distribution corresponding
            with the marginal variables, that is, the indices of the dimensions
            that are being retained. The other dimensions are marginalized out.

        Returns
        -------
        marginal_kde : gaussian_kde
            An object representing the marginal distribution.

        Notes
        -----
        .. versionadded:: 1.10.0

        zaElements of `dimensions` must be integers - the indices of the marginal variables being retained.rz,All elements of `dimensions` must be unique.zDimensions z# are invalid for a distribution in z dimensions.)rr))rHr�
issubdtype�dtype�integerr"r+r �copy�unique�anyr)rr�)	r/�
dimensions�dimsr0r%�
original_dims�	i_invalidr r)s	         r2�marginalzgaussian_kde.marginals=��*�}�Z�(�(���}�T�Z���4�4�	"�?�C��S�/�/�!��������	�	���
��T�$��(�^�+��T�A�X���r�y������3�t�9�9�,�,�A�C��S�/�/�!��A�X�$�!�)�,�	�
�6�)���	"�<��y�!9�<�<�,-�<�<�<�C��S�/�/�!��,�t�$���,���G�t�/E�/E�/G�/G�$+�-�-�-�	-rAc��	|jS#t$r+t|j��|jz|_|jcYSwxYwr�)r(�AttributeErrorrr%r~s r2r)zgaussian_kde.weights�sN��	!��=� ���	!�	!�	!� ���L�L���/�D�M��=� � � �	!���s�	�2>�>c�~�	|jS#t$r)dt|jdz��z|_|jcYSwxYw)Nrr)r,r�rr)r~s r2rqzgaussian_kde.neff�sR��	��:����	�	�	��3�t�|�Q��/�/�/�D�J��:����	���s�	�0<�<)NNr�)�__name__�
__module__�__qualname__�__doc__r3r@�__call__rSr\rfrmryrr�r�r-r��propertyr�r�r�r�r)rqr�rAr2rr(s�������Z�Z�v$1�$1�$1�$1�L&�&�&�P�H�3�3�3�j!�!�!�F����B0�0�0�d!�!�!�!�F0�0�0�A�A�A�&��! ���=#�=#�=#�=#�~@�@�@�$�	B�	B��X�	B�
 �
 �
 ����0/-�/-�/-�b�!�!��X�!�����X���rAc��tj||��}tj|��j}|dkrd}n$|dkrd}n|dvrd}nt	|�d|�����||fS)z�
    Calculates the output dtype and the "spec" (=C type name).

    This was necessary in order to deal with the fused types in the Cython
    routine `gaussian_kernel_estimate`. See gh-10824 for details.
    r|r'��double)��zlong doublez has unexpected item size: )rH�common_typer��itemsizer")r8r;r=r�r>s     r2r7r7�s����>�*�f�5�5�L��x��%�%�.�H��1�}�}����	�Q������	�X�	�	������F�F�H�F�F���	����rA) r`�scipyrr�scipy._lib._utilr�numpyrrrr	r
rrr
rrrrrrrrrH�r�_statsrr�__all__rr7r�rAr2�<module>r�s~��*����"�!�!�!�!�!�!�!�/�/�/�/�/�/�����������������������������������������������J�J�J�J�J�J�J�J��
��V
�V
�V
�V
�V
�V
�V
�V
�r����rA

Youez - 2016 - github.com/yon3zu
LinuXploit