| 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+P � � � d dl Zd dl mZmZmZmZmZmZmZm Z m
Z
m Z m Z m
Z
mZmZ g d�Zdd�Zdd�Z dd �Zdd�Zdd�Zdd�Zd� Zdefd�ZdS )� N)�asarray�zeros�place�nan�mod�pi�extract�log�sqrt�exp�cos�sin�polyval�polyint)�sawtooth�square�
gausspulse�chirp�
sweep_poly� unit_impulse� c �� � t | � � t |� � }} t || | z
z � � }t | ||z
z � � } | j j dv r
| j j }nd}t | j |� � }|dk |dk z }t ||t � � t | dt z � � }d|z
||dz t z k z }t ||� � }t ||� � } t |||t | z z dz
� � d|z
d|z
z }
t |
|� � }t |
|� � } t ||
t | dz z |z
t d| z
z z � � |S )a�
Return a periodic sawtooth or triangle waveform.
The sawtooth waveform has a period ``2*pi``, rises from -1 to 1 on the
interval 0 to ``width*2*pi``, then drops from 1 to -1 on the interval
``width*2*pi`` to ``2*pi``. `width` must be in the interval [0, 1].
Note that this is not band-limited. It produces an infinite number
of harmonics, which are aliased back and forth across the frequency
spectrum.
Parameters
----------
t : array_like
Time.
width : array_like, optional
Width of the rising ramp as a proportion of the total cycle.
Default is 1, producing a rising ramp, while 0 produces a falling
ramp. `width` = 0.5 produces a triangle wave.
If an array, causes wave shape to change over time, and must be the
same length as t.
Returns
-------
y : ndarray
Output array containing the sawtooth waveform.
Examples
--------
A 5 Hz waveform sampled at 500 Hz for 1 second:
>>> import numpy as np
>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> t = np.linspace(0, 1, 500)
>>> plt.plot(t, signal.sawtooth(2 * np.pi * 5 * t))
��fFdD�dr r � )
r �dtype�charr �shaper r r r r ) �t�width�w�ytype�y�mask1�tmod�mask2�tsub�wsub�mask3s �9/usr/lib/python3/dist-packages/scipy/signal/_waveforms.pyr r sk � �N �1�:�:�w�u�~�~�q�A���Q��U� � � �A���Q��U� � � �A��w�|�x� � ��� �����
�a�g�u� � �A� ��U�q�1�u� �E� �!�U�C���� �q�!�b�&�>�>�D� ��Y�4�!�a�%�"�*�,� -�E� �5�$� � �D� �5�!� � �D� �!�U�D�B��I�&��*�+�+�+�
��Y�1�u�9� %�E� �5�$� � �D� �5�!� � �D� �!�U�R�4�!�8�_�t�+��a�$�h��@�A�A�A� �H� � �?c � � t | � � t |� � }} t || | z
z � � }t | ||z
z � � } | j j dv r
| j j }nd}t | j |� � }|dk |dk z }t ||t � � t | dt z � � }d|z
||dz t z k z }t ||d� � d|z
d|z
z }t ||d� � |S )aB
Return a periodic square-wave waveform.
The square wave has a period ``2*pi``, has value +1 from 0 to
``2*pi*duty`` and -1 from ``2*pi*duty`` to ``2*pi``. `duty` must be in
the interval [0,1].
Note that this is not band-limited. It produces an infinite number
of harmonics, which are aliased back and forth across the frequency
spectrum.
Parameters
----------
t : array_like
The input time array.
duty : array_like, optional
Duty cycle. Default is 0.5 (50% duty cycle).
If an array, causes wave shape to change over time, and must be the
same length as t.
Returns
-------
y : ndarray
Output array containing the square waveform.
Examples
--------
A 5 Hz waveform sampled at 500 Hz for 1 second:
>>> import numpy as np
>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> t = np.linspace(0, 1, 500, endpoint=False)
>>> plt.plot(t, signal.square(2 * np.pi * 5 * t))
>>> plt.ylim(-2, 2)
A pulse-width modulated sine wave:
>>> plt.figure()
>>> sig = np.sin(2 * np.pi * t)
>>> pwm = signal.square(2 * np.pi * 30 * t, duty=(sig + 1)/2)
>>> plt.subplot(2, 1, 1)
>>> plt.plot(t, sig)
>>> plt.subplot(2, 1, 2)
>>> plt.plot(t, pwm)
>>> plt.ylim(-1.5, 1.5)
r r r r r ���) r r r r r r r r r ) r �dutyr" r# r$ r% r& r' r* s r+ r r X s � �b �1�:�:�w�t�}�}�q�A���Q��U� � � �A���Q��U� � � �A��w�|�x� � ��� �����
�a�g�u� � �A� ��U�q�1�u� �E� �!�U�C���� �q�!�b�&�>�>�D�
��Y�4�!�a�%�"�*�,� -�E� �!�U�A���� ��Y�1�u�9� %�E� �!�U�B���� �Hr, �� �������Fc �� � |dk rt d|z � � �|dk rt d|z � � �|dk rt d|z � � �t d|dz � � }t |z |z dz dt |� � z z }t | t
� � r]| d k rH|dk rt d
� � �t d|dz � � } t
t | � � |z � � S t d � � �t | | z | z � � }
|
t dt z |z | z � � z } |
t dt z |z | z � � z } |s|s| S |s|r| |
fS |r|s| | fS |r|r| | |
fS d S d S )
aa
Return a Gaussian modulated sinusoid:
``exp(-a t^2) exp(1j*2*pi*fc*t).``
If `retquad` is True, then return the real and imaginary parts
(in-phase and quadrature).
If `retenv` is True, then return the envelope (unmodulated signal).
Otherwise, return the real part of the modulated sinusoid.
Parameters
----------
t : ndarray or the string 'cutoff'
Input array.
fc : float, optional
Center frequency (e.g. Hz). Default is 1000.
bw : float, optional
Fractional bandwidth in frequency domain of pulse (e.g. Hz).
Default is 0.5.
bwr : float, optional
Reference level at which fractional bandwidth is calculated (dB).
Default is -6.
tpr : float, optional
If `t` is 'cutoff', then the function returns the cutoff
time for when the pulse amplitude falls below `tpr` (in dB).
Default is -60.
retquad : bool, optional
If True, return the quadrature (imaginary) as well as the real part
of the signal. Default is False.
retenv : bool, optional
If True, return the envelope of the signal. Default is False.
Returns
-------
yI : ndarray
Real part of signal. Always returned.
yQ : ndarray
Imaginary part of signal. Only returned if `retquad` is True.
yenv : ndarray
Envelope of signal. Only returned if `retenv` is True.
See Also
--------
scipy.signal.morlet
Examples
--------
Plot real component, imaginary component, and envelope for a 5 Hz pulse,
sampled at 100 Hz for 2 seconds:
>>> import numpy as np
>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> t = np.linspace(-1, 1, 2 * 100, endpoint=False)
>>> i, q, e = signal.gausspulse(t, fc=5, retquad=True, retenv=True)
>>> plt.plot(t, i, t, q, t, e, '--')
r z'Center frequency (fc=%.2f) must be >=0.z+Fractional bandwidth (bw=%.2f) must be > 0.z7Reference level for bandwidth (bwr=%.2f) must be < 0 dBg $@g 4@r g @�cutoffz.Reference level for time cutoff must be < 0 dBz'If `t` is a string, it must be 'cutoff'N)
�
ValueError�powr r
�
isinstance�strr r r
r )
r �fc�bw�bwr�tpr�retquad�retenv�ref�a�tref�yenv�yI�yQs
r+ r r � s� � �x
�A�v�v��B�R�G�H�H�H� �Q�w�w��F��K�L�L�L�
�a�x�x�� %�'*�+� ,� ,� ,�
�d�C�$�J�
�
�C�
�r�'�B�,�1� � ��c�#�h�h��/�A��!�S���
H� ��=�=� �a�x�x� � "-� .� .� .��t�S�4�Z�(�(�D���T���
�Q��'�'� '� � F�G�G� G� ��r�A�v��z�?�?�D�
��A��F�R�K�!�O�$�$� $�B�
��A��F�R�K�!�O�$�$� $�B� � �6� �� � � �v� ��4�x��� �v� ��2�v�
�� �6� ��2�t�|�� � � � r, �linearTc �h � t | |||||� � }|t dz z }t ||z � � S )aR Frequency-swept cosine generator.
In the following, 'Hz' should be interpreted as 'cycles per unit';
there is no requirement here that the unit is one second. The
important distinction is that the units of rotation are cycles, not
radians. Likewise, `t` could be a measurement of space instead of time.
Parameters
----------
t : array_like
Times at which to evaluate the waveform.
f0 : float
Frequency (e.g. Hz) at time t=0.
t1 : float
Time at which `f1` is specified.
f1 : float
Frequency (e.g. Hz) of the waveform at time `t1`.
method : {'linear', 'quadratic', 'logarithmic', 'hyperbolic'}, optional
Kind of frequency sweep. If not given, `linear` is assumed. See
Notes below for more details.
phi : float, optional
Phase offset, in degrees. Default is 0.
vertex_zero : bool, optional
This parameter is only used when `method` is 'quadratic'.
It determines whether the vertex of the parabola that is the graph
of the frequency is at t=0 or t=t1.
Returns
-------
y : ndarray
A numpy array containing the signal evaluated at `t` with the
requested time-varying frequency. More precisely, the function
returns ``cos(phase + (pi/180)*phi)`` where `phase` is the integral
(from 0 to `t`) of ``2*pi*f(t)``. ``f(t)`` is defined below.
See Also
--------
sweep_poly
Notes
-----
There are four options for the `method`. The following formulas give
the instantaneous frequency (in Hz) of the signal generated by
`chirp()`. For convenience, the shorter names shown below may also be
used.
linear, lin, li:
``f(t) = f0 + (f1 - f0) * t / t1``
quadratic, quad, q:
The graph of the frequency f(t) is a parabola through (0, f0) and
(t1, f1). By default, the vertex of the parabola is at (0, f0).
If `vertex_zero` is False, then the vertex is at (t1, f1). The
formula is:
if vertex_zero is True:
``f(t) = f0 + (f1 - f0) * t**2 / t1**2``
else:
``f(t) = f1 - (f1 - f0) * (t1 - t)**2 / t1**2``
To use a more general quadratic function, or an arbitrary
polynomial, use the function `scipy.signal.sweep_poly`.
logarithmic, log, lo:
``f(t) = f0 * (f1/f0)**(t/t1)``
f0 and f1 must be nonzero and have the same sign.
This signal is also known as a geometric or exponential chirp.
hyperbolic, hyp:
``f(t) = f0*f1*t1 / ((f0 - f1)*t + f1*t1)``
f0 and f1 must be nonzero.
Examples
--------
The following will be used in the examples:
>>> import numpy as np
>>> from scipy.signal import chirp, spectrogram
>>> import matplotlib.pyplot as plt
For the first example, we'll plot the waveform for a linear chirp
from 6 Hz to 1 Hz over 10 seconds:
>>> t = np.linspace(0, 10, 1500)
>>> w = chirp(t, f0=6, f1=1, t1=10, method='linear')
>>> plt.plot(t, w)
>>> plt.title("Linear Chirp, f(0)=6, f(10)=1")
>>> plt.xlabel('t (sec)')
>>> plt.show()
For the remaining examples, we'll use higher frequency ranges,
and demonstrate the result using `scipy.signal.spectrogram`.
We'll use a 4 second interval sampled at 7200 Hz.
>>> fs = 7200
>>> T = 4
>>> t = np.arange(0, int(T*fs)) / fs
We'll use this function to plot the spectrogram in each example.
>>> def plot_spectrogram(title, w, fs):
... ff, tt, Sxx = spectrogram(w, fs=fs, nperseg=256, nfft=576)
... fig, ax = plt.subplots()
... ax.pcolormesh(tt, ff[:145], Sxx[:145], cmap='gray_r',
... shading='gouraud')
... ax.set_title(title)
... ax.set_xlabel('t (sec)')
... ax.set_ylabel('Frequency (Hz)')
... ax.grid(True)
...
Quadratic chirp from 1500 Hz to 250 Hz
(vertex of the parabolic curve of the frequency is at t=0):
>>> w = chirp(t, f0=1500, f1=250, t1=T, method='quadratic')
>>> plot_spectrogram(f'Quadratic Chirp, f(0)=1500, f({T})=250', w, fs)
>>> plt.show()
Quadratic chirp from 1500 Hz to 250 Hz
(vertex of the parabolic curve of the frequency is at t=T):
>>> w = chirp(t, f0=1500, f1=250, t1=T, method='quadratic',
... vertex_zero=False)
>>> plot_spectrogram(f'Quadratic Chirp, f(0)=1500, f({T})=250\n' +
... '(vertex_zero=False)', w, fs)
>>> plt.show()
Logarithmic chirp from 1500 Hz to 250 Hz:
>>> w = chirp(t, f0=1500, f1=250, t1=T, method='logarithmic')
>>> plot_spectrogram(f'Logarithmic Chirp, f(0)=1500, f({T})=250', w, fs)
>>> plt.show()
Hyperbolic chirp from 1500 Hz to 250 Hz:
>>> w = chirp(t, f0=1500, f1=250, t1=T, method='hyperbolic')
>>> plot_spectrogram(f'Hyperbolic Chirp, f(0)=1500, f({T})=250', w, fs)
>>> plt.show()
� )� _chirp_phaser r
)r �f0�t1�f1�method�phi� vertex_zero�phases r+ r r s; � �p
��B��B�� � <� <�E��2��8�O�C� �u�s�{� � �r, c � � t | � � } t |� � }t |� � }t |� � }|dv r&||z
|z }dt z || z d|z | z | z z z }�nW|dv rR||z
|dz z }|r dt z || z || dz z dz z z }�n(dt z || z ||| z
dz |dz z
z dz z z }�n|dv ro||z dk rt d� � �||k rdt z |z | z }n�|t ||z � � z }dt z |z |z t ||z | |z � � d z
z }n�|d
v rx|d k s|d k rt d � � �||k rdt z |z | z }nX| |z ||z
z }dt z | |z z t t
j d
| |z z
� � � � z }nt d|z � � �|S )z{
Calculate the phase used by `chirp` to generate its output.
See `chirp` for a description of the arguments.
)rF �lin�lir r- )� quadratic�quad�q� )� logarithmicr
�log zJFor a logarithmic chirp, f0 and f1 must be nonzero and have the same sign.g �?)�
hyperbolic�hypr z2For a hyperbolic chirp, f0 and f1 must be nonzero.r zbmethod must be 'linear', 'quadratic', 'logarithmic', or 'hyperbolic', but a value of %r was given.)r �floatr r6 r
r7 �np�abs) r rJ rK rL rM rO �betarP �sings r+ rI rI � sG � � ��
�
�A� �r���B� �r���B� �r���B�
�(�(�(��R��2�~���B��"�q�&�3��:��>�A�#5�5�6��� �-� -� -��R��B�!�G�$�� � M���F�b�1�f�t�a�1�f�}�q�'8� 8�9�E�E���F�b�1�f�t��Q��1�}�r�Q�w�/F�'G�!�'K� K�L�E�E� �/� /� /�
��7�c�>�>� � ?� @� @�
@�
��8�8���F�R�K�!�O�E�E���B��G� � �$�D���F�T�M�B�&�#�b�2�g�q�2�v�*>�*>��*D�E�E�E� �(� (� (�
��7�7�b�A�g�g� � (� )� )�
)�
��8�8���F�R�K�!�O�E�E� �3��8�r�B�w�'�D���F�t�e�b�j�)�C���q�1�T�6�z�0B�0B�,C�,C�C�E�E� � J�!�"� #� #� #� �Lr, c �` � t | |� � }|t dz z }t ||z � � S )a&
Frequency-swept cosine generator, with a time-dependent frequency.
This function generates a sinusoidal function whose instantaneous
frequency varies with time. The frequency at time `t` is given by
the polynomial `poly`.
Parameters
----------
t : ndarray
Times at which to evaluate the waveform.
poly : 1-D array_like or instance of numpy.poly1d
The desired frequency expressed as a polynomial. If `poly` is
a list or ndarray of length n, then the elements of `poly` are
the coefficients of the polynomial, and the instantaneous
frequency is
``f(t) = poly[0]*t**(n-1) + poly[1]*t**(n-2) + ... + poly[n-1]``
If `poly` is an instance of numpy.poly1d, then the
instantaneous frequency is
``f(t) = poly(t)``
phi : float, optional
Phase offset, in degrees, Default: 0.
Returns
-------
sweep_poly : ndarray
A numpy array containing the signal evaluated at `t` with the
requested time-varying frequency. More precisely, the function
returns ``cos(phase + (pi/180)*phi)``, where `phase` is the integral
(from 0 to t) of ``2 * pi * f(t)``; ``f(t)`` is defined above.
See Also
--------
chirp
Notes
-----
.. versionadded:: 0.8.0
If `poly` is a list or ndarray of length `n`, then the elements of
`poly` are the coefficients of the polynomial, and the instantaneous
frequency is:
``f(t) = poly[0]*t**(n-1) + poly[1]*t**(n-2) + ... + poly[n-1]``
If `poly` is an instance of `numpy.poly1d`, then the instantaneous
frequency is:
``f(t) = poly(t)``
Finally, the output `s` is:
``cos(phase + (pi/180)*phi)``
where `phase` is the integral from 0 to `t` of ``2 * pi * f(t)``,
``f(t)`` as defined above.
Examples
--------
Compute the waveform with instantaneous frequency::
f(t) = 0.025*t**3 - 0.36*t**2 + 1.25*t + 2
over the interval 0 <= t <= 10.
>>> import numpy as np
>>> from scipy.signal import sweep_poly
>>> p = np.poly1d([0.025, -0.36, 1.25, 2.0])
>>> t = np.linspace(0, 10, 5001)
>>> w = sweep_poly(t, p)
Plot it:
>>> import matplotlib.pyplot as plt
>>> plt.subplot(2, 1, 1)
>>> plt.plot(t, w)
>>> plt.title("Sweep Poly\nwith frequency " +
... "$f(t) = 0.025t^3 - 0.36t^2 + 1.25t + 2$")
>>> plt.subplot(2, 1, 2)
>>> plt.plot(t, p(t), 'r', label='f(t)')
>>> plt.legend()
>>> plt.xlabel('t')
>>> plt.tight_layout()
>>> plt.show()
rH )�_sweep_poly_phaser r
)r �polyrN rP s r+ r r � s3 � �x
�a�� &� &�E��2��8�O�C� �u�s�{� � �r, c �Z � t |� � }dt z t || � � z }|S )z�
Calculate the phase used by sweep_poly to generate its output.
See `sweep_poly` for a description of the arguments.
r )r r r )r rc �intpolyrP s r+ rb rb = s, � � �d�m�m�G�
��F�W�W�a�(�(� (�E� �Lr, c � � t | |� � }t j | � � } |�dt | � � z }n<|dk rt | dz � � }n#t |d� � s|ft | � � z }d||< |S )aB
Unit impulse signal (discrete delta function) or unit basis vector.
Parameters
----------
shape : int or tuple of int
Number of samples in the output (1-D), or a tuple that represents the
shape of the output (N-D).
idx : None or int or tuple of int or 'mid', optional
Index at which the value is 1. If None, defaults to the 0th element.
If ``idx='mid'``, the impulse will be centered at ``shape // 2`` in
all dimensions. If an int, the impulse will be at `idx` in all
dimensions.
dtype : data-type, optional
The desired data-type for the array, e.g., ``numpy.int8``. Default is
``numpy.float64``.
Returns
-------
y : ndarray
Output array containing an impulse signal.
Notes
-----
The 1D case is also known as the Kronecker delta.
.. versionadded:: 0.19.0
Examples
--------
An impulse at the 0th element (:math:`\delta[n]`):
>>> from scipy import signal
>>> signal.unit_impulse(8)
array([ 1., 0., 0., 0., 0., 0., 0., 0.])
Impulse offset by 2 samples (:math:`\delta[n-2]`):
>>> signal.unit_impulse(7, 2)
array([ 0., 0., 1., 0., 0., 0., 0.])
2-dimensional impulse, centered:
>>> signal.unit_impulse((3, 3), 'mid')
array([[ 0., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 0.]])
Impulse at (2, 2), using broadcasting:
>>> signal.unit_impulse((4, 4), 2)
array([[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 1., 0.],
[ 0., 0., 0., 0.]])
Plot the impulse response of a 4th-order Butterworth lowpass filter:
>>> imp = signal.unit_impulse(100, 'mid')
>>> b, a = signal.butter(4, 0.2)
>>> response = signal.lfilter(b, a, imp)
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> plt.plot(np.arange(-50, 50), imp)
>>> plt.plot(np.arange(-50, 50), response)
>>> plt.margins(0.1, 0.1)
>>> plt.xlabel('Time [samples]')
>>> plt.ylabel('Amplitude')
>>> plt.grid(True)
>>> plt.show()
N�r �midr �__iter__r )r r] �
atleast_1d�len�tuple�hasattr)r �idxr �outs r+ r r J s� � �T ��u�
�
�C� �M�%� � �E�
�{��S��Z�Z� ��� �� � ��E�Q�J� � ���
�S�*�
%�
%� "��f�s�5�z�z�!���C��H� �Jr, )r )r- )r1 r- r2 r3 FF)rF r T)rF Trg )�numpyr] r r r r r r r r
r r r
r r r �__all__r r r r rI r rb r\ r � r, r+ �<module>rs s� �� � � � �$� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� $� � � ��E
� E
� E
� E
�PH
� H
� H
� H
�V =B��b � b � b � b �J[ � [ � [ � [ �|2� 2� 2� 2�j_ � _ � _ � _ �D
�
�
� !�� V� V� V� V� V� Vr,