| Server IP : 35.80.110.71 / Your IP : 216.73.216.221 Web Server : Apache/2.4.58 (Ubuntu) System : Linux ip-172-31-21-44 6.17.0-1019-aws #19~24.04.1-Ubuntu SMP Tue Jun 23 18:53:06 UTC 2026 x86_64 User : ubuntu ( 1000) PHP Version : 8.3.31 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /lib/python3/dist-packages/matplotlib/__pycache__/ |
Upload File : |
�
G8�c� � � � d Z ddlZddlmZ ddlZddlmZmZm Z d� Z
d� Z d'd�Z d(d�Z
d(d �Zd
� Z ej d � d)d �� Zd*d
�Z d+d�Z d,d�Zej* j- ddd�� ej. d-d�� Zej. d-d�� ZdZ ej6 ed� Z ej: d.ddiej* j< ��e _ ej6 ed� Z ej: d.ddiej* j< ��e _ ej6 ed � Z ej: d.dd iej* j< ��e _ ej6 ed � Z! ej: d.dd iej* j< ��e!_ ej. d/d �� Z"ej. d!d"ee
ddd#dfd$�� Z# G d%� d&� Z$y)0a
Numerical Python functions written for compatibility with MATLAB
commands with the same names. Most numerical Python functions can be found in
the `NumPy`_ and `SciPy`_ libraries. What remains here is code for performing
spectral computations and kernel density estimations.
.. _NumPy: https://numpy.org
.. _SciPy: https://www.scipy.org
Spectral functions
------------------
`cohere`
Coherence (normalized cross spectral density)
`csd`
Cross spectral density using Welch's average periodogram
`detrend`
Remove the mean or best fit line from an array
`psd`
Power spectral density using Welch's average periodogram
`specgram`
Spectrogram (spectrum over segments of time)
`complex_spectrum`
Return the complex-valued frequency spectrum of a signal
`magnitude_spectrum`
Return the magnitude of the frequency spectrum of a signal
`angle_spectrum`
Return the angle (wrapped phase) of the frequency spectrum of a signal
`phase_spectrum`
Return the phase (unwrapped angle) of the frequency spectrum of a signal
`detrend_mean`
Remove the mean from a line.
`detrend_linear`
Remove the best fit line from a line.
`detrend_none`
Return the original line.
`stride_windows`
Get all windows in an array in a memory-efficient manner
� N)�Number)�_api�
_docstring�cbookc �D � t j t | � � | z S )z�
Return *x* times the Hanning (or Hann) window of len(*x*).
See Also
--------
window_none : Another window algorithm.
)�np�hanning�len��xs �1/usr/lib/python3/dist-packages/matplotlib/mlab.py�window_hanningr = s � � �:�:�c�!�f� �a� � � c � � | S )zz
No window function; simply return *x*.
See Also
--------
window_hanning : Another window algorithm.
� r s r
� window_noner H s � �
�Hr c �� � |�|dv rt | t |�� S |dk( rt | t |�� S |dk( rt | t |�� S t |� rmt j | � } |�!|dz | j kD rt d|� d�� �|�| j dk( s|s| j dk( r || � S || |� � S t d |�d �� �# t $ r t j ||| �
� cY S w xY w)
al
Return *x* with its trend removed.
Parameters
----------
x : array or sequence
Array or sequence containing the data.
key : {'default', 'constant', 'mean', 'linear', 'none'} or function
The detrending algorithm to use. 'default', 'mean', and 'constant' are
the same as `detrend_mean`. 'linear' is the same as `detrend_linear`.
'none' is the same as `detrend_none`. The default is 'mean'. See the
corresponding functions for more details regarding the algorithms. Can
also be a function that carries out the detrend operation.
axis : int
The axis along which to do the detrending.
See Also
--------
detrend_mean : Implementation of the 'mean' algorithm.
detrend_linear : Implementation of the 'linear' algorithm.
detrend_none : Implementation of the 'none' algorithm.
)�constant�mean�default)�key�axis�linear�none� zaxis(=z) out of boundsr �r )r �arrzUnknown value for key: zH, must be one of: 'default', 'constant', 'mean', 'linear', or a function) �detrend� detrend_mean�detrend_linear� detrend_none�callabler �asarray�ndim�
ValueError� TypeError�apply_along_axis)r r r s r
r r S s � �2 �{�c� <�<��q�l��6�6� �� ��q�n�4�8�8� �� ��q�l��6�6� �#� � �J�J�q�M�� � ��q��1�6�6� 1� �v�d�V�?� ;�<� <� �L�Q�V�V�q�[�$�1�6�6�Q�;��q�6�M� >��q�t�$� $� �%�c�W� -:�
;�<� <�� � >��&�&�s��1�=� =� >�s �5 C �!C2�1C2c � � t j | � } |� |dz | j kD rt d|z � �| | j |d�� z
S )a�
Return *x* minus the mean(*x*).
Parameters
----------
x : array or sequence
Array or sequence containing the data
Can have any dimensionality
axis : int
The axis along which to take the mean. See `numpy.mean` for a
description of this argument.
See Also
--------
detrend_linear : Another detrend algorithm.
detrend_none : Another detrend algorithm.
detrend : A wrapper around all the detrend algorithms.
r zaxis(=%s) out of boundsT)�keepdims)r r# r$ r% r �r r s r
r r � sN � �( �
�
�1�
�A� ��D��F�Q�V�V�O��2�T�9�:�:� �q�v�v�d�T�v�*� *�*r c � � | S )a�
Return *x*: no detrending.
Parameters
----------
x : any object
An object containing the data
axis : int
This parameter is ignored.
It is included for compatibility with detrend_mean
See Also
--------
detrend_mean : Another detrend algorithm.
detrend_linear : Another detrend algorithm.
detrend : A wrapper around all the detrend algorithms.
r r* s r
r! r! � s � �&
�Hr c � � t j | � } | j dkD r t d� �| j s!t j d| j
�� S t j | j t �� }t j || d�� }|d |d z }| j � ||j � z z
}| ||z |z z
S )ab
Return *x* minus best fit line; 'linear' detrending.
Parameters
----------
y : 0-D or 1-D array or sequence
Array or sequence containing the data
See Also
--------
detrend_mean : Another detrend algorithm.
detrend_none : Another detrend algorithm.
detrend : A wrapper around all the detrend algorithms.
r zy cannot have ndim > 1g )�dtype)�bias)r r �r r ) r r# r$ r% �arrayr- �arange�size�float�covr )�yr �C�b�as r
r r � s� � � �
�
�1�
�A��v�v��z��1�2�2�
�6�6��x�x��!�'�'�*�*�
� � �!�&�&��&�A�
���q�!�!� �A� �$���$���A� ����1�Q�V�V�X�:� �A� ��!��a��=�r z3.6c �l � |�d}t j | � dk7 r t d� �t | |||� S )al
Get all windows of *x* with length *n* as a single array,
using strides to avoid data duplication.
.. warning::
It is not safe to write to the output array. Multiple
elements may point to the same piece of memory,
so modifying one value may change others.
Parameters
----------
x : 1D array or sequence
Array or sequence containing the data.
n : int
The number of data points in each window.
noverlap : int, default: 0 (no overlap)
The overlap between adjacent windows.
axis : int
The axis along which the windows will run.
References
----------
`stackoverflow: Rolling window for 1D arrays in Numpy?
<https://stackoverflow.com/a/6811241>`_
`stackoverflow: Using strides for an efficient moving average filter
<https://stackoverflow.com/a/4947453>`_
r r z%only 1-dimensional arrays can be used)r r$ r% �_stride_windows)r �n�noverlapr s r
�stride_windowsr= � s; � �< ���� �w�w�q�z�Q���@�A�A� �1�a��4� 0�0r c � � t t j j d� rT|dk( rO||k\ r t d� �t j j j | |d�� d d ||z
� j S ||k\ r t d� �|dk r t d� �t j | � } |dk( r:|dk( r5|dk( r| t j S | t j j S || j kD r t d� �t |� }t |� }||z
}|dk( r9|| j d |z
|z f}| j d || j d z f}n8| j d |z
|z |f}|| j d z | j d f}t j j j | ||� � S )
N�sliding_window_viewr z noverlap must be less than nr r zn cannot be less than 1z(n cannot be greater than the length of x���)�shape�strides)�hasattrr �lib�
stride_tricksr% r? �Tr# �newaxisr2 �intrA rB �
as_strided)r r; r< r �steprA rB s r
r: r: � s� � ��r�v�v�#�#�%:�;��� � �q�=� � ;�<� <��v�v�#�#�7�7�
�q�q� 8� �(�A��L�.�*�*+�!� ,� �1�}��7�8�8��1�u��2�3�3�
�
�
�1�
�A��A�v�(�a�-� �1�9��R�Z�Z�=� ��R�Z�Z�=�?�?� "��1�6�6�z��C�D�D� �8�}�H� �A��A� �x�<�D� �q�y��Q�W�W�R�[��)�D�0�1���9�9�Q�<��a�i�i��l�!2�3���'�'�"�+�h�&��-�q�1���� � �!� �$�a�i�i��l�3��
�6�6� � � *� *�1�E�7� *� K�Kr c �" � |�d} n|| u } |�d}|�d}|�t }|�t }|�d}|
�|
dk( rd}
t j g d�|
� � | s|
dk7 r t d
� �t j | � } | st j |� }|�|dk( rt j | � rd }nd }t j g d
�|�� t | � |k r&t | � } t j | |� } d| | d | s4t |� |k r&t |� } t j ||� }d|| d |�|}|
dk7 rd} n| �d} |d k( r|}
|dz r |dz
dz dz }n|dz }d}n |d k( r|dz r |dz dz }
n|dz dz }
d}t j |� s& |t j || j � � }t |� |k7 r t d� �t | ||� }t ||d�� }||j d� z }t
j j! ||d�� d
�dd�f }t
j j# |d|z � d|
}| sst |||� }t ||d�� }||j d� z }t
j j! ||d�� d|
�dd�f }t j$ |� |z }n�|
dk( rt j$ |� |z }n�|
dk( r:t j& |� t j& |� j) � z }nK|
dk( s|
dk( rt j* |� }n+|
dk( r&|t j& |� j) � z }|
dk( r�|dz st- ddd� }n
t- ddd� }||xx z cc< | r/||z }|t j& |� dz j) � z }n)|t j& |� j) � dz z }t j. |dz t | � |dz z
dz ||z
� |z }|d k( r3t j0 | d�� }t j0 || d�� }n|dz s
|dxx dz cc< |
dk( rt j2 |d�� }|||fS ) z�
Private helper implementing the common parts between the psd, csd,
spectrogram and complex, magnitude, angle, and phase spectrums.
NT� r � r �psd)r rN �complex� magnitude�angle�phase��modez*x and y must be equal if mode is not 'psd'�twosided�onesided)r rV rU )�sidesFr g �?� @z7The window length must match the data's first dimensionr )r@ r )r; r rP rQ rR rO r@ )r! r r �
check_in_listr% r r# � iscomplexobjr
�resize�iterable�onesr- r: r �reshape�fft�fftfreq�conj�abs�sumrQ �slicer1 �roll�unwrap)r r5 �NFFT�Fs� detrend_func�windowr< �pad_torW �
scale_by_freqrT � same_datar; �numFreqs�
freqcenter�scaling_factor�result�freqs�resultY�slc�ts r
�_spectral_helperrv # s� � � �y�� �
��F� � �z�
��������#� �
�~� �� �|��� �|�t�y�(������D�
�� ��� ��E�F�F� �
�
�1�
�A� � �J�J�q�M�� �}���*�
�?�?�1� � �E� �E����:�%�H� �1�v��}� ��F�� �I�I�a�� ����!�"�� ��Q��$� � ��F�� �I�I�a�� ����!�"��
�~��� �u�}� �
� � � �
�
�
���� �A�:� �1�*�q� �1�,�J� ���J��� �*� � �A�:� ��
�Q��H� �q�y�1�}�H���
�;�;�v� ������a�g�g�.�/��
�6�{�d��� E�G� G� �Q��h�
/�F�
�V�\��
2�F�
�f�n�n�W�-�
-�F�
�V�V�Z�Z��&�q�Z�
1�)�8�)�Q�,�
?�F� �F�F�N�N�6�1�R�4� (��(� 3�E� �!�!�T�8�4���'�<�a�8���F�N�N�7� 3�3���&�&�*�*�W��Q�*�7� �� �1� �E������ �7�*��
�� ����� �6�)��
�� ����� �"�&�&��.�"4�"4�"6�6��
�� �D�G�O����&�!��
�� ��"�&�&��.�$�$�&�&�� �u�}� �a�x���2�t�$�C� ��4��&�C��s� �~�%� �
� �b�L�F�
�r�v�v�f�~�q�(�-�-�/� /�F�
�b�f�f�V�n�(�(�*�A�-� -�F�
� � �$�q�&�#�a�&�4��6�/�A�-�t�h��?��B�A� �
������
�{��3������*��1�5��
�a�Z�
�b� �R�� � �w�����6��*�� �5�!� �r c
� � t j g d�| �� |� t |� }t |dt |� |t |d||d| �� \ }}}| dk7 r |j
}|j dk( r|j d d k( r |dd�df }||fS )
zu
Private helper implementing the commonality between the complex, magnitude,
angle, and phase spectrums.
)rO rP rQ rR rS Nr F� r r5 rg rh ri rj r< rk rW rl rT rO rL r )r rY r
rv r! �realr$ rA ) rT r rh rj rk rW �specrr �_s r
�_single_spectrum_helperr| � s� � � ���A��M�
�~��Q���%��T��A��2�3?��/0��,1�49�+/� 1�N�D�%�� �y���y�y�� �y�y�A�~�$�*�*�Q�-�1�,��A�q�D�z�� ��;�r aL Fs : float, default: 2
The sampling frequency (samples per time unit). It is used to calculate
the Fourier frequencies, *freqs*, in cycles per time unit.
window : callable or ndarray, default: `.window_hanning`
A function or a vector of length *NFFT*. To create window vectors see
`.window_hanning`, `.window_none`, `numpy.blackman`, `numpy.hamming`,
`numpy.bartlett`, `scipy.signal`, `scipy.signal.get_window`, etc. If a
function is passed as the argument, it must take a data segment as an
argument and return the windowed version of the segment.
sides : {'default', 'onesided', 'twosided'}, optional
Which sides of the spectrum to return. 'default' is one-sided for real
data and two-sided for complex data. 'onesided' forces the return of a
one-sided spectrum, while 'twosided' forces two-sided.a� pad_to : int, optional
The number of points to which the data segment is padded when performing
the FFT. While not increasing the actual resolution of the spectrum (the
minimum distance between resolvable peaks), this can give more points in
the plot, allowing for more detail. This corresponds to the *n* parameter
in the call to `~numpy.fft.fft`. The default is None, which sets *pad_to*
equal to the length of the input signal (i.e. no padding).af pad_to : int, optional
The number of points to which the data segment is padded when performing
the FFT. This can be different from *NFFT*, which specifies the number
of data points used. While not increasing the actual resolution of the
spectrum (the minimum distance between resolvable peaks), this can give
more points in the plot, allowing for more detail. This corresponds to
the *n* parameter in the call to `~numpy.fft.fft`. The default is None,
which sets *pad_to* equal to *NFFT*
NFFT : int, default: 256
The number of data points used in each block for the FFT. A power 2 is
most efficient. This should *NOT* be used to get zero padding, or the
scaling of the result will be incorrect; use *pad_to* for this instead.
detrend : {'none', 'mean', 'linear'} or callable, default: 'none'
The function applied to each segment before fft-ing, designed to remove
the mean or linear trend. Unlike in MATLAB, where the *detrend* parameter
is a vector, in Matplotlib it is a function. The :mod:`~matplotlib.mlab`
module defines `.detrend_none`, `.detrend_mean`, and `.detrend_linear`,
but you can use a custom function as well. You can also use a string to
choose one of the functions: 'none' calls `.detrend_none`. 'mean' calls
`.detrend_mean`. 'linear' calls `.detrend_linear`.
scale_by_freq : bool, default: True
Whether the resulting density values should be scaled by the scaling
frequency, which gives density in units of 1/Hz. This allows for
integration over the returned frequency values. The default is True for
MATLAB compatibility.)�Spectral�Single_Spectrum�PSDc �N � t | d||||||||��
\ } }
| j |
fS )a
Compute the power spectral density.
The power spectral density :math:`P_{xx}` by Welch's average
periodogram method. The vector *x* is divided into *NFFT* length
segments. Each segment is detrended by function *detrend* and
windowed by function *window*. *noverlap* gives the length of
the overlap between segments. The :math:`|\mathrm{fft}(i)|^2`
of each segment :math:`i` are averaged to compute :math:`P_{xx}`.
If len(*x*) < *NFFT*, it will be zero padded to *NFFT*.
Parameters
----------
x : 1-D array or sequence
Array or sequence containing the data
%(Spectral)s
%(PSD)s
noverlap : int, default: 0 (no overlap)
The number of points of overlap between segments.
Returns
-------
Pxx : 1-D array
The values for the power spectrum :math:`P_{xx}` (real valued)
freqs : 1-D array
The frequencies corresponding to the elements in *Pxx*
References
----------
Bendat & Piersol -- Random Data: Analysis and Measurement Procedures, John
Wiley & Sons (1986)
See Also
--------
specgram
`specgram` differs in the default overlap; in not returning the mean of
the segment periodograms; and in returning the times of the segments.
magnitude_spectrum : returns the magnitude spectrum.
csd : returns the spectral density between two signals.
N)
r r5 rg rh r rj r< rk rW rl )�csdry ) r rg rh r rj r< rk rW rl �Pxxrr s r
rN rN s9 � �d �q�D�t��G� "�X�f� �
�?�J�C�� �8�8�U�?�r c
�� � |�d}t | ||||||||| d�� \ }
} } |
j dk( r1|
j d dkD r|
j d�� }
|
| fS |
dd�df }
|
| fS ) a
Compute the cross-spectral density.
The cross spectral density :math:`P_{xy}` by Welch's average
periodogram method. The vectors *x* and *y* are divided into
*NFFT* length segments. Each segment is detrended by function
*detrend* and windowed by function *window*. *noverlap* gives
the length of the overlap between segments. The product of
the direct FFTs of *x* and *y* are averaged over each segment
to compute :math:`P_{xy}`, with a scaling to correct for power
loss due to windowing.
If len(*x*) < *NFFT* or len(*y*) < *NFFT*, they will be zero
padded to *NFFT*.
Parameters
----------
x, y : 1-D arrays or sequences
Arrays or sequences containing the data
%(Spectral)s
%(PSD)s
noverlap : int, default: 0 (no overlap)
The number of points of overlap between segments.
Returns
-------
Pxy : 1-D array
The values for the cross spectrum :math:`P_{xy}` before scaling (real
valued)
freqs : 1-D array
The frequencies corresponding to the elements in *Pxy*
References
----------
Bendat & Piersol -- Random Data: Analysis and Measurement Procedures, John
Wiley & Sons (1986)
See Also
--------
psd : equivalent to setting ``y = x``.
NrM rN rx rL r r r )rv r$ rA r )
r r5 rg rh r rj r< rk rW rl �Pxyrr r{ s
r
r� r� N s� � �` �|���$�q�A�D�R�29�&�.6�v�+0�
�*/� 1�M�C��� �x�x�1�}� �9�9�Q�<�!� ��(�(��(�"�C� ��:�� �a��d�)�C� ��:�r a9 Compute the {quantity} of *x*.
Data is padded to a length of *pad_to* and the windowing function *window* is
applied to the signal.
Parameters
----------
x : 1-D array or sequence
Array or sequence containing the data
{Spectral}
{Single_Spectrum}
Returns
-------
spectrum : 1-D array
The {quantity}.
freqs : 1-D array
The frequencies corresponding to the elements in *spectrum*.
See Also
--------
psd
Returns the power spectral density.
complex_spectrum
Returns the complex-valued frequency spectrum.
magnitude_spectrum
Returns the absolute value of the `complex_spectrum`.
angle_spectrum
Returns the angle of the `complex_spectrum`.
phase_spectrum
Returns the phase (unwrapped angle) of the `complex_spectrum`.
specgram
Can return the complex spectrum of segments within the signal.
rO �quantityz!complex-valued frequency spectrumrP z4magnitude (absolute value) of the frequency spectrumrQ z8angle of the frequency spectrum (wrapped phase spectrum)rR z:phase of the frequency spectrum (unwrapped phase spectrum)c
�� � |�d}|�d}t | � |k r%t j d|� dt | � � d�� t | d||||||||| �� \ }
} } | dk7 r |
j }
|
| | fS ) a
Compute a spectrogram.
Compute and plot a spectrogram of data in *x*. Data are split into
*NFFT* length segments and the spectrum of each section is
computed. The windowing function *window* is applied to each
segment, and the amount of overlap of each segment is
specified with *noverlap*.
Parameters
----------
x : array-like
1-D array or sequence.
%(Spectral)s
%(PSD)s
noverlap : int, default: 128
The number of points of overlap between blocks.
mode : str, default: 'psd'
What sort of spectrum to use:
'psd'
Returns the power spectral density.
'complex'
Returns the complex-valued frequency spectrum.
'magnitude'
Returns the magnitude spectrum.
'angle'
Returns the phase spectrum without unwrapping.
'phase'
Returns the phase spectrum with unwrapping.
Returns
-------
spectrum : array-like
2D array, columns are the periodograms of successive segments.
freqs : array-like
1-D array, frequencies corresponding to the rows in *spectrum*.
t : array-like
1-D array, the times corresponding to midpoints of segments
(i.e the columns in *spectrum*).
See Also
--------
psd : differs in the overlap and in the return values.
complex_spectrum : similar, but with complex valued frequencies.
magnitude_spectrum : similar single segment when *mode* is 'magnitude'.
angle_spectrum : similar to single segment when *mode* is 'angle'.
phase_spectrum : similar to single segment when *mode* is 'phase'.
Notes
-----
*detrend* and *scale_by_freq* only apply when *mode* is set to 'psd'.
N� rM z6Only one segment is calculated since parameter NFFT (=z) >= signal length (=z).rx rO )r
r �
warn_externalrv ry )
r rg rh r rj r< rk rW rl rT rz rr ru s
r
�specgramr� � s� � �| ���� �|���
�1�v��~� ��� %�%)�F�*?��A��x�r� K� L� &��T���3:�6�/7��,1�4A�+/� 1�N�D�%�� �y���y�y�� ���>�r rM rL r c
� � t | � d|z k r t d� �t | |||||||| � \ }
} t ||||||||| � \ } } t | ||||||||| �
\ }
} t j
|
� dz |
| z z }|| fS )a�
The coherence between *x* and *y*. Coherence is the normalized
cross spectral density:
.. math::
C_{xy} = \frac{|P_{xy}|^2}{P_{xx}P_{yy}}
Parameters
----------
x, y
Array or sequence containing the data
%(Spectral)s
%(PSD)s
noverlap : int, default: 0 (no overlap)
The number of points of overlap between segments.
Returns
-------
Cxy : 1-D array
The coherence vector.
freqs : 1-D array
The frequencies for the elements in *Cxy*.
See Also
--------
:func:`psd`, :func:`csd` :
For information about the methods used to compute :math:`P_{xy}`,
:math:`P_{xx}` and :math:`P_{yy}`.
rL zvCoherence is calculated by averaging over *NFFT* length segments. Your signal is too short for your choice of *NFFT*.)r
r% rN r� r rb )r r5 rg rh r rj r< rk rW rl r� �f�Pyyr� �Cxys r
�coherer� s� � �H �1�v��D����
M�N� N� ��D�"�g�v�x��� � �F�C��
��D�"�g�v�x��� � �F�C��
��A�t�R��&�(�F�E� � �F�C��
�&�&��+��
�c�C�i�
(�C� ��6�Mr c �2 � e Zd ZdZdd�Zd� Zd� ZeZd� ZeZ y)� GaussianKDEap
Representation of a kernel-density estimate using Gaussian kernels.
Parameters
----------
dataset : array-like
Datapoints to estimate from. In case of univariate data this is a 1-D
array, otherwise a 2D 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 `GaussianKDE` instance as only
parameter and return a scalar. If None (default), 'scott' is used.
Attributes
----------
dataset : ndarray
The dataset passed to the constructor.
dim : int
Number of dimensions.
num_dp : int
Number of datapoints.
factor : float
The bandwidth factor, obtained from `kde.covariance_factor`, with which
the covariance matrix is multiplied.
covariance : ndarray
The covariance matrix of *dataset*, scaled by the calculated bandwidth
(`kde.factor`).
inv_cov : ndarray
The inverse of *covariance*.
Methods
-------
kde.evaluate(points) : ndarray
Evaluate the estimated pdf on a provided set of points.
kde(points) : ndarray
Same as kde.evaluate(points)
Nc � � �� t j |� � _ t j � j � j dkD s t d� �t j � j � j \ � _ � _ ��n�t j �d� r� j � _ nrt j �d� r� j � _ nJt �t � rd� _ �fd�� _ n(t# �� r�� _ � fd�� _ n t d� �� j � � _ t' � d � sht j t j( � j dd
� � � � _ t j, j/ � j* � � _ � j* � j$ d z z � _ � j0 � j$ d z z � _ t j6 t j, j9 d t j: z � j2 z � � � j z � _ y )
Nr z.`dataset` input should have multiple elements.�scott� silvermanz use constantc � �� � S �Nr )� bw_methods �r
�<lambda>z&GaussianKDE.__init__.<locals>.<lambda>� s �� �Y� r c �& �� � j � � S r� )�
_bw_method��selfs �r
r� z&GaussianKDE.__init__.<locals>.<lambda>� s �� �T�_�_�T�-B� r zB`bw_method` should be 'scott', 'silverman', a scalar or a callable�
_data_inv_covF)�rowvarr. rL ) r �
atleast_2d�datasetr0 r2 r% rA �dim�num_dpr �
_str_equal�
scotts_factor�covariance_factor�silverman_factor�
isinstancer r� r" �factorrC r4 �data_covariance�linalg�inv� data_inv_cov�
covariance�inv_cov�sqrt�det�pi� norm_factor)r� r� r� s ` `r
�__init__zGaussianKDE.__init__w s� �� ��}�}�W�-�� ��x�x�� � �%�*�*�Q�.� � M�N� N� "���� � � 6� <� <� ���$�+� � � �
�
�
�i��
1�%)�%7�%7�D� "�
�
�
�i��
5�%)�%:�%:�D� "�
� �6�
*� ,�D�O�%6�D� "�
�i�
� '�D�O�%B�D� "� � 4� 5�
5� �,�,�.�� ��t�_�-�#%�=�=�����L�L� � � �$!�D� �
!#� � �
�
�d�.B�.B� C�D� � �.�.�����1A�A����(�(�4�;�;�!�+;�;�� � �G�G�B�I�I�M�M�!�b�e�e�)�d�o�o�2M�$N� O� "�k�k� *��r c �b � t j | j d| j dz z � S )N� �� �r �powerr� r� r� s r
r� zGaussianKDE.scotts_factor� s$ � ��x�x�� � �S�D�H�H�q�L�%9�:�:r c � � t j | j | j dz z dz d| j dz z � S )NrX g @r� r� r� r� s r
r� z GaussianKDE.silverman_factor� s= � ��x�x� �K�K�4�8�8�c�>� *�S� 0�#����A� �2F�H� Hr c � � t j |� }t j |� j \ }}|| j k7 r%t dj
|| j � � �t j |� }|| j k\ r�t | j � D ]} }| j dd�|t j f |z
}t j | j |� }t j ||z d�� dz }|t j | � z }� n�t |� D ]� }| j |dd�|t j f z
}t j | j |� }t j ||z d�� dz }t j t j | � d�� ||< �� || j z }|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
-------
(# 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.
z2points have dimension {}, dataset has dimension {}Nr r rX )r r� r0 rA r� r% �format�zerosr� �ranger� rG �dotr� rc �expr� ) r� �pointsr� �num_mrq �i�diff�tdiff�energys r
�evaluatezGaussianKDE.evaluate� s~ � �* � � �v�&���X�X�f�%�+�+�
��U� �$�(�(�?� � "�"(�&��d�h�h�"7�9�
9� ���%� �� �D�K�K� ��4�;�;�'�
2���|�|�A�q�"�*�*�$4�5��>�����t�|�|�T�2������u� �1�5��;�� �"�&�&�&��/�1��
2� �5�\�
<���|�|�f�Q��2�:�:�-=�&>�>�����t�|�|�T�2������u� �1�5��;�� �F�F�2�6�6�6�'�?�� ;��q� �
<� �$�*�*�*���
r r� )
�__name__�
__module__� __qualname__�__doc__r� r� r� r� r� �__call__r r r
r� r� K s. � �&�V'+�R;�H�
&��/�b �Hr r� )NNr� )Nr r/ )
NNNNNNNNNN)NNNN)NNNNNNNNr ) NNNNNNNNN)%r� � functools�numbersr �numpyr �
matplotlibr r r r r r r r! r �
deprecatedr= r: rv r| �interpd�update�dedent_interpdrN r� �_single_spectrum_docs�partial�complex_spectrumr� �params�magnitude_spectrum�angle_spectrum�phase_spectrumr� r� r� r r r
�<module>r� s ��2�h � � � .� .� �
�.<�b+�8
�, �D �� � ���!1� �!1�H#L�L BF�8<�:>�[ �~ ;?��6 � � � � �>�"B� �7 � 7 �t ���48�>B�4� �4�n ���7;�>B�<� �<�~#� �L %�9�$�$�%<�i�H� �7�0�7�7� !�
0� !���� � � !� � � '�Y�&�&�'>� �L� � 9� 2� 9� 9� !�
C� !���� � � !� � � #��"�"�#:�G�D��5�.�5�5� !�
G�!���� � �!�� � #��"�"�#:�G�D��5�.�5�5� !�
I�!���� � �!�� �
���9=�CG��O� �O�d ����a� �n��d�)�4�.� �.�bP� Pr