← Back
Editing: _waveforms.cpython-311.pyc
� 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,
Save File
Cancel