| 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/signal/__pycache__/ |
Upload File : |
�
d�c+ � � � d Z ddlZddlmZ ddlmZ ddlm Z ddl
m Z ddl m
Z
mZmZmZ ddlZg d �Z d(d �Z d)d�Z d*d�Z d*d�Z d+d�Zd,d�Zd,d �Z d-d �Z d.d"�Z d/d#�Z d0d$�Z d%� Z d&� Z d'� Z dS )1z Tools for spectral analysis.
� N)�fft� )� _signaltools)�
get_window)� _lombscargle)� const_ext�even_ext�odd_ext�zero_ext)
� periodogram�welch� lombscargle�csd� coherence� spectrogram�stft�istft�
check_COLA�
check_NOLAFc �� � t j | t j �� � } t j |t j �� � }t j |t j �� � }| j dk sJ �|j dk sJ �|j dk sJ �|r't | ||� � � z
|� � }nt | ||� � }|r|dt j ||� � z z }|S )a�
lombscargle(x, y, freqs)
Computes the Lomb-Scargle periodogram.
The Lomb-Scargle periodogram was developed by Lomb [1]_ and further
extended by Scargle [2]_ to find, and test the significance of weak
periodic signals with uneven temporal sampling.
When *normalize* is False (default) the computed periodogram
is unnormalized, it takes the value ``(A**2) * N/4`` for a harmonic
signal with amplitude A for sufficiently large N.
When *normalize* is True the computed periodogram is normalized by
the residuals of the data around a constant reference model (at zero).
Input arrays should be 1-D and will be cast to float64.
Parameters
----------
x : array_like
Sample times.
y : array_like
Measurement values.
freqs : array_like
Angular frequencies for output periodogram.
precenter : bool, optional
Pre-center measurement values by subtracting the mean.
normalize : bool, optional
Compute normalized periodogram.
Returns
-------
pgram : array_like
Lomb-Scargle periodogram.
Raises
------
ValueError
If the input arrays `x` and `y` do not have the same shape.
See Also
--------
istft: Inverse Short Time Fourier Transform
check_COLA: Check whether the Constant OverLap Add (COLA) constraint is met
welch: Power spectral density by Welch's method
spectrogram: Spectrogram by Welch's method
csd: Cross spectral density by Welch's method
Notes
-----
This subroutine calculates the periodogram using a slightly
modified algorithm due to Townsend [3]_ which allows the
periodogram to be calculated using only a single pass through
the input arrays for each frequency.
The algorithm running time scales roughly as O(x * freqs) or O(N^2)
for a large number of samples and frequencies.
References
----------
.. [1] N.R. Lomb "Least-squares frequency analysis of unequally spaced
data", Astrophysics and Space Science, vol 39, pp. 447-462, 1976
.. [2] J.D. Scargle "Studies in astronomical time series analysis. II -
Statistical aspects of spectral analysis of unevenly spaced data",
The Astrophysical Journal, vol 263, pp. 835-853, 1982
.. [3] R.H.D. Townsend, "Fast calculation of the Lomb-Scargle
periodogram using graphics processing units.", The Astrophysical
Journal Supplement Series, vol 191, pp. 247-253, 2010
Examples
--------
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
First define some input parameters for the signal:
>>> A = 2.
>>> w0 = 1. # rad/sec
>>> nin = 150
>>> nout = 100000
Randomly generate sample times:
>>> x = rng.uniform(0, 10*np.pi, nin)
Plot a sine wave for the selected times:
>>> y = A * np.cos(w0*x)
Define the array of frequencies for which to compute the periodogram:
>>> w = np.linspace(0.01, 10, nout)
Calculate Lomb-Scargle periodogram:
>>> import scipy.signal as signal
>>> pgram = signal.lombscargle(x, y, w, normalize=True)
Now make a plot of the input data:
>>> fig, (ax_t, ax_w) = plt.subplots(2, 1, constrained_layout=True)
>>> ax_t.plot(x, y, 'b+')
>>> ax_t.set_xlabel('Time [s]')
Then plot the normalized periodogram:
>>> ax_w.plot(w, pgram)
>>> ax_w.set_xlabel('Angular frequency [rad/s]')
>>> ax_w.set_ylabel('Normalized amplitude')
>>> plt.show()
��dtyper � )�np�ascontiguousarray�float64�ndimr �mean�dot)�x�y�freqs� precenter� normalize�pgrams �;/usr/lib/python3/dist-packages/scipy/signal/_spectral_py.pyr r s� � �r � �Q�b�j�1�1�1�A�
� �Q�b�j�1�1�1�A� � ��b�j� 9� 9� 9�E� �6�Q�;�;�;�;� �6�Q�;�;�;�;� �:��?�?�?�?�� *� �Q��A�F�F�H�H� �e�4�4��� �Q��5�)�)��� "�
��R�V�A�q�\�\�!�!�� �L� � �?�boxcar�constantT�density���c � � t j | � � } | j dk r2t j | j � � t j | j � � fS |�d}|�| j | }n�|| j | k r|}n�|| j | k r| j | }nk|| j | k rZt j dd� gt
| j � � z } t j d|� | |< | t | � � } |}d}t |d� � r|j |k rt d� � �t | |||d|||||��
�
S )a�
Estimate power spectral density using a periodogram.
Parameters
----------
x : array_like
Time series of measurement values
fs : float, optional
Sampling frequency of the `x` time series. Defaults to 1.0.
window : str or tuple or array_like, optional
Desired window to use. If `window` is a string or tuple, it is
passed to `get_window` to generate the window values, which are
DFT-even by default. See `get_window` for a list of windows and
required parameters. If `window` is array_like it will be used
directly as the window and its length must be equal to the length
of the axis over which the periodogram is computed. Defaults
to 'boxcar'.
nfft : int, optional
Length of the FFT used. If `None` the length of `x` will be
used.
detrend : str or function or `False`, optional
Specifies how to detrend each segment. If `detrend` is a
string, it is passed as the `type` argument to the `detrend`
function. If it is a function, it takes a segment and returns a
detrended segment. If `detrend` is `False`, no detrending is
done. Defaults to 'constant'.
return_onesided : bool, optional
If `True`, return a one-sided spectrum for real data. If
`False` return a two-sided spectrum. Defaults to `True`, but for
complex data, a two-sided spectrum is always returned.
scaling : { 'density', 'spectrum' }, optional
Selects between computing the power spectral density ('density')
where `Pxx` has units of V**2/Hz and computing the power
spectrum ('spectrum') where `Pxx` has units of V**2, if `x`
is measured in V and `fs` is measured in Hz. Defaults to
'density'
axis : int, optional
Axis along which the periodogram is computed; the default is
over the last axis (i.e. ``axis=-1``).
Returns
-------
f : ndarray
Array of sample frequencies.
Pxx : ndarray
Power spectral density or power spectrum of `x`.
See Also
--------
welch: Estimate power spectral density using Welch's method
lombscargle: Lomb-Scargle periodogram for unevenly sampled data
Notes
-----
.. versionadded:: 0.12.0
Examples
--------
>>> import numpy as np
>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
Generate a test signal, a 2 Vrms sine wave at 1234 Hz, corrupted by
0.001 V**2/Hz of white noise sampled at 10 kHz.
>>> fs = 10e3
>>> N = 1e5
>>> amp = 2*np.sqrt(2)
>>> freq = 1234.0
>>> noise_power = 0.001 * fs / 2
>>> time = np.arange(N) / fs
>>> x = amp*np.sin(2*np.pi*freq*time)
>>> x += rng.normal(scale=np.sqrt(noise_power), size=time.shape)
Compute and plot the power spectral density.
>>> f, Pxx_den = signal.periodogram(x, fs)
>>> plt.semilogy(f, Pxx_den)
>>> plt.ylim([1e-7, 1e2])
>>> plt.xlabel('frequency [Hz]')
>>> plt.ylabel('PSD [V**2/Hz]')
>>> plt.show()
If we average the last half of the spectral density, to exclude the
peak, we can recover the noise power on the signal.
>>> np.mean(Pxx_den[25000:])
0.000985320699252543
Now compute and plot the power spectrum.
>>> f, Pxx_spec = signal.periodogram(x, fs, 'flattop', scaling='spectrum')
>>> plt.figure()
>>> plt.semilogy(f, np.sqrt(Pxx_spec))
>>> plt.ylim([1e-4, 1e1])
>>> plt.xlabel('frequency [Hz]')
>>> plt.ylabel('Linear spectrum [V RMS]')
>>> plt.show()
The peak height in the power spectrum is an estimate of the RMS
amplitude.
>>> np.sqrt(Pxx_spec.max())
2.0077340678640727
r Nr) �sizezOthe size of the window must be the same size of the input on the specified axis) �fs�window�nperseg�noverlap�nfft�detrend�return_onesided�scaling�axis) r �asarrayr. �empty�shape�s_�len�tuple�hasattr�
ValueErrorr
)
r r/ r0 r3 r4 r5 r6 r7 r1 �ss
r& r r � sW � �Z �
�1�
�
�A��v��{�{��x��� � �"�(�1�7�"3�"3�3�3�
�~��� �|��'�$�-���
���� � � ����
����
� � ��'�$�-���
����
� � �
�U�1�1�1�X�J�s�1�7�|�|� #���%����,��$��
�e�A�h�h�K�������v�v� � � C� �;�'� !� !� � B� C� C�
C� ��r�&�'�A��G�_� �t� -� -� -� -r' �hannr c �P � t | | ||||||||| |
�� � \ } } | | j fS )a;
Estimate power spectral density using Welch's method.
Welch's method [1]_ computes an estimate of the power spectral
density by dividing the data into overlapping segments, computing a
modified periodogram for each segment and averaging the
periodograms.
Parameters
----------
x : array_like
Time series of measurement values
fs : float, optional
Sampling frequency of the `x` time series. Defaults to 1.0.
window : str or tuple or array_like, optional
Desired window to use. If `window` is a string or tuple, it is
passed to `get_window` to generate the window values, which are
DFT-even by default. See `get_window` for a list of windows and
required parameters. If `window` is array_like it will be used
directly as the window and its length must be nperseg. Defaults
to a Hann window.
nperseg : int, optional
Length of each segment. Defaults to None, but if window is str or
tuple, is set to 256, and if window is array_like, is set to the
length of the window.
noverlap : int, optional
Number of points to overlap between segments. If `None`,
``noverlap = nperseg // 2``. Defaults to `None`.
nfft : int, optional
Length of the FFT used, if a zero padded FFT is desired. If
`None`, the FFT length is `nperseg`. Defaults to `None`.
detrend : str or function or `False`, optional
Specifies how to detrend each segment. If `detrend` is a
string, it is passed as the `type` argument to the `detrend`
function. If it is a function, it takes a segment and returns a
detrended segment. If `detrend` is `False`, no detrending is
done. Defaults to 'constant'.
return_onesided : bool, optional
If `True`, return a one-sided spectrum for real data. If
`False` return a two-sided spectrum. Defaults to `True`, but for
complex data, a two-sided spectrum is always returned.
scaling : { 'density', 'spectrum' }, optional
Selects between computing the power spectral density ('density')
where `Pxx` has units of V**2/Hz and computing the power
spectrum ('spectrum') where `Pxx` has units of V**2, if `x`
is measured in V and `fs` is measured in Hz. Defaults to
'density'
axis : int, optional
Axis along which the periodogram is computed; the default is
over the last axis (i.e. ``axis=-1``).
average : { 'mean', 'median' }, optional
Method to use when averaging periodograms. Defaults to 'mean'.
.. versionadded:: 1.2.0
Returns
-------
f : ndarray
Array of sample frequencies.
Pxx : ndarray
Power spectral density or power spectrum of x.
See Also
--------
periodogram: Simple, optionally modified periodogram
lombscargle: Lomb-Scargle periodogram for unevenly sampled data
Notes
-----
An appropriate amount of overlap will depend on the choice of window
and on your requirements. For the default Hann window an overlap of
50% is a reasonable trade off between accurately estimating the
signal power, while not over counting any of the data. Narrower
windows may require a larger overlap.
If `noverlap` is 0, this method is equivalent to Bartlett's method
[2]_.
.. versionadded:: 0.12.0
References
----------
.. [1] P. Welch, "The use of the fast Fourier transform for the
estimation of power spectra: A method based on time averaging
over short, modified periodograms", IEEE Trans. Audio
Electroacoust. vol. 15, pp. 70-73, 1967.
.. [2] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra",
Biometrika, vol. 37, pp. 1-16, 1950.
Examples
--------
>>> import numpy as np
>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
Generate a test signal, a 2 Vrms sine wave at 1234 Hz, corrupted by
0.001 V**2/Hz of white noise sampled at 10 kHz.
>>> fs = 10e3
>>> N = 1e5
>>> amp = 2*np.sqrt(2)
>>> freq = 1234.0
>>> noise_power = 0.001 * fs / 2
>>> time = np.arange(N) / fs
>>> x = amp*np.sin(2*np.pi*freq*time)
>>> x += rng.normal(scale=np.sqrt(noise_power), size=time.shape)
Compute and plot the power spectral density.
>>> f, Pxx_den = signal.welch(x, fs, nperseg=1024)
>>> plt.semilogy(f, Pxx_den)
>>> plt.ylim([0.5e-3, 1])
>>> plt.xlabel('frequency [Hz]')
>>> plt.ylabel('PSD [V**2/Hz]')
>>> plt.show()
If we average the last half of the spectral density, to exclude the
peak, we can recover the noise power on the signal.
>>> np.mean(Pxx_den[256:])
0.0009924865443739191
Now compute and plot the power spectrum.
>>> f, Pxx_spec = signal.welch(x, fs, 'flattop', 1024, scaling='spectrum')
>>> plt.figure()
>>> plt.semilogy(f, np.sqrt(Pxx_spec))
>>> plt.xlabel('frequency [Hz]')
>>> plt.ylabel('Linear spectrum [V RMS]')
>>> plt.show()
The peak height in the power spectrum is an estimate of the RMS
amplitude.
>>> np.sqrt(Pxx_spec.max())
2.0077340678640727
If we now introduce a discontinuity in the signal, by increasing the
amplitude of a small portion of the signal by 50, we can see the
corruption of the mean average power spectral density, but using a
median average better estimates the normal behaviour.
>>> x[int(N//2):int(N//2)+10] *= 50.
>>> f, Pxx_den = signal.welch(x, fs, nperseg=1024)
>>> f_med, Pxx_den_med = signal.welch(x, fs, nperseg=1024, average='median')
>>> plt.semilogy(f, Pxx_den, label='mean')
>>> plt.semilogy(f_med, Pxx_den_med, label='median')
>>> plt.ylim([0.5e-3, 1])
>>> plt.xlabel('frequency [Hz]')
>>> plt.ylabel('PSD [V**2/Hz]')
>>> plt.legend()
>>> plt.show()
)
r/ r0 r1 r2 r3 r4 r5 r6 r7 �average)r �real)
r r/ r0 r1 r2 r3 r4 r5 r6 r7 rC r" �Pxxs
r& r
r
) sF � �| �Q��b��� &�T�7�%4�g� ��1� 1� 1�J�E�3�
�#�(�?�r' c � � t | ||||||||| |
d�� � \ } }
}t |j � � dk �r|j dk �r|j d dk r�| dk r�t |j d � � }t j |� � rUt j t j |� � d�� � d t j t j |� � d�� � z z }nt j |d�� � }||z }nQ| d
k r|�
d�� � }n4t d | ��� � �t j ||j d d� � � }| |fS )
ax
Estimate the cross power spectral density, Pxy, using Welch's method.
Parameters
----------
x : array_like
Time series of measurement values
y : array_like
Time series of measurement values
fs : float, optional
Sampling frequency of the `x` and `y` time series. Defaults
to 1.0.
window : str or tuple or array_like, optional
Desired window to use. If `window` is a string or tuple, it is
passed to `get_window` to generate the window values, which are
DFT-even by default. See `get_window` for a list of windows and
required parameters. If `window` is array_like it will be used
directly as the window and its length must be nperseg. Defaults
to a Hann window.
nperseg : int, optional
Length of each segment. Defaults to None, but if window is str or
tuple, is set to 256, and if window is array_like, is set to the
length of the window.
noverlap: int, optional
Number of points to overlap between segments. If `None`,
``noverlap = nperseg // 2``. Defaults to `None`.
nfft : int, optional
Length of the FFT used, if a zero padded FFT is desired. If
`None`, the FFT length is `nperseg`. Defaults to `None`.
detrend : str or function or `False`, optional
Specifies how to detrend each segment. If `detrend` is a
string, it is passed as the `type` argument to the `detrend`
function. If it is a function, it takes a segment and returns a
detrended segment. If `detrend` is `False`, no detrending is
done. Defaults to 'constant'.
return_onesided : bool, optional
If `True`, return a one-sided spectrum for real data. If
`False` return a two-sided spectrum. Defaults to `True`, but for
complex data, a two-sided spectrum is always returned.
scaling : { 'density', 'spectrum' }, optional
Selects between computing the cross spectral density ('density')
where `Pxy` has units of V**2/Hz and computing the cross spectrum
('spectrum') where `Pxy` has units of V**2, if `x` and `y` are
measured in V and `fs` is measured in Hz. Defaults to 'density'
axis : int, optional
Axis along which the CSD is computed for both inputs; the
default is over the last axis (i.e. ``axis=-1``).
average : { 'mean', 'median' }, optional
Method to use when averaging periodograms. If the spectrum is
complex, the average is computed separately for the real and
imaginary parts. Defaults to 'mean'.
.. versionadded:: 1.2.0
Returns
-------
f : ndarray
Array of sample frequencies.
Pxy : ndarray
Cross spectral density or cross power spectrum of x,y.
See Also
--------
periodogram: Simple, optionally modified periodogram
lombscargle: Lomb-Scargle periodogram for unevenly sampled data
welch: Power spectral density by Welch's method. [Equivalent to
csd(x,x)]
coherence: Magnitude squared coherence by Welch's method.
Notes
-----
By convention, Pxy is computed with the conjugate FFT of X
multiplied by the FFT of Y.
If the input series differ in length, the shorter series will be
zero-padded to match.
An appropriate amount of overlap will depend on the choice of window
and on your requirements. For the default Hann window an overlap of
50% is a reasonable trade off between accurately estimating the
signal power, while not over counting any of the data. Narrower
windows may require a larger overlap.
.. versionadded:: 0.16.0
References
----------
.. [1] P. Welch, "The use of the fast Fourier transform for the
estimation of power spectra: A method based on time averaging
over short, modified periodograms", IEEE Trans. Audio
Electroacoust. vol. 15, pp. 70-73, 1967.
.. [2] Rabiner, Lawrence R., and B. Gold. "Theory and Application of
Digital Signal Processing" Prentice-Hall, pp. 414-419, 1975
Examples
--------
>>> import numpy as np
>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
Generate two test signals with some common features.
>>> fs = 10e3
>>> N = 1e5
>>> amp = 20
>>> freq = 1234.0
>>> noise_power = 0.001 * fs / 2
>>> time = np.arange(N) / fs
>>> b, a = signal.butter(2, 0.25, 'low')
>>> x = rng.normal(scale=np.sqrt(noise_power), size=time.shape)
>>> y = signal.lfilter(b, a, x)
>>> x += amp*np.sin(2*np.pi*freq*time)
>>> y += rng.normal(scale=0.1*np.sqrt(noise_power), size=time.shape)
Compute and plot the magnitude of the cross spectral density.
>>> f, Pxy = signal.csd(x, y, fs, nperseg=1024)
>>> plt.semilogy(f, np.abs(Pxy))
>>> plt.xlabel('frequency [Hz]')
>>> plt.ylabel('CSD [V**2/Hz]')
>>> plt.show()
�psd��moder r r, r �median�r7 y �?r z(average must be "median" or "mean", got N)
�_spectral_helperr< r: r. � _median_biasr � iscomplexobjrJ rD �imagr r? �reshape)r r! r/ r0 r1 r2 r3 r4 r5 r6 r7 rC r" �_�Pxy�biass r& r r � sb � �~ %�Q��2�v�w��$�%,�o�w��*/�1� 1� 1�M�E�1�c�
�3�9�~�~����s�x�!�|�|� �9�R�=�1� � ��(�"�"�#�C�I�b�M�2�2���?�3�'�'� 2� �9�R�W�S�\�\��;�;�;� �"�)�B�G�C�L�L�r�"B�"B�"B� B� C�C�C� �)�C�b�1�1�1�C��t� ����F�"�"��h�h�B�h�'�'��� �j�$+�G�".� /� /� /� �*�S�#�)�C�R�C�.�1�1�C� �#�:�r' ��tukeyg �?rG c �� � g d�} |
| vr#t d� |
| � � � � �t ||| j | �� � \ }}|�|dz }|
dk r t | | ||||||||| d�� � \ } }
}nyt | | ||||||||| d�� � \ } }
}|
d k rt j |� � }n?|
d
v r;t j |� � }|
d k r!| d k r| d
z } t j || �� � }| |
|fS )a� Compute a spectrogram with consecutive Fourier transforms.
Spectrograms can be used as a way of visualizing the change of a
nonstationary signal's frequency content over time.
Parameters
----------
x : array_like
Time series of measurement values
fs : float, optional
Sampling frequency of the `x` time series. Defaults to 1.0.
window : str or tuple or array_like, optional
Desired window to use. If `window` is a string or tuple, it is
passed to `get_window` to generate the window values, which are
DFT-even by default. See `get_window` for a list of windows and
required parameters. If `window` is array_like it will be used
directly as the window and its length must be nperseg.
Defaults to a Tukey window with shape parameter of 0.25.
nperseg : int, optional
Length of each segment. Defaults to None, but if window is str or
tuple, is set to 256, and if window is array_like, is set to the
length of the window.
noverlap : int, optional
Number of points to overlap between segments. If `None`,
``noverlap = nperseg // 8``. Defaults to `None`.
nfft : int, optional
Length of the FFT used, if a zero padded FFT is desired. If
`None`, the FFT length is `nperseg`. Defaults to `None`.
detrend : str or function or `False`, optional
Specifies how to detrend each segment. If `detrend` is a
string, it is passed as the `type` argument to the `detrend`
function. If it is a function, it takes a segment and returns a
detrended segment. If `detrend` is `False`, no detrending is
done. Defaults to 'constant'.
return_onesided : bool, optional
If `True`, return a one-sided spectrum for real data. If
`False` return a two-sided spectrum. Defaults to `True`, but for
complex data, a two-sided spectrum is always returned.
scaling : { 'density', 'spectrum' }, optional
Selects between computing the power spectral density ('density')
where `Sxx` has units of V**2/Hz and computing the power
spectrum ('spectrum') where `Sxx` has units of V**2, if `x`
is measured in V and `fs` is measured in Hz. Defaults to
'density'.
axis : int, optional
Axis along which the spectrogram is computed; the default is over
the last axis (i.e. ``axis=-1``).
mode : str, optional
Defines what kind of return values are expected. Options are
['psd', 'complex', 'magnitude', 'angle', 'phase']. 'complex' is
equivalent to the output of `stft` with no padding or boundary
extension. 'magnitude' returns the absolute magnitude of the
STFT. 'angle' and 'phase' return the complex angle of the STFT,
with and without unwrapping, respectively.
Returns
-------
f : ndarray
Array of sample frequencies.
t : ndarray
Array of segment times.
Sxx : ndarray
Spectrogram of x. By default, the last axis of Sxx corresponds
to the segment times.
See Also
--------
periodogram: Simple, optionally modified periodogram
lombscargle: Lomb-Scargle periodogram for unevenly sampled data
welch: Power spectral density by Welch's method.
csd: Cross spectral density by Welch's method.
Notes
-----
An appropriate amount of overlap will depend on the choice of window
and on your requirements. In contrast to welch's method, where the
entire data stream is averaged over, one may wish to use a smaller
overlap (or perhaps none at all) when computing a spectrogram, to
maintain some statistical independence between individual segments.
It is for this reason that the default window is a Tukey window with
1/8th of a window's length overlap at each end.
.. versionadded:: 0.16.0
References
----------
.. [1] Oppenheim, Alan V., Ronald W. Schafer, John R. Buck
"Discrete-Time Signal Processing", Prentice Hall, 1999.
Examples
--------
>>> import numpy as np
>>> from scipy import signal
>>> from scipy.fft import fftshift
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
Generate a test signal, a 2 Vrms sine wave whose frequency is slowly
modulated around 3kHz, corrupted by white noise of exponentially
decreasing magnitude sampled at 10 kHz.
>>> fs = 10e3
>>> N = 1e5
>>> amp = 2 * np.sqrt(2)
>>> noise_power = 0.01 * fs / 2
>>> time = np.arange(N) / float(fs)
>>> mod = 500*np.cos(2*np.pi*0.25*time)
>>> carrier = amp * np.sin(2*np.pi*3e3*time + mod)
>>> noise = rng.normal(scale=np.sqrt(noise_power), size=time.shape)
>>> noise *= np.exp(-time/5)
>>> x = carrier + noise
Compute and plot the spectrogram.
>>> f, t, Sxx = signal.spectrogram(x, fs)
>>> plt.pcolormesh(t, f, Sxx, shading='gouraud')
>>> plt.ylabel('Frequency [Hz]')
>>> plt.xlabel('Time [sec]')
>>> plt.show()
Note, if using output that is not one sided, then use the following:
>>> f, t, Sxx = signal.spectrogram(x, fs, return_onesided=False)
>>> plt.pcolormesh(t, fftshift(f), fftshift(Sxx, axes=0), shading='gouraud')
>>> plt.ylabel('Frequency [Hz]')
>>> plt.xlabel('Time [sec]')
>>> plt.show()
)rG �complex� magnitude�angle�phasez,unknown value for mode {}, must be one of {}�� input_lengthN� rG rH r rX )rY rZ rZ r r rK ) r? �format�_triage_segmentsr: rL r �absrY �unwrap)r r/ r0 r1 r2 r3 r4 r5 r6 r7 rI �modelistr" �time�Sxxs r& r r i sg � �H A�@�@�H� �8����G� �&��x�0�0�2� 2� 2� '�v�w�45�G�D�M�C� C� C�O�F�G� ���a�<�� �u�}�}�+�A�q�"�f�g�,4�d�G�,;�W�d�16� 8� 8� 8���t�S�S� ,�A�q�"�f�g�,4�d�G�,;�W�d�17� 9� 9� 9���t�S�
�;� � ��&��+�+�C�C�
�'�
'�
'��(�3�-�-�C��w����!�8�8��A�I�D��i��$�/�/�/�� �$�� �r' 绽���|�=c � ��� t |� � }|dk rt d� � �||k rt d� � �t |� � }t | t � � st | � � t
u rt
| |� � �n[t j | � � �t �j
� � dk rt d� � ��j
d |k rt d� � �||z
�t ��fd�t |�z � � D � � � � }|�z dk r!|d|�z �xx �|�z d� z
cc< |t j
|� � z
}t j t j |� � � � |k S ) a� Check whether the Constant OverLap Add (COLA) constraint is met.
Parameters
----------
window : str or tuple or array_like
Desired window to use. If `window` is a string or tuple, it is
passed to `get_window` to generate the window values, which are
DFT-even by default. See `get_window` for a list of windows and
required parameters. If `window` is array_like it will be used
directly as the window and its length must be nperseg.
nperseg : int
Length of each segment.
noverlap : int
Number of points to overlap between segments.
tol : float, optional
The allowed variance of a bin's weighted sum from the median bin
sum.
Returns
-------
verdict : bool
`True` if chosen combination satisfies COLA within `tol`,
`False` otherwise
See Also
--------
check_NOLA: Check whether the Nonzero Overlap Add (NOLA) constraint is met
stft: Short Time Fourier Transform
istft: Inverse Short Time Fourier Transform
Notes
-----
In order to enable inversion of an STFT via the inverse STFT in
`istft`, it is sufficient that the signal windowing obeys the constraint of
"Constant OverLap Add" (COLA). This ensures that every point in the input
data is equally weighted, thereby avoiding aliasing and allowing full
reconstruction.
Some examples of windows that satisfy COLA:
- Rectangular window at overlap of 0, 1/2, 2/3, 3/4, ...
- Bartlett window at overlap of 1/2, 3/4, 5/6, ...
- Hann window at 1/2, 2/3, 3/4, ...
- Any Blackman family window at 2/3 overlap
- Any window with ``noverlap = nperseg-1``
A very comprehensive list of other windows may be found in [2]_,
wherein the COLA condition is satisfied when the "Amplitude
Flatness" is unity.
.. versionadded:: 0.19.0
References
----------
.. [1] Julius O. Smith III, "Spectral Audio Signal Processing", W3K
Publishing, 2011,ISBN 978-0-9745607-3-1.
.. [2] G. Heinzel, A. Ruediger and R. Schilling, "Spectrum and
spectral density estimation by the Discrete Fourier transform
(DFT), including a comprehensive list of window functions and
some new at-top windows", 2002,
http://hdl.handle.net/11858/00-001M-0000-0013-557A-5
Examples
--------
>>> from scipy import signal
Confirm COLA condition for rectangular window of 75% (3/4) overlap:
>>> signal.check_COLA(signal.windows.boxcar(100), 100, 75)
True
COLA is not true for 25% (1/4) overlap, though:
>>> signal.check_COLA(signal.windows.boxcar(100), 100, 25)
False
"Symmetrical" Hann window (for filter design) is not COLA:
>>> signal.check_COLA(signal.windows.hann(120, sym=True), 120, 60)
False
"Periodic" or "DFT-even" Hann window (for FFT analysis) is COLA for
overlap of 1/2, 2/3, 3/4, etc.:
>>> signal.check_COLA(signal.windows.hann(120, sym=False), 120, 60)
True
>>> signal.check_COLA(signal.windows.hann(120, sym=False), 120, 80)
True
>>> signal.check_COLA(signal.windows.hann(120, sym=False), 120, 90)
True
r �"nperseg must be a positive integer�#noverlap must be less than nperseg.�window must be 1-Dr �"window must have length of npersegc 3 �> �K � | ]}�|�z |d z �z � V � �dS )r N� ��.0�ii�step�wins ��r& � <genexpr>z check_COLA.<locals>.<genexpr>� s9 �� � � �J�J�r�#�b��g�r�!�t�T�k�)�*�J�J�J�J�J�Jr' N)�intr? �
isinstance�str�typer= r r r8 r< r: �sum�rangerJ �maxr` )r0 r1 r2 �tol�binsums� deviationrp rq s @@r& r r s� ��� �| �'�l�l�G���{�{��=�>�>�>��7����>�?�?�?��8�}�}�H��&�#� � � C�$�v�,�,�%�"7�"7����)�)����j�� � �� �s�y�>�>�Q� � � � 1�2�2� 2� �9�Q�<�7� "� "� � A�B�B� B� �X� �D��J�J�J�J�J�U�7�D�=�5I�5I�J�J�J�J�J�G���~�������4� �� � � �C�'�D�.�(9�(:�(:�$;�;� � � ��"�)�G�,�,�,�I�
�6�"�&��#�#� $� $�s� *�*r' c �� ��� t |� � }|dk rt d� � �||k rt d� � �|dk rt d� � �t |� � }t | t � � st | � � t
u rt
| |� � �n[t j | � � �t �j
� � dk rt d� � ��j
d |k rt d� � �||z
�t ��fd�t |�z � � D � � � � }|�z dk r$|d |�z �xx �|�z d � d
z z
cc< t j
|� � |k S ) aH Check whether the Nonzero Overlap Add (NOLA) constraint is met.
Parameters
----------
window : str or tuple or array_like
Desired window to use. If `window` is a string or tuple, it is
passed to `get_window` to generate the window values, which are
DFT-even by default. See `get_window` for a list of windows and
required parameters. If `window` is array_like it will be used
directly as the window and its length must be nperseg.
nperseg : int
Length of each segment.
noverlap : int
Number of points to overlap between segments.
tol : float, optional
The allowed variance of a bin's weighted sum from the median bin
sum.
Returns
-------
verdict : bool
`True` if chosen combination satisfies the NOLA constraint within
`tol`, `False` otherwise
See Also
--------
check_COLA: Check whether the Constant OverLap Add (COLA) constraint is met
stft: Short Time Fourier Transform
istft: Inverse Short Time Fourier Transform
Notes
-----
In order to enable inversion of an STFT via the inverse STFT in
`istft`, the signal windowing must obey the constraint of "nonzero
overlap add" (NOLA):
.. math:: \sum_{t}w^{2}[n-tH] \ne 0
for all :math:`n`, where :math:`w` is the window function, :math:`t` is the
frame index, and :math:`H` is the hop size (:math:`H` = `nperseg` -
`noverlap`).
This ensures that the normalization factors in the denominator of the
overlap-add inversion equation are not zero. Only very pathological windows
will fail the NOLA constraint.
.. versionadded:: 1.2.0
References
----------
.. [1] Julius O. Smith III, "Spectral Audio Signal Processing", W3K
Publishing, 2011,ISBN 978-0-9745607-3-1.
.. [2] G. Heinzel, A. Ruediger and R. Schilling, "Spectrum and
spectral density estimation by the Discrete Fourier transform
(DFT), including a comprehensive list of window functions and
some new at-top windows", 2002,
http://hdl.handle.net/11858/00-001M-0000-0013-557A-5
Examples
--------
>>> import numpy as np
>>> from scipy import signal
Confirm NOLA condition for rectangular window of 75% (3/4) overlap:
>>> signal.check_NOLA(signal.windows.boxcar(100), 100, 75)
True
NOLA is also true for 25% (1/4) overlap:
>>> signal.check_NOLA(signal.windows.boxcar(100), 100, 25)
True
"Symmetrical" Hann window (for filter design) is also NOLA:
>>> signal.check_NOLA(signal.windows.hann(120, sym=True), 120, 60)
True
As long as there is overlap, it takes quite a pathological window to fail
NOLA:
>>> w = np.ones(64, dtype="float")
>>> w[::2] = 0
>>> signal.check_NOLA(w, 64, 32)
False
If there is not enough overlap, a window with zeros at the ends will not
work:
>>> signal.check_NOLA(signal.windows.hann(64), 64, 0)
False
>>> signal.check_NOLA(signal.windows.hann(64), 64, 1)
False
>>> signal.check_NOLA(signal.windows.hann(64), 64, 2)
True
r rg z"noverlap must be less than npersegr z&noverlap must be a nonnegative integerri rj c 3 �D �K � | ]}�|�z |d z �z � dz V � �dS )r r Nrl rm s ��r& rr z check_NOLA.<locals>.<genexpr> s> �� � � �M�M�"�#�b��g�r�!�t�T�k�)�*�A�-�M�M�M�M�M�Mr' Nr )rs r? rt ru rv r= r r r8 r< r: rw rx �min)r0 r1 r2 rz r{ rp rq s @@r& r r � s� ��� �D �'�l�l�G���{�{��=�>�>�>��7����=�>�>�>��!�|�|��A�B�B�B��8�}�}�H��&�#� � � C�$�v�,�,�%�"7�"7����)�)����j�� � �� �s�y�>�>�Q� � � � 1�2�2� 2� �9�Q�<�7� "� "� � A�B�B� B� �X� �D��M�M�M�M�M��g�t�m�8L�8L�M�M�M�M�M�G���~�������4� �� � � �C�'�D�.�(9�(:�(:�$;�Q�$>�>� � � �
�6�'�?�?�S� � r' � �zeros�spectrumc � � | dk rd} n| dk rt d| �d�� � �t | | |||||||| |
d|| �� � \ } }
}| |
|fS )a� Compute the Short Time Fourier Transform (STFT).
STFTs can be used as a way of quantifying the change of a
nonstationary signal's frequency and phase content over time.
Parameters
----------
x : array_like
Time series of measurement values
fs : float, optional
Sampling frequency of the `x` time series. Defaults to 1.0.
window : str or tuple or array_like, optional
Desired window to use. If `window` is a string or tuple, it is
passed to `get_window` to generate the window values, which are
DFT-even by default. See `get_window` for a list of windows and
required parameters. If `window` is array_like it will be used
directly as the window and its length must be nperseg. Defaults
to a Hann window.
nperseg : int, optional
Length of each segment. Defaults to 256.
noverlap : int, optional
Number of points to overlap between segments. If `None`,
``noverlap = nperseg // 2``. Defaults to `None`. When
specified, the COLA constraint must be met (see Notes below).
nfft : int, optional
Length of the FFT used, if a zero padded FFT is desired. If
`None`, the FFT length is `nperseg`. Defaults to `None`.
detrend : str or function or `False`, optional
Specifies how to detrend each segment. If `detrend` is a
string, it is passed as the `type` argument to the `detrend`
function. If it is a function, it takes a segment and returns a
detrended segment. If `detrend` is `False`, no detrending is
done. Defaults to `False`.
return_onesided : bool, optional
If `True`, return a one-sided spectrum for real data. If
`False` return a two-sided spectrum. Defaults to `True`, but for
complex data, a two-sided spectrum is always returned.
boundary : str or None, optional
Specifies whether the input signal is extended at both ends, and
how to generate the new values, in order to center the first
windowed segment on the first input point. This has the benefit
of enabling reconstruction of the first input point when the
employed window function starts at zero. Valid options are
``['even', 'odd', 'constant', 'zeros', None]``. Defaults to
'zeros', for zero padding extension. I.e. ``[1, 2, 3, 4]`` is
extended to ``[0, 1, 2, 3, 4, 0]`` for ``nperseg=3``.
padded : bool, optional
Specifies whether the input signal is zero-padded at the end to
make the signal fit exactly into an integer number of window
segments, so that all of the signal is included in the output.
Defaults to `True`. Padding occurs after boundary extension, if
`boundary` is not `None`, and `padded` is `True`, as is the
default.
axis : int, optional
Axis along which the STFT is computed; the default is over the
last axis (i.e. ``axis=-1``).
scaling: {'spectrum', 'psd'}
The default 'spectrum' scaling allows each frequency line of `Zxx` to
be interpreted as a magnitude spectrum. The 'psd' option scales each
line to a power spectral density - it allows to calculate the signal's
energy by numerically integrating over ``abs(Zxx)**2``.
.. versionadded:: 1.9.0
Returns
-------
f : ndarray
Array of sample frequencies.
t : ndarray
Array of segment times.
Zxx : ndarray
STFT of `x`. By default, the last axis of `Zxx` corresponds
to the segment times.
See Also
--------
istft: Inverse Short Time Fourier Transform
check_COLA: Check whether the Constant OverLap Add (COLA) constraint
is met
check_NOLA: Check whether the Nonzero Overlap Add (NOLA) constraint is met
welch: Power spectral density by Welch's method.
spectrogram: Spectrogram by Welch's method.
csd: Cross spectral density by Welch's method.
lombscargle: Lomb-Scargle periodogram for unevenly sampled data
Notes
-----
In order to enable inversion of an STFT via the inverse STFT in
`istft`, the signal windowing must obey the constraint of "Nonzero
OverLap Add" (NOLA), and the input signal must have complete
windowing coverage (i.e. ``(x.shape[axis] - nperseg) %
(nperseg-noverlap) == 0``). The `padded` argument may be used to
accomplish this.
Given a time-domain signal :math:`x[n]`, a window :math:`w[n]`, and a hop
size :math:`H` = `nperseg - noverlap`, the windowed frame at time index
:math:`t` is given by
.. math:: x_{t}[n]=x[n]w[n-tH]
The overlap-add (OLA) reconstruction equation is given by
.. math:: x[n]=\frac{\sum_{t}x_{t}[n]w[n-tH]}{\sum_{t}w^{2}[n-tH]}
The NOLA constraint ensures that every normalization term that appears
in the denomimator of the OLA reconstruction equation is nonzero. Whether a
choice of `window`, `nperseg`, and `noverlap` satisfy this constraint can
be tested with `check_NOLA`.
.. versionadded:: 0.19.0
References
----------
.. [1] Oppenheim, Alan V., Ronald W. Schafer, John R. Buck
"Discrete-Time Signal Processing", Prentice Hall, 1999.
.. [2] Daniel W. Griffin, Jae S. Lim "Signal Estimation from
Modified Short-Time Fourier Transform", IEEE 1984,
10.1109/TASSP.1984.1164317
Examples
--------
>>> import numpy as np
>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
Generate a test signal, a 2 Vrms sine wave whose frequency is slowly
modulated around 3kHz, corrupted by white noise of exponentially
decreasing magnitude sampled at 10 kHz.
>>> fs = 10e3
>>> N = 1e5
>>> amp = 2 * np.sqrt(2)
>>> noise_power = 0.01 * fs / 2
>>> time = np.arange(N) / float(fs)
>>> mod = 500*np.cos(2*np.pi*0.25*time)
>>> carrier = amp * np.sin(2*np.pi*3e3*time + mod)
>>> noise = rng.normal(scale=np.sqrt(noise_power),
... size=time.shape)
>>> noise *= np.exp(-time/5)
>>> x = carrier + noise
Compute and plot the STFT's magnitude.
>>> f, t, Zxx = signal.stft(x, fs, nperseg=1000)
>>> plt.pcolormesh(t, f, np.abs(Zxx), vmin=0, vmax=amp, shading='gouraud')
>>> plt.title('STFT Magnitude')
>>> plt.ylabel('Frequency [Hz]')
>>> plt.xlabel('Time [sec]')
>>> plt.show()
Compare the energy of the signal `x` with the energy of its STFT:
>>> E_x = sum(x**2) / fs # Energy of x
>>> # Calculate a two-sided STFT with PSD scaling:
>>> f, t, Zxx = signal.stft(x, fs, nperseg=1000, return_onesided=False,
... scaling='psd')
>>> # Integrate numerically over abs(Zxx)**2:
>>> df, dt = f[1] - f[0], t[1] - t[0]
>>> E_Zxx = sum(np.sum(Zxx.real**2 + Zxx.imag**2, axis=0) * df) * dt
>>> # The energy is the same, but the numerical errors are quite large:
>>> np.isclose(E_x, E_Zxx, rtol=1e-2)
True
rG r+ r� �Parameter scaling=� not in ['spectrum', 'psd']!r )r6 r7 rI �boundary�padded)r? rL )r r/ r0 r1 r2 r3 r4 r5 r� r� r7 r6 r" rc �Zxxs r& r r s� � �P �%������ �J� � ��L�g�L�L�L�M�M�M�'��1�b�&�'�8�(,�g��07�d�-3�h�/5� 7� 7� 7��E�4�� �$�� �r' ���c �� � t j | � � dz } t | � � } t |� � }| j dk rt d� � �| |k rt d� � �| j | } |rd| j | dz
z } n
| j | } |�| }n$t |� � }|dk rt d� � �|�|r || dz k r|}n'| }n$||k rt d� � �t |� � }|�|dz }nt |� � }||k rt d � � �||z
}
|| j dz
k s| | j dz
k r�| d
k r
| j | z } |d
k r
| j |z }t
t | j � � � � }t || gd � � � D ]}|� |� � �t j
| || |gz � � } t |t � � st |� � t u rt ||� � }nnt j |� � }t! |j � � dk rt d
� � �|j d
|k r"t d� |� � � � �|r t$ j n t$ j } || d|�� � dd|�dd�f }|| dz
|
z z }t j t
| j dd� � � |gz |j �� � }t j ||j �� � }t j ||� � |j k r|� |j � � }|
dk r||� � � z }nD|
dk r+|t j |t3 |dz � � z � � z }nt d|
�d�� � �t | � � D ]J}|d||
z ||
z |z �fxx |d|f |z z
cc< |d||
z ||
z |z �fxx |dz z
cc< �K|r&|d|dz |dz �f }|d|dz |dz �f }t j |dk � � t! |� � k rt7 j d� � |t j |dk |d� � z }|r|j }|j dk r/|| j dz
k r!| |k r|dz }t j |d|� � }t j |j d
� � tC |� � z }||fS )a� Perform the inverse Short Time Fourier transform (iSTFT).
Parameters
----------
Zxx : array_like
STFT of the signal to be reconstructed. If a purely real array
is passed, it will be cast to a complex data type.
fs : float, optional
Sampling frequency of the time series. Defaults to 1.0.
window : str or tuple or array_like, optional
Desired window to use. If `window` is a string or tuple, it is
passed to `get_window` to generate the window values, which are
DFT-even by default. See `get_window` for a list of windows and
required parameters. If `window` is array_like it will be used
directly as the window and its length must be nperseg. Defaults
to a Hann window. Must match the window used to generate the
STFT for faithful inversion.
nperseg : int, optional
Number of data points corresponding to each STFT segment. This
parameter must be specified if the number of data points per
segment is odd, or if the STFT was padded via ``nfft >
nperseg``. If `None`, the value depends on the shape of
`Zxx` and `input_onesided`. If `input_onesided` is `True`,
``nperseg=2*(Zxx.shape[freq_axis] - 1)``. Otherwise,
``nperseg=Zxx.shape[freq_axis]``. Defaults to `None`.
noverlap : int, optional
Number of points to overlap between segments. If `None`, half
of the segment length. Defaults to `None`. When specified, the
COLA constraint must be met (see Notes below), and should match
the parameter used to generate the STFT. Defaults to `None`.
nfft : int, optional
Number of FFT points corresponding to each STFT segment. This
parameter must be specified if the STFT was padded via ``nfft >
nperseg``. If `None`, the default values are the same as for
`nperseg`, detailed above, with one exception: if
`input_onesided` is True and
``nperseg==2*Zxx.shape[freq_axis] - 1``, `nfft` also takes on
that value. This case allows the proper inversion of an
odd-length unpadded STFT using ``nfft=None``. Defaults to
`None`.
input_onesided : bool, optional
If `True`, interpret the input array as one-sided FFTs, such
as is returned by `stft` with ``return_onesided=True`` and
`numpy.fft.rfft`. If `False`, interpret the input as a a
two-sided FFT. Defaults to `True`.
boundary : bool, optional
Specifies whether the input signal was extended at its
boundaries by supplying a non-`None` ``boundary`` argument to
`stft`. Defaults to `True`.
time_axis : int, optional
Where the time segments of the STFT is located; the default is
the last axis (i.e. ``axis=-1``).
freq_axis : int, optional
Where the frequency axis of the STFT is located; the default is
the penultimate axis (i.e. ``axis=-2``).
scaling: {'spectrum', 'psd'}
The default 'spectrum' scaling allows each frequency line of `Zxx` to
be interpreted as a magnitude spectrum. The 'psd' option scales each
line to a power spectral density - it allows to calculate the signal's
energy by numerically integrating over ``abs(Zxx)**2``.
Returns
-------
t : ndarray
Array of output data times.
x : ndarray
iSTFT of `Zxx`.
See Also
--------
stft: Short Time Fourier Transform
check_COLA: Check whether the Constant OverLap Add (COLA) constraint
is met
check_NOLA: Check whether the Nonzero Overlap Add (NOLA) constraint is met
Notes
-----
In order to enable inversion of an STFT via the inverse STFT with
`istft`, the signal windowing must obey the constraint of "nonzero
overlap add" (NOLA):
.. math:: \sum_{t}w^{2}[n-tH] \ne 0
This ensures that the normalization factors that appear in the denominator
of the overlap-add reconstruction equation
.. math:: x[n]=\frac{\sum_{t}x_{t}[n]w[n-tH]}{\sum_{t}w^{2}[n-tH]}
are not zero. The NOLA constraint can be checked with the `check_NOLA`
function.
An STFT which has been modified (via masking or otherwise) is not
guaranteed to correspond to a exactly realizible signal. This
function implements the iSTFT via the least-squares estimation
algorithm detailed in [2]_, which produces a signal that minimizes
the mean squared error between the STFT of the returned signal and
the modified STFT.
.. versionadded:: 0.19.0
References
----------
.. [1] Oppenheim, Alan V., Ronald W. Schafer, John R. Buck
"Discrete-Time Signal Processing", Prentice Hall, 1999.
.. [2] Daniel W. Griffin, Jae S. Lim "Signal Estimation from
Modified Short-Time Fourier Transform", IEEE 1984,
10.1109/TASSP.1984.1164317
Examples
--------
>>> import numpy as np
>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
Generate a test signal, a 2 Vrms sine wave at 50Hz corrupted by
0.001 V**2/Hz of white noise sampled at 1024 Hz.
>>> fs = 1024
>>> N = 10*fs
>>> nperseg = 512
>>> amp = 2 * np.sqrt(2)
>>> noise_power = 0.001 * fs / 2
>>> time = np.arange(N) / float(fs)
>>> carrier = amp * np.sin(2*np.pi*50*time)
>>> noise = rng.normal(scale=np.sqrt(noise_power),
... size=time.shape)
>>> x = carrier + noise
Compute the STFT, and plot its magnitude
>>> f, t, Zxx = signal.stft(x, fs=fs, nperseg=nperseg)
>>> plt.figure()
>>> plt.pcolormesh(t, f, np.abs(Zxx), vmin=0, vmax=amp, shading='gouraud')
>>> plt.ylim([f[1], f[-1]])
>>> plt.title('STFT Magnitude')
>>> plt.ylabel('Frequency [Hz]')
>>> plt.xlabel('Time [sec]')
>>> plt.yscale('log')
>>> plt.show()
Zero the components that are 10% or less of the carrier magnitude,
then convert back to a time series via inverse STFT
>>> Zxx = np.where(np.abs(Zxx) >= amp/10, Zxx, 0)
>>> _, xrec = signal.istft(Zxx, fs)
Compare the cleaned signal with the original and true carrier signals.
>>> plt.figure()
>>> plt.plot(time, x, time, xrec, time, carrier)
>>> plt.xlim([2, 2.1])
>>> plt.xlabel('Time [sec]')
>>> plt.ylabel('Signal')
>>> plt.legend(['Carrier + Noise', 'Filtered via STFT', 'True Carrier'])
>>> plt.show()
Note that the cleaned signal does not start as abruptly as the original,
since some of the coefficients of the transient were also removed:
>>> plt.figure()
>>> plt.plot(time, x, time, xrec, time, carrier)
>>> plt.xlim([0, 0.1])
>>> plt.xlabel('Time [sec]')
>>> plt.ylabel('Signal')
>>> plt.legend(['Carrier + Noise', 'Filtered via STFT', 'True Carrier'])
>>> plt.show()
y r z Input stft must be at least 2d!z/Must specify differing time and frequency axes!r Nrg �.nfft must be greater than or equal to nperseg.rh r T)�reverseri z window must have length of {0}r� )r7 �n.r r� rG r� r� re z1NOLA condition failed, STFT may not be invertibler( r, )"r r8 rs r r? r: �listrx �sorted�pop� transposert ru rv r= r r< r^ �sp_fft�irfft�ifftr� r � result_type�astyperw �sqrt�warnings�warn�whererD �moveaxis�arange�float)r� r/ r0 r1 r2 r3 �input_onesidedr� � time_axis� freq_axisr6 �nseg� n_default�nstep�zouter�axrq �ifunc�xsubs� outputlengthr �normro rc s r& r r � sf � �Z
�*�S�/�/�B�
�C��I���I��I���I�
�x�!�|�|��:�;�;�;��I� � ��J�K�K�K� �9�Y� �D�� )��s�y��+�a�/�0� � ��I�i�(� � ������g�,�,�� �Q�;�;� � A�B�B� B� �|� � ��I��M�!9�!9��D�D� �D�D�
�� � ��I�J�J�J��4�y�y�����A�:����x�=�=���7����>�?�?�?� �h� �E� �C�H�Q�J� � �)�s�x��z�"9�"9� �q�=�=���9�,�I� �q�=�=���9�,�I��e�C�H�o�o�&�&���)�Y�/��>�>�>� � �B� �J�J�r�N�N�N�N��l�3�� �9�'=� =�>�>�� �&�#� � � O�$�v�,�,�%�"7�"7����)�)����j�� � �� �s�y�>�>�Q� � � � 1�2�2� 2� �9�Q�<�7� "� "� � =� D� D�W� M� M�N�N� N� *� ;�F�L�L�� �E� �E�#�B�$� '� '� '��X�g�X�q�q�q�(8� 9�E� �d�1�f�e�^�+�L�
���c�i����n�%�%�|�n�4�E�K�H�H�H�A�
�8�L�� � 4� 4� 4�D� �~�c�5�!�!�U�[�0�0��j�j���%�%���*� � �
��������� �E� � �
����c�#�q�&�k�k�)�*�*�*����L�g�L�L�L�M�M�M� �D�k�k� 7� 7�� �#�r�%�x��5���(�(�
(�)�)�)�U�3��7�^�c�-A�A�)�)�)� �S�"�U�(�2�e�8�G�+�+�
+�,�,�,��Q��6�,�,�,�,� � 3�
�c�7�A�:���
�m�+�+� ,���C��!��g�q�j�M�1�1�2��
�v�d�U�l���s�4�y�y�(�(��
�I�J�J�J����$��,��c� *� *�*�A�� �
�F�� �v��z�z� ����
� "� "��9�$�$��Q�� �� �A�r�9�-�-�A�
�9�Q�W�Q�Z� � ��r��� *�D� ��7�Nr' c �� � t | |||||||�� � \ } }
t ||||||||�� � \ } } t | ||||||||�� � \ } }
t j |
� � dz |
z | z }| |fS )a�
Estimate the magnitude squared coherence estimate, Cxy, of
discrete-time signals X and Y using Welch's method.
``Cxy = abs(Pxy)**2/(Pxx*Pyy)``, where `Pxx` and `Pyy` are power
spectral density estimates of X and Y, and `Pxy` is the cross
spectral density estimate of X and Y.
Parameters
----------
x : array_like
Time series of measurement values
y : array_like
Time series of measurement values
fs : float, optional
Sampling frequency of the `x` and `y` time series. Defaults
to 1.0.
window : str or tuple or array_like, optional
Desired window to use. If `window` is a string or tuple, it is
passed to `get_window` to generate the window values, which are
DFT-even by default. See `get_window` for a list of windows and
required parameters. If `window` is array_like it will be used
directly as the window and its length must be nperseg. Defaults
to a Hann window.
nperseg : int, optional
Length of each segment. Defaults to None, but if window is str or
tuple, is set to 256, and if window is array_like, is set to the
length of the window.
noverlap: int, optional
Number of points to overlap between segments. If `None`,
``noverlap = nperseg // 2``. Defaults to `None`.
nfft : int, optional
Length of the FFT used, if a zero padded FFT is desired. If
`None`, the FFT length is `nperseg`. Defaults to `None`.
detrend : str or function or `False`, optional
Specifies how to detrend each segment. If `detrend` is a
string, it is passed as the `type` argument to the `detrend`
function. If it is a function, it takes a segment and returns a
detrended segment. If `detrend` is `False`, no detrending is
done. Defaults to 'constant'.
axis : int, optional
Axis along which the coherence is computed for both inputs; the
default is over the last axis (i.e. ``axis=-1``).
Returns
-------
f : ndarray
Array of sample frequencies.
Cxy : ndarray
Magnitude squared coherence of x and y.
See Also
--------
periodogram: Simple, optionally modified periodogram
lombscargle: Lomb-Scargle periodogram for unevenly sampled data
welch: Power spectral density by Welch's method.
csd: Cross spectral density by Welch's method.
Notes
-----
An appropriate amount of overlap will depend on the choice of window
and on your requirements. For the default Hann window an overlap of
50% is a reasonable trade off between accurately estimating the
signal power, while not over counting any of the data. Narrower
windows may require a larger overlap.
.. versionadded:: 0.16.0
References
----------
.. [1] P. Welch, "The use of the fast Fourier transform for the
estimation of power spectra: A method based on time averaging
over short, modified periodograms", IEEE Trans. Audio
Electroacoust. vol. 15, pp. 70-73, 1967.
.. [2] Stoica, Petre, and Randolph Moses, "Spectral Analysis of
Signals" Prentice Hall, 2005
Examples
--------
>>> import numpy as np
>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
Generate two test signals with some common features.
>>> fs = 10e3
>>> N = 1e5
>>> amp = 20
>>> freq = 1234.0
>>> noise_power = 0.001 * fs / 2
>>> time = np.arange(N) / fs
>>> b, a = signal.butter(2, 0.25, 'low')
>>> x = rng.normal(scale=np.sqrt(noise_power), size=time.shape)
>>> y = signal.lfilter(b, a, x)
>>> x += amp*np.sin(2*np.pi*freq*time)
>>> y += rng.normal(scale=0.1*np.sqrt(noise_power), size=time.shape)
Compute and plot the coherence.
>>> f, Cxy = signal.coherence(x, y, fs, nperseg=1024)
>>> plt.semilogy(f, Cxy)
>>> plt.xlabel('frequency [Hz]')
>>> plt.ylabel('Coherence')
>>> plt.show()
)r/ r0 r1 r2 r3 r4 r7 r )r
r r r` )r r! r/ r0 r1 r2 r3 r4 r7 r" rE rQ �PyyrR �Cxys r& r r � s� � �Z �q�R��� (�t�W� �"� "� "�J�E�3� �1��F�G�h� �g�D�:� :� :�F�A�s�
��A�"�V�W�"��w�T�K� K� K�F�A�s�
�&��+�+�q�.�3�
��
$�C� �#�:�r' c �� ��
� | dvrt d| z � � �t t t t dd�}| |vrBt d� | t
|� � � � � � � � � �|| u }|s| dk rt d� � �t �
� � �
t j
| � � } |s5t j
|� � }t j | |t j � � }n t j | t j � � }|s�t
| j
� � }t
|j
� � }|� �
� � |� �
� � t j t j |� � t j |� � � � j
}n"# t $ r}t d� � |�d}~ww xY w|rV| j d k rJt j | j
� � t j | j
� � t j | j
� � fS nn| j d k s |j d k rX|t% | j
�
|j
�
g� � fz }t j t j |� � d
�
� � }|||fS | j d k r?�
d
k r9t j | �
d
� � } |s!|j d k rt j |�
d
� � }|s�| j
d
|j
d
k r�| j
d
|j
d
k r\t
| j
� � }|j
d
| j
d
z
|d
< t j | t j |� � fd
� � } n[t
|j
� � }| j
d
|j
d
z
|d
< t j |t j |� � fd
� � }|�$t |� � }|d k rt d � � �t/ ||| j
d
�
� � \ }}|�|}n$||k rt d� � �t |� � }|�|dz }nt |� � }||k rt d� � �||z
}| �,|| } || |dz d
�� � } |s |||dz d
�� � }|
r�| j
d
|z
|z |z }t
| j
dd
� � � |gz } t j | t j | � � fd
�� � } |sJt
|j
dd
� � � |gz } t j |t j | � � fd
�� � }�sd� } n%t1 �d� � s�fd�} n�
d
k r�
�fd�} n�} t j |t j � � |k r|� |� � }| dk r d|||z � � � z z } n3| dk rd|� � � dz z } nt d| z � � �| dk rt j | � � } |rZt j | � � rd} t; j d � � n1d } |s*t j |� � rd} t; j d � � nd} | dk rt? j |d |z � � } n | d k rt? j! |d |z � � } tE | || |||| � � }!|s-tE ||| |||| � � }"t j# |!� � |"z }!n | dk rt j# |!� � |!z }!|!| z }!| d k r4| dk r.|dz r|!d d d�fxx dz cc< n|!d d d
�fxx dz cc< t j$ |dz | j
d
|dz z
d z ||z
� � tK |� � z }#| � |#|dz |z z }#|!� |� � }!|r
| dk r|!j& }!�
d k r�
d z �
t j |!d
�
� � }!| |#|!fS ) a� Calculate various forms of windowed FFTs for PSD, CSD, etc.
This is a helper function that implements the commonality between
the stft, psd, csd, and spectrogram functions. It is not designed to
be called externally. The windows are not averaged over; the result
from each window is returned.
Parameters
----------
x : array_like
Array or sequence containing the data to be analyzed.
y : array_like
Array or sequence containing the data to be analyzed. If this is
the same object in memory as `x` (i.e. ``_spectral_helper(x,
x, ...)``), the extra computations are spared.
fs : float, optional
Sampling frequency of the time series. Defaults to 1.0.
window : str or tuple or array_like, optional
Desired window to use. If `window` is a string or tuple, it is
passed to `get_window` to generate the window values, which are
DFT-even by default. See `get_window` for a list of windows and
required parameters. If `window` is array_like it will be used
directly as the window and its length must be nperseg. Defaults
to a Hann window.
nperseg : int, optional
Length of each segment. Defaults to None, but if window is str or
tuple, is set to 256, and if window is array_like, is set to the
length of the window.
noverlap : int, optional
Number of points to overlap between segments. If `None`,
``noverlap = nperseg // 2``. Defaults to `None`.
nfft : int, optional
Length of the FFT used, if a zero padded FFT is desired. If
`None`, the FFT length is `nperseg`. Defaults to `None`.
detrend : str or function or `False`, optional
Specifies how to detrend each segment. If `detrend` is a
string, it is passed as the `type` argument to the `detrend`
function. If it is a function, it takes a segment and returns a
detrended segment. If `detrend` is `False`, no detrending is
done. Defaults to 'constant'.
return_onesided : bool, optional
If `True`, return a one-sided spectrum for real data. If
`False` return a two-sided spectrum. Defaults to `True`, but for
complex data, a two-sided spectrum is always returned.
scaling : { 'density', 'spectrum' }, optional
Selects between computing the cross spectral density ('density')
where `Pxy` has units of V**2/Hz and computing the cross
spectrum ('spectrum') where `Pxy` has units of V**2, if `x`
and `y` are measured in V and `fs` is measured in Hz.
Defaults to 'density'
axis : int, optional
Axis along which the FFTs are computed; the default is over the
last axis (i.e. ``axis=-1``).
mode: str {'psd', 'stft'}, optional
Defines what kind of return values are expected. Defaults to
'psd'.
boundary : str or None, optional
Specifies whether the input signal is extended at both ends, and
how to generate the new values, in order to center the first
windowed segment on the first input point. This has the benefit
of enabling reconstruction of the first input point when the
employed window function starts at zero. Valid options are
``['even', 'odd', 'constant', 'zeros', None]``. Defaults to
`None`.
padded : bool, optional
Specifies whether the input signal is zero-padded at the end to
make the signal fit exactly into an integer number of window
segments, so that all of the signal is included in the output.
Defaults to `False`. Padding occurs after boundary extension, if
`boundary` is not `None`, and `padded` is `True`.
Returns
-------
freqs : ndarray
Array of sample frequencies.
t : ndarray
Array of times corresponding to each data segment
result : ndarray
Array of output data, contents dependent on *mode* kwarg.
Notes
-----
Adapted from matplotlib.mlab
.. versionadded:: 0.16.0
)rG r z:Unknown value for mode %s, must be one of: {'psd', 'stft'}N)�even�oddr* r� Nz2Unknown boundary option '{0}', must be one of: {1}rG z'x and y must be equal if mode is 'stft'z%x and y cannot be broadcast together.r r, r rg r[ r� r rh rK c � � | S )Nrl )�ds r& � detrend_funcz&_spectral_helper.<locals>.detrend_func, s � ��Hr' �__call__c �2 �� t j | �d�� � S )Nr, )rv r7 )r r4 )r� r4 s �r& r� z&_spectral_helper.<locals>.detrend_func/ s �� � �'���b�A�A�A� Ar' c �r �� t j | d�� � } �| � � } t j | �d� � S )Nr, )r r� )r� r7 r4 s ��r& r� z&_spectral_helper.<locals>.detrend_func4 s7 �� �� �A�r�4�(�(�A����
�
�A��;�q�$��+�+� +r' r+ r( r� zUnknown scaling: %rr �twosidedz9Input data is complex, switching to return_onesided=False�onesided.)'r? r r
r r r^ r� �keysrs r r8 r� � complex64r: r� � broadcastr9 r. r r� r � concatenater� r_ r> r� rw r� rN r� r� r� �fftfreq�rfftfreq� _fft_helper� conjugater� r� rD )$r r! r/ r0 r1 r2 r3 r4 r5 r6 r7 rI r� r� �boundary_funcs� same_data�outdtype�xouter�youter�
outershape�e�outshape�emptyout� pad_shaperq r� �ext_func�nadd� zeros_shaper� �scale�sidesr" �result�result_yrc s$ ` ` r& rL rL _ s� ��� �t �?�"�"�� +�-1�2� 3� 3� 3� '� $�"+� '� � "� "�N� �~�%�%��M� �&��4��0C�0C�0E�0E�+F�+F�G�G�I� I� I� �Q��I� � D��� � ��B�C�C�C� �t�9�9�D� �
�1�
�
�A� � 3� �J�q�M�M���>�!�Q�� �5�5����>�!�R�\�2�2�� � M��a�g� � ���a�g� � ���
�
�4�����
�
�4���� M�� �b�h�v�&6�&6����8H�8H�I�I�O�J�J��� M� M� M� � D�E�E�1� L����� M���� � 0� �6�Q�;�;��8�A�G�$�$�b�h�q�w�&7�&7���!�'�9J�9J�J� J� �
�6�Q�;�;�!�&�A�+�+�!�S�!�'�$�-���� �)G�%H�%H�$J�J�H��{�2�8�H�#5�#5�r�4�@�@�H��X�x�/� /��v��z�z� �2�:�:�� �A�t�R�(�(�A� �
-���!����K��4��,�,�� � A� �7�2�;�!�'�"�+� %� %��w�r�{�Q�W�R�[�(�(� ���M�M� � !��� �a�g�b�k� 9� �"�
��N�A�r�x� �':�':�#;�R�@�@��� ���M�M� � !��� �a�g�b�k� 9� �"�
��N�A�r�x� �':�':�#;�R�@�@�����g�,�,�� �Q�;�;� � A�B�B� B� $�F�G�!�'�"�+�N�N�N�L�C�� �|����
�� � ��I�J�J�J��4�y�y�����A�:����x�=�=���7����>�?�?�?� �h� �E� ��!�(�+�� �H�Q���
�� ,� ,� ,��� 1����G�Q�J�R�0�0�0�A�
� D� �'�"�+�g�%�&��.�'�9���1�7�3�B�3�<�(�(�D�6�1� � �N�A�r�x� � 4� 4�5�B� ?� ?� ?��� D� �q�w�s��s�|�,�,��v�5�K����2�8�K�#8�#8� 9��C�C�C�A� � � � � � �
�W�j�
)�
)� � B� B� B� B� B� B�
���� ,� ,� ,� ,� ,� ,� ,�
� � �~�c�2�<�(�(�H�4�4��j�j��"�"���)����r�S��W�M�M�O�O�+�,��� �J� � ��c�g�g�i�i��l�"����.��8�9�9�9� �v�~�~��������
�
�?�1� � �
;� �E� �M� 2�
3�
3�
3�
3� �E� �
;��?�1�%�%� ;� &�E� �M� #:� ;� ;� ;�� �� �
�����t�Q�r�T�*�*��� �*� � ����a��d�+�+�� ��C� �w��$��
N�
N�F� � /� �q�#�|�W�h�� $�&� &��� �f�%�%��0���
�� � �� �f�%�%��.��
�e�O�F� �
���t�u�}�}� �!�8� #� �3����7�O�O�O�q� �O�O�O�O�
�3��"��9� � � �� "� � � �
�9�W�Q�Y���� �g�a�i� 7�!� ;� �x�'� )� )�).�r��� 3�D��� ����b� � ��
�]�]�8�
$�
$�F� � �T�V�^�^���� �a�x�x� �� �� �[���T�
*�
*�F� �$�� � s �$>F# �#
G�-F=�=Gc �� � |dk r|dk r| dt j f }n~||z
}| j dd� | j d |z
|z |fz } | j dd� || j d z | j d fz }
t j j � | | |
�� � } ||� � }||z }|dk r
t j } n|j }t j
} | ||�� � }|S ) a8
Calculate windowed FFT, for internal use by
`scipy.signal._spectral_helper`.
This is a helper function that does the main FFT calculation for
`_spectral helper`. All input validation is performed there, and the
data axis is assumed to be the last axis of x. It is not designed to
be called externally. The windows are not averaged over; the result
from each window is returned.
Returns
-------
result : ndarray
Array of FFT data
Notes
-----
Adapted from matplotlib.mlab
.. versionadded:: 0.16.0
r r .Nr, )r: �stridesr� )r� ) r �newaxisr: r� �lib�
stride_tricks�
as_stridedr� r rD �rfft) r rq r� r1 r2 r3 r� r� rp r: r� �funcs r& r� r� � s � �. �!�|�|��A�
�
��3��
�?�#��� ��!������� �q�w�r�{�8� 3�d� :�G� D�D���)�C�R�C�.�$�q�y��}�"4�a�i��m�!D�D����%�0�0��%�9@� 1� B� B�� �\�&�
!�
!�F� �6�\�F�
�
����z�������{��
�T�&�D�
!�
!�
!�F� �Mr' c � � t | t � � st | t � � rE|�d}||k r*t j d� ||� � � � |}t
| |� � }n�t j | � � }t |j
� � dk rt d� � �||j
d k rt d� � �|�|j
d }n"|� ||j
d k rt d � � �||fS )
a�
Parses window and nperseg arguments for spectrogram and _spectral_helper.
This is a helper function, not meant to be called externally.
Parameters
----------
window : string, tuple, or ndarray
If window is specified by a string or tuple and nperseg is not
specified, nperseg is set to the default of 256 and returns a window of
that length.
If instead the window is array_like and nperseg is not specified, then
nperseg is set to the length of the window. A ValueError is raised if
the user supplies both an array_like window and a value for nperseg but
nperseg does not equal the length of the window.
nperseg : int
Length of each segment
input_length: int
Length of input signal, i.e. x.shape[-1]. Used to test for errors.
Returns
-------
win : ndarray
window. If function was called with string or tuple than this will hold
the actual array used as a window.
nperseg : int
Length of each segment. If window is str or tuple, nperseg is set to
256. If window is array_like, nperseg is set to the length of the
window.
Nr� zLnperseg = {0:d} is greater than input length = {1:d}, using nperseg = {1:d}r ri r, z"window is longer than input signalr z>value specified for nperseg is different from length of window) rt ru r= r� r� r^ r r r8 r< r: r? )r0 r1 r\ rq s r& r_ r_ � s � �D �&�#� � � ;�*�V�U�";�";� ;� �?��G� �\� !� !� �M� <�!�6�'�<�8�8�
:�
:�
:� #�G����)�)����j�� � �� �s�y�>�>�Q� � � � 1�2�2� 2� �#�)�B�-� '� '� � A�B�B� B� �?��i��l�G�G�
�
��#�)�A�,�&�&� � ":� ;� ;� ;� ��<�r' c � � dt j d| dz
dz dz � � z }dt j d|dz z d|z z
� � z S )aG
Returns the bias of the median of a set of periodograms relative to
the mean.
See Appendix B from [1]_ for details.
Parameters
----------
n : int
Numbers of periodograms being averaged.
Returns
-------
bias : float
Calculated bias.
References
----------
.. [1] B. Allen, W.G. Anderson, P.R. Brady, D.A. Brown, J.D.E. Creighton.
"FINDCHIRP: an algorithm for detection of gravitational waves from
inspiraling compact binaries", Physical Review D 85, 2012,
:arxiv:`gr-qc/0509116`
r r( r )r r� rw )r� �ii_2s r& rM rM � sL � �0
�r�y��a��c�a�Z�!�^�,�,� ,�D� �r�v�b�D�1�H�o��T� �1�2�2� 2�2r' )FF)r( r) Nr* Tr+ r, )
r( rA NNNr* Tr+ r, r )
r( rT NNNr* Tr+ r, rG )re ) r( rA r� NNFTr� Tr, r� )
r( rA NNNTTr, r� r� )r( rA NNNr* r, ) r( rA NNNr* Tr+ r, rG NF)!�__doc__�numpyr �scipyr r� � r �windowsr � _spectralr � _arraytoolsr r r
r r� �__all__r r r
r r r r r r r rL r� r_ rM rl r' r& �<module>r� s_ ��� � � � � � � � � � � � � � � � � � � � � � � � #� #� #� #� #� #� ?� ?� ?� ?� ?� ?� ?� ?� ?� ?� ?� ?� ���� G� G� G�� � � I� I� I� I�X @J�>@�I-� I-� I-� I-�X GK�<E�!�c� c� c� c�L HL�:C� �W� W� W� W�t JN�?C�16�i � i � i � i �Xw+� w+� w+� w+�t|!� |!� |!� |!�~ EI�GK�$�s � s � s � s �l IM�FH� �^� ^� ^� ^�B CG�24�w� w� w� w�t JN�DH�FJ� !�c � c � c � c �L /� /� /�d8� 8� 8�v3� 3� 3� 3� 3r'