Submit
Path:
~
/
/
proc
/
thread-self
/
root
/
opt
/
alt
/
python35
/
lib64
/
python3.5
/
site-packages
/
scipy
/
signal
/
__pycache__
/
File Content:
signaltools.cpython-35.pyc
��W� � @ s� d d l m Z m Z m Z d d l Z d d l Z d d l Z d d l m Z m Z d d l m Z m Z m Z d d l m Z d d l m Z d d l m Z m Z d d l m Z m Z m Z m Z m Z m Z m Z m Z m Z m Z m Z m! Z! m" Z" m# Z# m$ Z$ m% Z% m& Z& m' Z' m( Z( m) Z) m* Z* m+ Z+ m, Z, m- Z- m. Z. m/ Z/ m0 Z0 m1 Z1 m2 Z2 m3 Z3 m4 Z4 m5 Z5 m6 Z6 m7 Z7 m8 Z8 m9 Z9 m: Z: m; Z; m< Z< m= Z= d d l Z> d d l? m@ Z@ d d lA mB ZB d d lC mD ZD mE ZE mF ZF mG ZG mH ZH d d lI mJ ZJ d d lK mL ZL e jM jN d k rMe jM jO d k rMd d lP mQ ZQ n d d lR mQ ZQ d d d d d d d d d d d d d d d d! d" d# d$ d% d& d' d( d) d* d+ d, d- d. d/ g ZS d0 d d1 d d2 d3 i ZT d4 d d5 d d6 d3 d7 d3 d8 d d9 d d: d; i ZU e e> jV � d< k ZW e jX � ZY d= d> � ZZ d? d@ � Z[ dA dB � Z\ d2 dC d � Z] dD dE � Z^ d2 dF d � Z_ d2 dG d � Z` dH d � Za d dI d � Zb d d dJ d � Zc d2 d4 d dK d � Zd d2 d4 d dL d � Ze d dM d � Zf dq d dN d � Zg d dO d � Zh dP d � Zi d dr dQ d � Zj d dR d � Zk dS d! � Zl dT dU dV d" � Zm dT dW dX d# � Zn dT dW dY d% � Zo dT dW dZ d& � Zp dT dW d[ d$ � Zq d d d d\ d' � Zr d ds d_ d( � Zs d` d/ � Zt dt da d db d) � Zu dc d* � Zv dd d+ � Zw du d de df � Zx dv dg d d5 d dh d- � Zy di dj � Zz dw d dk d � Z{ dx dg d dl d, � Z| dm dn � Z} d do dy d dp d. � Z~ d S)z� )�division�print_function�absolute_importN� )�sigtools�dlti)�upfirdn�_UpFIRDn� _output_len)�callable)� NumpyVersion)�fftpack�linalg)(�allclose�angle�arange�argsort�array�asarray� atleast_1d� atleast_2d�cast�dot�exp� expand_dims� iscomplexobj�mean�ndarray�newaxis�ones�pi�poly�polyadd�polyder�polydiv�polymul�polysub�polyval�prod�product�r_�ravel� real_if_close�reshape�roots�sort�sum�take� transpose�unique�where�zeros� zeros_like)� factorial)� get_window)� axis_slice� axis_reverse�odd_ext�even_ext� const_ext)�cheby1)�firwin� � )�gcd� correlate� fftconvolve�convolve� convolve2d� correlate2d� order_filter�medfilt� medfilt2d�wiener�lfilter�lfiltic�sosfilt� deconvolve�hilbert�hilbert2� cmplx_sort� unique_roots�invres�invresz�residue�residuez�resample� resample_poly�detrend� lfilter_zi� sosfilt_zi� sosfiltfilt�filtfilt�decimate�vectorstrength�valid�same�full� Zfill�padZwrapZcircularZsymmZ symmetricZreflect� z1.9.0.dev-e24486ec C sE y t | } Wn0 t k r@ | d k r6 t d � � | } Yn X| S)Nr r rd zAAcceptable mode flags are 'valid' (0), 'same' (1), or 'full' (2).)r r rd )� _modedict�KeyError� ValueError)�mode�val� rl �/signaltools.py� _valfrommode7 s rn c C sM y t | d >} Wn4 t k rH | d k r: t d � � | d >} Yn X| S)Nrd r r z]Acceptable boundary flags are 'fill', 'wrap' (or 'circular'), and 'symm' (or 'symmetric').)r r rd )� _boundarydictrh ri )�boundaryrk rl rl rm �_bvalfromboundaryB s rq c C s} | d k ry d \ } } xA t | | � D]0 \ } } | | k sF d } | | k s( d } q( W| pe | st t d � � | Sd S)a If in 'valid' mode, checks whether or not one of the array shapes is at least as large as the other in every dimension. Returns whether or not the input arrays need to be swapped depending on whether shape2 is larger than shape1. This is important for some of the correlation and convolution implementations in this module, where the larger array input needs to come before the smaller array input when operating in this mode. Note that if the mode provided is not 'valid', False is immediately returned. ra TFzOFor 'valid' mode, one must be at least as large as the other in every dimension)TT)�zipri )rj Zshape1Zshape2Zok1Zok2Zd1Zd2rl rl rm �_inputs_swap_neededN s rs c C s| t | � } t | � } y t | } Wn t k rF t d � � Yn X| j | j k od d k n rq | | S| j | j k s� t d � � | j | j k o� d k n r� | j | j k s� | d k r� t j | | | � S| d k r | j | j k pt | | j | j � } | r+| | } } | d k r�d d � t | j | j � D� } t j | | j � } t j | | | | � } n� d d � t | j | j � D� } t j | | j � } d d � | j D� } | j � | | <| d k r t j | | j � } n$ | d k r.t j | j | j � } t j | | | | � } | rxt d d d � g | j } | | j � } | S)a� Cross-correlate two N-dimensional arrays. Cross-correlate `in1` and `in2`, with the output size determined by the `mode` argument. Parameters ---------- in1 : array_like First input. in2 : array_like Second input. Should have the same number of dimensions as `in1`. If operating in 'valid' mode, either `in1` or `in2` must be at least as large as the other in every dimension. mode : str {'full', 'valid', 'same'}, optional A string indicating the size of the output: ``full`` The output is the full discrete linear cross-correlation of the inputs. (Default) ``valid`` The output consists only of those elements that do not rely on the zero-padding. ``same`` The output is the same size as `in1`, centered with respect to the 'full' output. Returns ------- correlate : array An N-dimensional array containing a subset of the discrete linear cross-correlation of `in1` with `in2`. Notes ----- The correlation z of two d-dimensional arrays x and y is defined as: z[...,k,...] = sum[..., i_l, ...] x[..., i_l,...] * conj(y[..., i_l + k,...]) Examples -------- Implement a matched filter using cross-correlation, to recover a signal that has passed through a noisy channel. >>> from scipy import signal >>> sig = np.repeat([0., 1., 1., 0., 1., 0., 0., 1.], 128) >>> sig_noise = sig + np.random.randn(len(sig)) >>> corr = signal.correlate(sig_noise, np.ones(128), mode='same') / 128 >>> import matplotlib.pyplot as plt >>> clock = np.arange(64, len(sig), 128) >>> fig, (ax_orig, ax_noise, ax_corr) = plt.subplots(3, 1, sharex=True) >>> ax_orig.plot(sig) >>> ax_orig.plot(clock, sig[clock], 'ro') >>> ax_orig.set_title('Original signal') >>> ax_noise.plot(sig_noise) >>> ax_noise.set_title('Signal with noise') >>> ax_corr.plot(corr) >>> ax_corr.plot(clock, corr[clock], 'ro') >>> ax_corr.axhline(0.5, ls=':') >>> ax_corr.set_title('Cross-correlated with rectangular pulse') >>> ax_orig.margins(0, 0.1) >>> fig.tight_layout() >>> fig.show() z5Acceptable mode flags are 'valid', 'same', or 'full'.r z/in1 and in2 should have the same dimensionalityr rb rc ra c S s$ g | ] \ } } | | d � q S)r rl )�.0�i�jrl rl rm � <listcomp>� s z correlate.<locals>.<listcomp>c S s$ g | ] \ } } | | d � q S)r rl )rt ru rv rl rl rm rw � s c S s g | ] } t d | � � q S)r )�slice)rt ru rl rl rm rw � s N���)r rg rh ri �ndim�size�nprC rs �shaperr �empty�dtyper Z _correlateNDr5 �copyrx �conj) �in1�in2rj rk �swapped_inputsZps�out�zZ in1zpaddedZsc�reverserl rl rm rC l sB D " @ "" c si t | � } t | j � } | | d � � | � � � f d d � t t � � � D� } | t | � S)Nrd c s' g | ] } t � | � | � � q Srl )rx )rt �k)�endind�startindrl rm rw � s z _centered.<locals>.<listcomp>)r r r} �range�len�tuple)Zarr�newshapeZ currshapeZmyslicerl )r� r� rm � _centered� s (r� c C sk t | � } t | � } | j | j k o5 d k n rB | | S| j | j k sc t d � � n( | j d k s� | j d k r� t g � St | j � } t | j � } t j | j t � p� t j | j t � } | | d } t | | | � r| | | | f \ } } } } d d � | D� } t d d � | D� � } | r�t sYt j d � r�zQ t j j | | � } t j j | | � } t j j | | | � | j � } Wd t s�t j � XnP t j | | � } t j | | � } t j | | � | j � } | s| j } | d k r!| S| d k r:t | | � S| d k r[t | | | d � St d � � d S) aE Convolve two N-dimensional arrays using FFT. Convolve `in1` and `in2` using the fast Fourier transform method, with the output size determined by the `mode` argument. This is generally much faster than `convolve` for large arrays (n > ~500), but can be slower when only a few output values are needed, and can only output float arrays (int or object array inputs will be cast to float). Parameters ---------- in1 : array_like First input. in2 : array_like Second input. Should have the same number of dimensions as `in1`. If operating in 'valid' mode, either `in1` or `in2` must be at least as large as the other in every dimension. mode : str {'full', 'valid', 'same'}, optional A string indicating the size of the output: ``full`` The output is the full discrete linear convolution of the inputs. (Default) ``valid`` The output consists only of those elements that do not rely on the zero-padding. ``same`` The output is the same size as `in1`, centered with respect to the 'full' output. Returns ------- out : array An N-dimensional array containing a subset of the discrete linear convolution of `in1` with `in2`. Examples -------- Autocorrelation of white noise is an impulse. (This is at least 100 times as fast as `convolve`.) >>> from scipy import signal >>> sig = np.random.randn(1000) >>> autocorr = signal.fftconvolve(sig, sig[::-1], mode='full') >>> import matplotlib.pyplot as plt >>> fig, (ax_orig, ax_mag) = plt.subplots(2, 1) >>> ax_orig.plot(sig) >>> ax_orig.set_title('White noise') >>> ax_mag.plot(np.arange(-len(sig)+1,len(sig)), autocorr) >>> ax_mag.set_title('Autocorrelation') >>> fig.tight_layout() >>> fig.show() Gaussian blur implemented using FFT convolution. Notice the dark borders around the image, due to the zero-padding beyond its boundaries. The `convolve2d` function allows for other types of image boundaries, but is far slower. >>> from scipy import misc >>> face = misc.face(gray=True) >>> kernel = np.outer(signal.gaussian(70, 8), signal.gaussian(70, 8)) >>> blurred = signal.fftconvolve(face, kernel, mode='same') >>> fig, (ax_orig, ax_kernel, ax_blurred) = plt.subplots(3, 1, ... figsize=(6, 15)) >>> ax_orig.imshow(face, cmap='gray') >>> ax_orig.set_title('Original') >>> ax_orig.set_axis_off() >>> ax_kernel.imshow(kernel, cmap='gray') >>> ax_kernel.set_title('Gaussian kernel') >>> ax_kernel.set_axis_off() >>> ax_blurred.imshow(blurred, cmap='gray') >>> ax_blurred.set_title('Blurred') >>> ax_blurred.set_axis_off() >>> fig.show() r z/in1 and in2 should have the same dimensionalityr c S s( g | ] } t j j t | � � � q Srl )r �helperZ next_fast_len�int)rt �drl rl rm rw [ s z fftconvolve.<locals>.<listcomp>c S s% g | ] } t d t | � � � q S)r )rx r� )rt Zszrl rl rm rw \ s FNrc rb ra z5Acceptable mode flags are 'valid', 'same', or 'full'.)r rz ri r{ r r} r| Z issubdtyper �complexrs r� � _rfft_mt_safe� _rfft_lock�acquire�fftZrfftnZirfftnr� �releaser ZfftnZifftn�realr� ) r� r� rj �s1�s2Zcomplex_resultr} ZfshapeZfsliceZsp1Zsp2�retrl rl rm rD � sH O " ' c C s� t | � } t | � } | j | j k o5 d k n rB | | St | | j | j � rg | | } } | j | j k o� d k n r� | j | j k s� | d k r� t j | | | � St d d d � g | j } t | | | j � | � S)a� Convolve two N-dimensional arrays. Convolve `in1` and `in2`, with the output size determined by the `mode` argument. Parameters ---------- in1 : array_like First input. in2 : array_like Second input. Should have the same number of dimensions as `in1`. If operating in 'valid' mode, either `in1` or `in2` must be at least as large as the other in every dimension. mode : str {'full', 'valid', 'same'}, optional A string indicating the size of the output: ``full`` The output is the full discrete linear convolution of the inputs. (Default) ``valid`` The output consists only of those elements that do not rely on the zero-padding. ``same`` The output is the same size as `in1`, centered with respect to the 'full' output. Returns ------- convolve : array An N-dimensional array containing a subset of the discrete linear convolution of `in1` with `in2`. See also -------- numpy.polymul : performs polynomial multiplication (same operation, but also accepts poly1d objects) Examples -------- Smooth a square pulse using a Hann window: >>> from scipy import signal >>> sig = np.repeat([0., 1., 0.], 100) >>> win = signal.hann(50) >>> filtered = signal.convolve(sig, win, mode='same') / sum(win) >>> import matplotlib.pyplot as plt >>> fig, (ax_orig, ax_win, ax_filt) = plt.subplots(3, 1, sharex=True) >>> ax_orig.plot(sig) >>> ax_orig.set_title('Original pulse') >>> ax_orig.margins(0, 0.1) >>> ax_win.plot(win) >>> ax_win.set_title('Filter impulse response') >>> ax_win.margins(0, 0.1) >>> ax_filt.plot(filtered) >>> ax_filt.set_title('Filtered signal') >>> ax_filt.margins(0, 0.1) >>> fig.tight_layout() >>> fig.show() r r rb Nry ) r rz rs r} r{ r| rE rx rC r� )r� r� rj �volumeZkernelr� rl rl rm rE } s ? " 4 c C se t | � } | j } x: t t | � � D]& } | | d d k r( t d � � q( Wt j | | | � S)a� Perform an order filter on an N-dimensional array. Perform an order filter on the array in. The domain argument acts as a mask centered over each pixel. The non-zero elements of domain are used to select elements surrounding each input pixel which are placed in a list. The list is sorted, and the output for that pixel is the element corresponding to rank in the sorted list. Parameters ---------- a : ndarray The N-dimensional input array. domain : array_like A mask array with the same number of dimensions as `a`. Each dimension should have an odd number of elements. rank : int A non-negative integer which selects the element from the sorted list (0 corresponds to the smallest element, 1 is the next smallest element, etc.). Returns ------- out : ndarray The results of the order filter in an array with the same shape as `a`. Examples -------- >>> from scipy import signal >>> x = np.arange(25).reshape(5, 5) >>> domain = np.identity(3) >>> x array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14], [15, 16, 17, 18, 19], [20, 21, 22, 23, 24]]) >>> signal.order_filter(x, domain, 0) array([[ 0., 0., 0., 0., 0.], [ 0., 0., 1., 2., 0.], [ 0., 5., 6., 7., 0.], [ 0., 10., 11., 12., 0.], [ 0., 0., 0., 0., 0.]]) >>> signal.order_filter(x, domain, 2) array([[ 6., 7., 8., 9., 4.], [ 11., 12., 13., 14., 9.], [ 16., 17., 18., 19., 14.], [ 21., 22., 23., 24., 19.], [ 20., 21., 22., 23., 24.]]) rd r zIEach dimension of domain argument should have an odd number of elements.)r r} r� r� ri r �_order_filterND)�a�domain�rankr{ r� rl rl rm rH � s 5 c C s� t | � } | d k r( d g | j } t | � } | j f k r^ t j | j � | j � } x7 t | j � D]& } | | d d k rn t d � � qn Wt | � } t | d d �} | d } t j | | | � S)a� Perform a median filter on an N-dimensional array. Apply a median filter to the input array using a local window-size given by `kernel_size`. Parameters ---------- volume : array_like An N-dimensional input array. kernel_size : array_like, optional A scalar or an N-length list giving the size of the median filter window in each dimension. Elements of `kernel_size` should be odd. If `kernel_size` is a scalar, then this scalar is used as the size in each dimension. Default size is 3 for each dimension. Returns ------- out : ndarray An array the same size as input containing the median filtered result. Nr@ rd r z*Each element of kernel_size should be odd.�axisr ) r rz r r} r| �repeat�itemr� ri r r) r r� )r� � kernel_sizer� r� Znumels�orderrl rl rm rI s c C s t | � } | d k r( d g | j } t | � } | j f k r^ t j | j � | j � } t | t | � d � t | d d �} t | d t | � d � t | d d �| d } | d k r� t t | � d d �} | | } | d | | 9} | | 7} t | | k | | � } | S)a� Perform a Wiener filter on an N-dimensional array. Apply a Wiener filter to the N-dimensional array `im`. Parameters ---------- im : ndarray An N-dimensional array. mysize : int or array_like, optional A scalar or an N-length list giving the size of the Wiener filter window in each dimension. Elements of mysize should be odd. If mysize is a scalar, then this scalar is used as the size in each dimension. noise : float, optional The noise-power to use. If None, then noise is estimated as the average of the local variance of the input. Returns ------- out : ndarray Wiener filtered result with the same shape as `im`. Nr@ rb r� r rd r ) r rz r} r| r� r� rC r r) r r+ r4 )ZimZmysizeZnoiseZlMeanZlVar�resr� rl rl rm rK ; s () c C s� t | � } t | � } | j | j k o5 d k n sF t d � � t | | j | j � rk | | } } t | � } t | � } t j � �6 t j d t j � t j | | d | | | � } Wd QRX| S)aN Convolve two 2-dimensional arrays. Convolve `in1` and `in2` with output size determined by `mode`, and boundary conditions determined by `boundary` and `fillvalue`. Parameters ---------- in1 : array_like First input. in2 : array_like Second input. Should have the same number of dimensions as `in1`. If operating in 'valid' mode, either `in1` or `in2` must be at least as large as the other in every dimension. mode : str {'full', 'valid', 'same'}, optional A string indicating the size of the output: ``full`` The output is the full discrete linear convolution of the inputs. (Default) ``valid`` The output consists only of those elements that do not rely on the zero-padding. ``same`` The output is the same size as `in1`, centered with respect to the 'full' output. boundary : str {'fill', 'wrap', 'symm'}, optional A flag indicating how to handle boundaries: ``fill`` pad input arrays with fillvalue. (default) ``wrap`` circular boundary conditions. ``symm`` symmetrical boundary conditions. fillvalue : scalar, optional Value to fill pad input arrays with. Default is 0. Returns ------- out : ndarray A 2-dimensional array containing a subset of the discrete linear convolution of `in1` with `in2`. Examples -------- Compute the gradient of an image by 2D convolution with a complex Scharr operator. (Horizontal operator is real, vertical is imaginary.) Use symmetric boundary condition to avoid creating edges at the image boundaries. >>> from scipy import signal >>> from scipy import misc >>> ascent = misc.ascent() >>> scharr = np.array([[ -3-3j, 0-10j, +3 -3j], ... [-10+0j, 0+ 0j, +10 +0j], ... [ -3+3j, 0+10j, +3 +3j]]) # Gx + j*Gy >>> grad = signal.convolve2d(ascent, scharr, boundary='symm', mode='same') >>> import matplotlib.pyplot as plt >>> fig, (ax_orig, ax_mag, ax_ang) = plt.subplots(3, 1, figsize=(6, 15)) >>> ax_orig.imshow(ascent, cmap='gray') >>> ax_orig.set_title('Original') >>> ax_orig.set_axis_off() >>> ax_mag.imshow(np.absolute(grad), cmap='gray') >>> ax_mag.set_title('Gradient magnitude') >>> ax_mag.set_axis_off() >>> ax_ang.imshow(np.angle(grad), cmap='hsv') # hsv is cyclic, like angles >>> ax_ang.set_title('Gradient orientation') >>> ax_ang.set_axis_off() >>> fig.show() rd z(convolve2d inputs must both be 2D arrays�ignorer N)r rz ri rs r} rn rq �warnings�catch_warnings� simplefilterr| �ComplexWarningr � _convolve2d)r� r� rj rp � fillvaluerk �bvalr� rl rl rm rF n s L " %c C s� t | � } t | � } | j | j k o5 d k n sF t d � � t | | j | j � } | rq | | } } t | � } t | � } t j � �6 t j d t j � t j | | d | | | � } Wd QRX| r� | d d d � d d d � f } | S) a� Cross-correlate two 2-dimensional arrays. Cross correlate `in1` and `in2` with output size determined by `mode`, and boundary conditions determined by `boundary` and `fillvalue`. Parameters ---------- in1 : array_like First input. in2 : array_like Second input. Should have the same number of dimensions as `in1`. If operating in 'valid' mode, either `in1` or `in2` must be at least as large as the other in every dimension. mode : str {'full', 'valid', 'same'}, optional A string indicating the size of the output: ``full`` The output is the full discrete linear cross-correlation of the inputs. (Default) ``valid`` The output consists only of those elements that do not rely on the zero-padding. ``same`` The output is the same size as `in1`, centered with respect to the 'full' output. boundary : str {'fill', 'wrap', 'symm'}, optional A flag indicating how to handle boundaries: ``fill`` pad input arrays with fillvalue. (default) ``wrap`` circular boundary conditions. ``symm`` symmetrical boundary conditions. fillvalue : scalar, optional Value to fill pad input arrays with. Default is 0. Returns ------- correlate2d : ndarray A 2-dimensional array containing a subset of the discrete linear cross-correlation of `in1` with `in2`. Examples -------- Use 2D cross-correlation to find the location of a template in a noisy image: >>> from scipy import signal >>> from scipy import misc >>> face = misc.face(gray=True) - misc.face(gray=True).mean() >>> template = np.copy(face[300:365, 670:750]) # right eye >>> template -= template.mean() >>> face = face + np.random.randn(*face.shape) * 50 # add noise >>> corr = signal.correlate2d(face, template, boundary='symm', mode='same') >>> y, x = np.unravel_index(np.argmax(corr), corr.shape) # find the match >>> import matplotlib.pyplot as plt >>> fig, (ax_orig, ax_template, ax_corr) = plt.subplots(3, 1, ... figsize=(6, 15)) >>> ax_orig.imshow(face, cmap='gray') >>> ax_orig.set_title('Original') >>> ax_orig.set_axis_off() >>> ax_template.imshow(template, cmap='gray') >>> ax_template.set_title('Template') >>> ax_template.set_axis_off() >>> ax_corr.imshow(corr, cmap='gray') >>> ax_corr.set_title('Cross-correlation') >>> ax_corr.set_axis_off() >>> ax_orig.plot(x, y, 'ro') >>> fig.show() rd z)correlate2d inputs must both be 2D arraysr� r Nr ry ry )r rz ri rs r} rn rq r� r� r� r| r� r r� ) r� r� rj rp r� r� rk r� r� rl rl rm rG � s M " %"c C s� t | � } | d k r% d g d } t | � } | j f k rX t j | j � d � } x* | D]" } | d d k r_ t d � � q_ Wt j | | � S)a� Median filter a 2-dimensional array. Apply a median filter to the `input` array using a local window-size given by `kernel_size` (must be odd). Parameters ---------- input : array_like A 2-dimensional input array. kernel_size : array_like, optional A scalar or a list of length 2, giving the size of the median filter window in each dimension. Elements of `kernel_size` should be odd. If `kernel_size` is a scalar, then this scalar is used as the size in each dimension. Default is a kernel of size (3, 3). Returns ------- out : ndarray An array the same size as input containing the median filtered result. Nr@ rd r z*Each element of kernel_size should be odd.)r r} r| r� r� ri r Z _medfilt2d)�inputr� Zimager{ rl rl rm rJ 3 s c s� t j | � } t | � d k r�t j � � � t j | � } � j d k ri | j d k ri t d � � t j | � } � | | g } | d k r t j | � } | j | j k r� t d � � t | j � } � j d d | | <t | � } | j | k r| j d g } | d k r(| | j 7} x� t | j � D]� } | | k ru| j | | | k ru| j | | | <q8| | k r�| j | | | k r�| j | | | <q8| | k r�| j | d k r�d | | <q8t d | | j f � � q8Wt j j j | | | � } | j | � t j | � } | j d k rKt d | � � t j � d | �� t j | d | d d �} � | d � t j | d | d d �} t j � f d d � | | � } | j t d � g } | d k r t | j | � | | <| | | 7<t | j | t � � d � | | <| | } | d k rK| St | j | t � � d d � | | <| | } | | f Sn; | d k r�t j � | | | � St j � | | | | � Sd S) a2 Filter data along one-dimension with an IIR or FIR filter. Filter a data sequence, `x`, using a digital filter. This works for many fundamental data types (including Object type). The filter is a direct form II transposed implementation of the standard difference equation (see Notes). Parameters ---------- b : array_like The numerator coefficient vector in a 1-D sequence. a : array_like The denominator coefficient vector in a 1-D sequence. If ``a[0]`` is not 1, then both `a` and `b` are normalized by ``a[0]``. x : array_like An N-dimensional input array. axis : int, optional The axis of the input data array along which to apply the linear filter. The filter is applied to each subarray along this axis. Default is -1. zi : array_like, optional Initial conditions for the filter delays. It is a vector (or array of vectors for an N-dimensional input) of length ``max(len(a), len(b)) - 1``. If `zi` is None or is not given then initial rest is assumed. See `lfiltic` for more information. Returns ------- y : array The output of the digital filter. zf : array, optional If `zi` is None, this is not returned, otherwise, `zf` holds the final filter delay values. See Also -------- lfiltic : Construct initial conditions for `lfilter`. lfilter_zi : Compute initial state (steady state of step response) for `lfilter`. filtfilt : A forward-backward filter, to obtain a filter with linear phase. savgol_filter : A Savitzky-Golay filter. sosfilt: Filter data using cascaded second-order sections. sosfiltfilt: A forward-backward filter using second-order sections. Notes ----- The filter function is implemented as a direct II transposed structure. This means that the filter implements:: a[0]*y[n] = b[0]*x[n] + b[1]*x[n-1] + ... + b[M]*x[n-M] - a[1]*y[n-1] - ... - a[N]*y[n-N] where `M` is the degree of the numerator, `N` is the degree of the denominator, and `n` is the sample number. It is implemented using the following difference equations (assuming M = N):: a[0]*y[n] = b[0] * x[n] + d[0][n-1] d[0][n] = b[1] * x[n] - a[1] * y[n] + d[1][n-1] d[1][n] = b[2] * x[n] - a[2] * y[n] + d[2][n-1] ... d[N-2][n] = b[N-1]*x[n] - a[N-1]*y[n] + d[N-1][n-1] d[N-1][n] = b[N] * x[n] - a[N] * y[n] where `d` are the state variables. The rational transfer function describing this filter in the z-transform domain is:: -1 -M b[0] + b[1]z + ... + b[M] z Y(z) = -------------------------------- X(z) -1 -N a[0] + a[1]z + ... + a[N] z Examples -------- Generate a noisy signal to be filtered: >>> from scipy import signal >>> import matplotlib.pyplot as plt >>> t = np.linspace(-1, 1, 201) >>> x = (np.sin(2*np.pi*0.75*t*(1-t) + 2.1) + 0.1*np.sin(2*np.pi*1.25*t + 1) ... + 0.18*np.cos(2*np.pi*3.85*t)) >>> xn = x + np.random.randn(len(t)) * 0.08 Create an order 3 lowpass butterworth filter: >>> b, a = signal.butter(3, 0.05) Apply the filter to xn. Use lfilter_zi to choose the initial condition of the filter: >>> zi = signal.lfilter_zi(b, a) >>> z, _ = signal.lfilter(b, a, xn, zi=zi*xn[0]) Apply the filter again, to have a result filtered at an order the same as filtfilt: >>> z2, _ = signal.lfilter(b, a, z, zi=zi*z[0]) Use filtfilt to apply the filter: >>> y = signal.filtfilt(b, a, xn) Plot the original signal and the various filtered versions: >>> plt.figure >>> plt.plot(t, xn, 'b', alpha=0.75) >>> plt.plot(t, z, 'r--', t, z2, 'r', t, y, 'k') >>> plt.legend(('noisy signal', 'lfilter, once', 'lfilter, twice', ... 'filtfilt'), loc='best') >>> plt.grid(True) >>> plt.show() r z+object of too small depth for desired arrayNr z/Unexpected shape for zi: expected %s, found %s.ZfdgFDGOz input type '%s' not supportedr r� Fc s t j � | � S)N)r| rE )�y)�brl rm �<lambda>� s zlfilter.<locals>.<lambda>)r| r r� r rz ri �listr} r� r� �strides�libZ stride_tricksZ as_strided�appendZ result_type�char�NotImplementedErrorr �apply_along_axisrx r Z_linear_filter)r� r� �xr� �ziZinputsZexpected_shaper� r� r Zout_full�indr� �zfrl )r� rm rL Z sh u ## ! % ( c C s� t j | � d } t j | � d } t | | � } t | � } | j j d k re | j t j � } t | | j � } | d k r� t | | j � } nA t | � } t j | � } | | k r� t | t | | � f } t j | � } | | k rt | t | | � f } xJ t | � D]< } t | | d d � | d | | � d d �| | <qWxN t | � D]@ } | | t | | d d � | d | | � d d �8<qhW| S)a Construct initial conditions for lfilter. Given a linear filter (b, a) and initial conditions on the output `y` and the input `x`, return the initial conditions on the state vector zi which is used by `lfilter` to generate the output given the input. Parameters ---------- b : array_like Linear filter term. a : array_like Linear filter term. y : array_like Initial conditions. If ``N = len(a) - 1``, then ``y = {y[-1], y[-2], ..., y[-N]}``. If `y` is too short, it is padded with zeros. x : array_like, optional Initial conditions. If ``M = len(b) - 1``, then ``x = {x[-1], x[-2], ..., x[-M]}``. If `x` is not given, its initial conditions are assumed zero. If `x` is too short, it is padded with zeros. Returns ------- zi : ndarray The state vector ``zi = {z_0[-1], z_1[-1], ..., z_K-1[-1]}``, where ``K = max(M, N)``. See Also -------- lfilter, lfilter_zi r ZbuiNr� r ) r| r{ �maxr r �kind�astypeZfloat64r5 r* r� r0 ) r� r� r� r� �N�M�Kr� �L�mrl rl rm rM s* ( :>c C s� t | � } t | � } t | � } t | � } | | k rK g } | } nR t | | d t � } d | d d � <t | | | � } | t | | d d �} | | f S)as Deconvolves ``divisor`` out of ``signal``. Returns the quotient and remainder such that ``signal = convolve(divisor, quotient) + remainder`` Parameters ---------- signal : array_like Signal data, typically a recorded signal divisor : array_like Divisor data, typically an impulse response or filter that was applied to the original signal Returns ------- quotient : ndarray Quotient, typically the recovered original signal remainder : ndarray Remainder Examples -------- Deconvolve a signal that's been filtered: >>> from scipy import signal >>> original = [0, 1, 0, 0, 1, 1, 0, 0] >>> impulse_response = [2, 1] >>> recorded = signal.convolve(impulse_response, original) >>> recorded array([0, 2, 1, 0, 2, 3, 1, 0, 0]) >>> recovered, remainder = signal.deconvolve(recorded, impulse_response) >>> recovered array([ 0., 1., 0., 0., 1., 1., 0., 0.]) See also -------- numpy.polydiv : performs polynomial division (same operation, but also accepts poly1d objects) r r Nrj rc )r r� r �floatrL rE ) �signalZdivisor�num�denr� �DZquot�remr� rl rl rm rO X s ) c C s. t | � } t | � r$ t d � � | d k r= | j | } | d k rU t d � � t j | | d | �} t | � } | d d k r� d | d <| | d <d | d | d � <n" d | d <d | d | d d � <| j d k rt g | j } t d � | | <| | } t j | | d | �} | S)aU Compute the analytic signal, using the Hilbert transform. The transformation is done along the last axis by default. Parameters ---------- x : array_like Signal data. Must be real. N : int, optional Number of Fourier components. Default: ``x.shape[axis]`` axis : int, optional Axis along which to do the transformation. Default: -1. Returns ------- xa : ndarray Analytic signal of `x`, of each 1-D array along `axis` Notes ----- The analytic signal ``x_a(t)`` of signal ``x(t)`` is: .. math:: x_a = F^{-1}(F(x) 2U) = x + i y where `F` is the Fourier transform, `U` the unit step function, and `y` the Hilbert transform of `x`. [1]_ In other words, the negative half of the frequency spectrum is zeroed out, turning the real-valued signal into a complex signal. The Hilbert transformed signal can be obtained from ``np.imag(hilbert(x))``, and the original signal from ``np.real(hilbert(x))``. Examples --------- In this example we use the Hilbert transform to determine the amplitude envelope and instantaneous frequency of an amplitude-modulated signal. >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.signal import hilbert, chirp >>> duration = 1.0 >>> fs = 400.0 >>> samples = int(fs*duration) >>> t = np.arange(samples) / fs We create a chirp of which the frequency increases from 20 Hz to 100 Hz and apply an amplitude modulation. >>> signal = chirp(t, 20.0, t[-1], 100.0) >>> signal *= (1.0 + 0.5 * np.sin(2.0*np.pi*3.0*t) ) The amplitude envelope is given by magnitude of the analytic signal. The instantaneous frequency can be obtained by differentiating the instantaneous phase in respect to time. The instantaneous phase corresponds to the phase angle of the analytic signal. >>> analytic_signal = hilbert(signal) >>> amplitude_envelope = np.abs(analytic_signal) >>> instantaneous_phase = np.unwrap(np.angle(analytic_signal)) >>> instantaneous_frequency = np.diff(instantaneous_phase) / (2.0*np.pi) * fs >>> fig = plt.figure() >>> ax0 = fig.add_subplot(211) >>> ax0.plot(t, signal, label='signal') >>> ax0.plot(t, amplitude_envelope, label='envelope') >>> ax0.set_xlabel("time in seconds") >>> ax0.legend() >>> ax1 = fig.add_subplot(212) >>> ax1.plot(t[1:], instantaneous_frequency) >>> ax1.set_xlabel("time in seconds") >>> ax1.set_ylim(0.0, 120.0) References ---------- .. [1] Wikipedia, "Analytic signal". http://en.wikipedia.org/wiki/Analytic_signal .. [2] Leon Cohen, "Time-Frequency Analysis", 1995. Chapter 2. .. [3] Alan V. Oppenheim, Ronald W. Schafer. Discrete-Time Signal Processing, Third Edition, 2009. Chapter 12. ISBN 13: 978-1292-02572-8 zx must be real.Nr zN must be positive.r� rd r ) r r ri r} r r� r5 rz r rx �ifft)r� r� r� �Xf�hr� rl rl rm rP � s( T c C s< t | � } | j d k r' t d � � t | � r? t d � � | d k rW | j } nr t | t � r� | d k r~ t d � � | | f } n< t | � d k s� t j t j | � d k � r� t d � � t j | | d d �} t | d d � } t | d d � } x� t d � D]� } t d | d � } | | } | d d k rud | d <| | d <d | d | d � <n" d | d <d | d | d d � <t d | d t � t � � qW| d d � t f | t d d � f } | j } x0 | d k r | d d � t f } | d 8} q�Wt j | | d d �} | S)a� Compute the '2-D' analytic signal of `x` Parameters ---------- x : array_like 2-D signal data. N : int or tuple of two ints, optional Number of Fourier components. Default is ``x.shape`` Returns ------- xa : ndarray Analytic signal of `x` taken along axes (0,1). References ---------- .. [1] Wikipedia, "Analytic signal", http://en.wikipedia.org/wiki/Analytic_signal rd zx must be 2-D.zx must be real.Nr zN must be positive.z@When given as a tuple, N must hold exactly two positive integersZaxesr r� zh%dzh%d = h)r r )r r )r rz ri r r} � isinstancer� r� r| �anyr r Zfft2r5 r� �eval�exec�globals�localsr Zifft2) r� r� r� Zh1Zh2�pr� ZN1r� rl rl rm rQ � s@ 0 "* c C sO t | � } t | � r- t t | � � } n t | � } t | | d � | f S)a Sort roots based on magnitude. Parameters ---------- p : array_like The roots to sort, as a 1-D array. Returns ------- p_sorted : ndarray Sorted roots. indx : ndarray Array of indices needed to sort the input `p`. r )r r r �absr1 )r� �indxrl rl rm rR 9 s g����MbP?�minc C sf | d k r t j } n< | d k r0 t j } n$ | d k rH t j } n t d � � t | � d } t | � } t | � \ } } g } g } d } | d d | } g } x� t t | � � D]� } | | } t | | � | k r| j | � | | � } | | | <| | d 7<q� | j | � | } | g } | d 7} | j d � q� Wt | � t | � f S)a� Determine unique roots and their multiplicities from a list of roots. Parameters ---------- p : array_like The list of roots. tol : float, optional The tolerance for two roots to be considered equal. Default is 1e-3. rtype : {'max', 'min, 'avg'}, optional How to determine the returned root if multiple roots are within `tol` of each other. - 'max': pick the maximum of those roots. - 'min': pick the minimum of those roots. - 'avg': take the average of those roots. Returns ------- pout : ndarray The list of unique roots, sorted from low to high. mult : ndarray The multiplicity of each root. Notes ----- This utility function is not specific to roots but can be used for any sequence of values for which uniqueness and multiplicity has to be determined. For a more general routine, see `numpy.unique`. Examples -------- >>> from scipy import signal >>> vals = [0, 1.3, 1.31, 2.8, 1.25, 2.2, 10.3] >>> uniq, mult = signal.unique_roots(vals, tol=2e-2, rtype='avg') Check which roots have multiplicity larger than 1: >>> uniq[mult > 1] array([ 1.305]) r� �maximumr� �minimum�avgr zJ`rtype` must be one of {'max', 'maximum', 'min', 'minimum', 'avg', 'mean'}g �?r r rA )r� r� )r� r� )r� r ry ) r| r� r� r ri r r� rR r� r� r� r ) r� �tol�rtypeZcomprootr� �pout�multZcurpZ samerootsr� Ztrrl rl rm rS Q s8 + r� c C s | } t | � \ } } t | | d � } t | d | d | �\ } } g } x6 t t | � � D]" } | j | | g | | � qa Wt t | � � } t | � d k r� t | | � } n d g } d } x� t t | � � D]� } g } xB t t | � � D]. } | | k r� | j | | g | | � q� Wxy t | | � D]g } | d d � } | j | | g | | | d � t | | | t t | � � � } | d 7} qAWq� Wt | � } x@ t | d d d d �r�| j d d k r�| d d � } q�W| | f S) a$ Compute b(s) and a(s) from partial fraction expansion. If `M` is the degree of numerator `b` and `N` the degree of denominator `a`:: b(s) b[0] s**(M) + b[1] s**(M-1) + ... + b[M] H(s) = ------ = ------------------------------------------ a(s) a[0] s**(N) + a[1] s**(N-1) + ... + a[N] then the partial-fraction expansion H(s) is defined as:: r[0] r[1] r[-1] = -------- + -------- + ... + --------- + k(s) (s-p[0]) (s-p[1]) (s-p[-1]) If there are any repeated roots (closer together than `tol`), then H(s) has terms like:: r[i] r[i+1] r[i+n-1] -------- + ----------- + ... + ----------- (s-p[i]) (s-p[i])**2 (s-p[i])**n This function is used for polynomials in positive powers of s or z, such as analog filters or digital filters in controls engineering. For negative powers of z (typical for digital filters in DSP), use `invresz`. Parameters ---------- r : array_like Residues. p : array_like Poles. k : array_like Coefficients of the direct polynomial term. tol : float, optional The tolerance for two roots to be considered equal. Default is 1e-3. rtype : {'max', 'min, 'avg'}, optional How to determine the returned root if multiple roots are within `tol` of each other. - 'max': pick the maximum of those roots. - 'min': pick the minimum of those roots. - 'avg': take the average of those roots. Returns ------- b : ndarray Numerator polynomial coefficients. a : ndarray Denominator polynomial coefficients. See Also -------- residue, invresz, unique_roots r r� r� Nr Zrtolg�+����=ry ) rR r1 rS r� r� �extendr r! r% r" r, r r} )�rr� r� r� r� �extrar� r� r� r� r� �temp�lr� �t2rl rl rm rT � s4 : $# /c C s t t | | f � \ } } | d } t | | � \ } } t | � } | d } t | d | d | �\ } } g } x6 t t | � � D]" } | j | | g | | � q� Wt | � } d } xLt t | � � D]8} | j � } g } xB t t | � � D]. } | | k r� | j | | g | | � q� Wt t | � � } | | } x� t | d d � D]� } | | k r�t t | d � | � } t | t | d � � } t | | � } t | | � } t | | | � t | | | � t | | � | | | d <q^W| | 7} q� W| | | | f S)a� Compute partial-fraction expansion of b(s) / a(s). If `M` is the degree of numerator `b` and `N` the degree of denominator `a`:: b(s) b[0] s**(M) + b[1] s**(M-1) + ... + b[M] H(s) = ------ = ------------------------------------------ a(s) a[0] s**(N) + a[1] s**(N-1) + ... + a[N] then the partial-fraction expansion H(s) is defined as:: r[0] r[1] r[-1] = -------- + -------- + ... + --------- + k(s) (s-p[0]) (s-p[1]) (s-p[-1]) If there are any repeated roots (closer together than `tol`), then H(s) has terms like:: r[i] r[i+1] r[i+n-1] -------- + ----------- + ... + ----------- (s-p[i]) (s-p[i])**2 (s-p[i])**n This function is used for polynomials in positive powers of s or z, such as analog filters or digital filters in controls engineering. For negative powers of z (typical for digital filters in DSP), use `residuez`. Parameters ---------- b : array_like Numerator polynomial coefficients. a : array_like Denominator polynomial coefficients. Returns ------- r : ndarray Residues. p : ndarray Poles. k : ndarray Coefficients of the direct polynomial term. See Also -------- invres, residuez, numpy.poly, unique_roots r g r� r� r ry )�mapr r$ r. rS r� r� r� r� r r! r% r# r& r' r7 )r� r� r� r� Zrscaler� r� r� r� r� �nr� �bn�pnr� �an�sigr� �term1�term2rl rl rm rV � s8 2 Bc C s� t t | | f � \ } } | d } | d d d � | d d d � } } t | | � \ } } | g k rv g } n | d d d � } | d d d � } t | � } | d } t | d | d | �\ } } g } x6 t t | � � D]" } | j | | g | | � q� Wt | � } d } xrt t | � � D]^} | j � } g } xB t t | � � D]. } | | k r_| j | | g | | � q_Wt t | � � d d d � } | | } x� t | d d � D]� } | | k r-t t | d � | � } t | t | d � � } t | | � } t | | � } t | d | | � t | d | | � t | | � | | | | | | | d <q�W| | 7} q4W| | | | f S)a� Compute partial-fraction expansion of b(z) / a(z). If `M` is the degree of numerator `b` and `N` the degree of denominator `a`:: b(z) b[0] + b[1] z**(-1) + ... + b[M] z**(-M) H(z) = ------ = ------------------------------------------ a(z) a[0] + a[1] z**(-1) + ... + a[N] z**(-N) then the partial-fraction expansion H(z) is defined as:: r[0] r[-1] = --------------- + ... + ---------------- + k[0] + k[1]z**(-1) ... (1-p[0]z**(-1)) (1-p[-1]z**(-1)) If there are any repeated roots (closer than `tol`), then the partial fraction expansion has terms like:: r[i] r[i+1] r[i+n-1] -------------- + ------------------ + ... + ------------------ (1-p[i]z**(-1)) (1-p[i]z**(-1))**2 (1-p[i]z**(-1))**n This function is used for polynomials in negative powers of z, such as digital filters in DSP. For positive powers, use `residue`. Parameters ---------- b : array_like Numerator polynomial coefficients. a : array_like Denominator polynomial coefficients. Returns ------- r : ndarray Residues. p : ndarray Poles. k : ndarray Coefficients of the direct polynomial term. See also -------- invresz, residue, unique_roots r Nr g r� r� g �?ry ry ry ry ry ry )r� r r$ r. rS r� r� r� r� r r! r% r# r& r' r7 )r� r� r� r� Zgain�brevZarevZkrevr� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rl rl rm rW I sB 0 ' [c C s� t | � } t | � \ } } t | | d � } t | d | d | �\ } } g } x6 t t | � � D]" } | j | | g | | � qg Wt t | � � } t | � d k r� t | | � } n d g } d } t | � d d d � } x� t t | � � D]� } g } xB t t | � � D]. } | | k r | j | | g | | � q Wx� t | | � D]t } | d d � } | j | | g | | | d � t | | | t t | � � d d d � � } | d 7} q`Wq� Wt | d d d � � } | | f S) a. Compute b(z) and a(z) from partial fraction expansion. If `M` is the degree of numerator `b` and `N` the degree of denominator `a`:: b(z) b[0] + b[1] z**(-1) + ... + b[M] z**(-M) H(z) = ------ = ------------------------------------------ a(z) a[0] + a[1] z**(-1) + ... + a[N] z**(-N) then the partial-fraction expansion H(z) is defined as:: r[0] r[-1] = --------------- + ... + ---------------- + k[0] + k[1]z**(-1) ... (1-p[0]z**(-1)) (1-p[-1]z**(-1)) If there are any repeated roots (closer than `tol`), then the partial fraction expansion has terms like:: r[i] r[i+1] r[i+n-1] -------------- + ------------------ + ... + ------------------ (1-p[i]z**(-1)) (1-p[i]z**(-1))**2 (1-p[i]z**(-1))**n This function is used for polynomials in negative powers of z, such as digital filters in DSP. For positive powers, use `invres`. Parameters ---------- r : array_like Residues. p : array_like Poles. k : array_like Coefficients of the direct polynomial term. tol : float, optional The tolerance for two roots to be considered equal. Default is 1e-3. rtype : {'max', 'min, 'avg'}, optional How to determine the returned root if multiple roots are within `tol` of each other. - 'max': pick the maximum of those roots. - 'min': pick the minimum of those roots. - 'avg': take the average of those roots. Returns ------- b : ndarray Numerator polynomial coefficients. a : ndarray Denominator polynomial coefficients. See Also -------- residuez, unique_roots, invres r r� r� Nr ry ry ry ) r rR r1 rS r� r� r� r r! r% r" r, )r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rl rl rm rU � s2 9 $0c C s t | � } t j | d | �} | j | } | d k r� t | � r^ | t j | � � } nN t | t � r� | j | f k r� t d � � | } n t j t | | � � } d g | j } t | � | | <| | _ | | } t d � g | j } t | j � } | | | <t t j | | � � } t | d � } t d | d d � | | <| | | | <t | d d d � | | <| | | | <t j | d | �t | � t | � } | j j d k r�| j } | d k r�| St d | � | d | d | t | � | d } | | f Sd S) a� Resample `x` to `num` samples using Fourier method along the given axis. The resampled signal starts at the same value as `x` but is sampled with a spacing of ``len(x) / num * (spacing of x)``. Because a Fourier method is used, the signal is assumed to be periodic. Parameters ---------- x : array_like The data to be resampled. num : int The number of samples in the resampled signal. t : array_like, optional If `t` is given, it is assumed to be the sample positions associated with the signal data in `x`. axis : int, optional The axis of `x` that is resampled. Default is 0. window : array_like, callable, string, float, or tuple, optional Specifies the window applied to the signal in the Fourier domain. See below for details. Returns ------- resampled_x or (resampled_x, resampled_t) Either the resampled array, or, if `t` was given, a tuple containing the resampled array and the corresponding resampled positions. See also -------- decimate : Downsample the signal after applying an FIR or IIR filter. resample_poly : Resample using polyphase filtering and an FIR filter. Notes ----- The argument `window` controls a Fourier-domain window that tapers the Fourier spectrum before zero-padding to alleviate ringing in the resampled values for sampled signals you didn't intend to be interpreted as band-limited. If `window` is a function, then it is called with a vector of inputs indicating the frequency bins (i.e. fftfreq(x.shape[axis]) ). If `window` is an array of the same length as `x.shape[axis]` it is assumed to be the window to be applied directly in the Fourier domain (with dc and low-frequency first). For any other type of `window`, the function `scipy.signal.get_window` is called to generate the window. The first sample of the returned vector is the same as the first sample of the input vector. The spacing between samples is changed from ``dx`` to ``dx * len(x) / num``. If `t` is not None, then it represents the old sample positions, and the new sample positions will be returned as well as the new samples. As noted, `resample` uses FFT transformations, which can be very slow if the number of input or output samples is large and prime; see `scipy.fftpack.fft`. Examples -------- Note that the end of the resampled data rises to meet the first sample of the next cycle: >>> from scipy import signal >>> x = np.linspace(0, 10, 20, endpoint=False) >>> y = np.cos(-x**2/6.0) >>> f = signal.resample(y, 100) >>> xnew = np.linspace(0, 10, 100, endpoint=False) >>> import matplotlib.pyplot as plt >>> plt.plot(x, y, 'go-', xnew, f, '.-', 10, y[0], 'ro') >>> plt.legend(['data', 'resampled'], loc='best') >>> plt.show() r� Nz(window must have the same length as datar r� r rd �F)r� r� )r r r� r} r Zfftfreqr� r ri Z ifftshiftr8 rz r� rx r� r� r| r� r5 r� r� r r� r� r )r� r� �tr� �window�XZNx�Wr� �slr� �Yr� Znew_trl rl rm rX � s> Q ) 5�kaiser� @c sA t | � } t | � } t | � } | d k s< | d k rH t d � � t | | � } | | } | | } | | k o� d k n r� | j � S| j | | } | | t | | � } t | t t j f � rt | � } | j d k r� t d � � | j d d } | } n@ t | | � } d | } d | } t d | d | d | �} | | 9} | | | } d } | | | � xB t t | � | | | j | | | � | � k r�| d 7} q�Wt j t j | � | t j | � f � } t | | j | | � � � | � � � � f d d � } t j | | | � } | S) a� Resample `x` along the given axis using polyphase filtering. The signal `x` is upsampled by the factor `up`, a zero-phase low-pass FIR filter is applied, and then it is downsampled by the factor `down`. The resulting sample rate is ``up / down`` times the original sample rate. Values beyond the boundary of the signal are assumed to be zero during the filtering step. Parameters ---------- x : array_like The data to be resampled. up : int The upsampling factor. down : int The downsampling factor. axis : int, optional The axis of `x` that is resampled. Default is 0. window : string, tuple, or array_like, optional Desired window to use to design the low-pass filter, or the FIR filter coefficients to employ. See below for details. Returns ------- resampled_x : array The resampled array. See also -------- decimate : Downsample the signal after applying an FIR or IIR filter. resample : Resample up or down using the FFT method. Notes ----- This polyphase method will likely be faster than the Fourier method in `scipy.signal.resample` when the number of samples is large and prime, or when the number of samples is large and `up` and `down` share a large greatest common denominator. The length of the FIR filter used will depend on ``max(up, down) // gcd(up, down)``, and the number of operations during polyphase filtering will depend on the filter length and `down` (see `scipy.signal.upfirdn` for details). The argument `window` specifies the FIR low-pass filter design. If `window` is an array_like it is assumed to be the FIR filter coefficients. Note that the FIR filter is applied after the upsampling step, so it should be designed to operate on a signal at a sampling frequency higher than the original by a factor of `up//gcd(up, down)`. This function's output will be centered with respect to this array, so it is best to pass a symmetric filter with an odd number of samples if, as is usually the case, a zero-phase filter is desired. For any other type of `window`, the functions `scipy.signal.get_window` and `scipy.signal.firwin` are called to generate the appropriate filter coefficients. The first sample of the returned vector is the same as the first sample of the input vector. The spacing between samples is changed from ``dx`` to ``dx * up / float(down)``. Examples -------- Note that the end of the resampled data rises to meet the first sample of the next cycle for the FFT method, and gets closer to zero for the polyphase method: >>> from scipy import signal >>> x = np.linspace(0, 10, 20, endpoint=False) >>> y = np.cos(-x**2/6.0) >>> f_fft = signal.resample(y, 100) >>> f_poly = signal.resample_poly(y, 100, 20) >>> xnew = np.linspace(0, 10, 100, endpoint=False) >>> import matplotlib.pyplot as plt >>> plt.plot(xnew, f_fft, 'b.-', xnew, f_poly, 'r.-') >>> plt.plot(x, y, 'ko-') >>> plt.plot(10, y[0], 'bo', 10, 0., 'ro') # boundaries >>> plt.legend(['resample', 'resamp_poly', 'data'], loc='best') >>> plt.show() r zup and down must be >= 1zwindow must be 1-Drd g �?� r� r c s � j | � � � � S)z*Apply the upfirdn filter and remove excess)Z apply_filter)r� )� n_pre_remove�n_pre_remove_end�ufdrl rm � apply_remove� s z#resample_poly.<locals>.apply_remove)r r� ri rB r� r} �boolr� r� r| r rz r{ r� r? r r� � concatenater5 r r r� )r� �up�downr� r� Zg_�n_outZhalf_lenr� Zmax_rateZf_cZ n_pre_padZ n_post_padr� r� rl )r� r� r� rm rY r sF S !* c C s� t | � } t | � } | j d k r3 t d � � | j d k rN t d � � | j } t | � } t | � } | d k j � r� t d � � t t d t | j | � � } t | d d �} t | � } t | � } | r� | d } | d } | | f S)a� Determine the vector strength of the events corresponding to the given period. The vector strength is a measure of phase synchrony, how well the timing of the events is synchronized to a single period of a periodic signal. If multiple periods are used, calculate the vector strength of each. This is called the "resonating vector strength". Parameters ---------- events : 1D array_like An array of time points containing the timing of the events. period : float or array_like The period of the signal that the events should synchronize to. The period is in the same units as `events`. It can also be an array of periods, in which case the outputs are arrays of the same length. Returns ------- strength : float or 1D array The strength of the synchronization. 1.0 is perfect synchronization and 0.0 is no synchronization. If `period` is an array, this is also an array with each element containing the vector strength at the corresponding period. phase : float or array The phase that the events are most strongly synchronized to in radians. If `period` is an array, this is also an array with each element containing the phase for the corresponding period. References ---------- van Hemmen, JL, Longtin, A, and Vollmayr, AN. Testing resonating vector strength: Auditory system, electric fish, and noise. Chaos 21, 047508 (2011); doi: 10.1063/1.3670512 van Hemmen, JL. Vector strength after Goldberg, Brown, and von Mises: biological and mathematical perspectives. Biol Cybern. 2013 Aug;107(4):385-96. doi: 10.1007/s00422-013-0561-7. van Hemmen, JL and Vollmayr, AN. Resonating vector strength: what happens when we vary the "probing" frequency while keeping the spike times fixed. Biol Cybern. 2013 Aug;107(4):491-94. doi: 10.1007/s00422-013-0560-8 r z)events cannot have dimensions more than 1z)period cannot have dimensions more than 1r zperiods must be positivey @r� ) r rz ri r r� r r r �Tr r� r )�eventsZperiodZ scalarperiodZvectorsZ vectormeanZstrengthZphaserl rl rm r` � s& / �linearc C s� | d k r t d � � t | � } | j j } | d k rB d } | d k rn | t t | | � | � } | S| j } | | } t t t d | | f � � } t j | | k � r� t d � � t | � d } t | � } | d k r� | | } t | d | � | d | � f } t t | t | � � | t | d d �| f � } | j � } | j j d k rw| j | � } x� t | � D]� } | | d | | } t | d f | � } t | t d | d � d | � | d d � d f <t | | | | d � } t j | | | � \ } } } } | | t | | � | | <q�Wt | | d � } t | t | � � } t t d | � � } | d | � d g | | d � } t | t | � � } | Sd S)ab Remove linear trend along axis from data. Parameters ---------- data : array_like The input data. axis : int, optional The axis along which to detrend the data. By default this is the last axis (-1). type : {'linear', 'constant'}, optional The type of detrending. If ``type == 'linear'`` (default), the result of a linear least-squares fit to `data` is subtracted from `data`. If ``type == 'constant'``, only the mean of `data` is subtracted. bp : array_like of ints, optional A sequence of break points. If given, an individual linear fit is performed for each part of `data` between two break points. Break points are specified as indices into `data`. Returns ------- ret : ndarray The detrended input data. Examples -------- >>> from scipy import signal >>> randgen = np.random.RandomState(9) >>> npoints = 1000 >>> noise = randgen.randn(npoints) >>> x = 3 + 2*np.linspace(0, 1, npoints) + noise >>> (signal.detrend(x) - noise).max() < 0.01 True r r� �constant�cz*Trend type must be 'linear' or 'constant'.ZdfDFr� r z>Breakpoints must be less than length of data along given axis.r r� rd g �?N)r r� r r )r r ) ri r r r� r r r} r/ r3 r* r| r� r� r- r2 r� r( r� r� r� r r r rx r �lstsqr r1 r� )�datar� �typeZbpr r� Zdshaper� ZNregZrnkZnewdims�newdatar� ZNpts�Ar� ZcoefZresidsr� �sZtdshape�valsZolddimsrl rl rm rZ F sJ % # 5" %c C s� t j | � } | j d k r* t d � � t j | � } | j d k rT t d � � x6 t | � d k r� | d d k r� | d d � } qW W| j d k r� t d � � | d d k r� | | d } | | d } t t | � t | � � } t | � | k r*t j | t j | t | � � f } n8 t | � | k rbt j | t j | t | � � f } t j | d � t j | � j } | d d � | d d � | d } t j j | | � } | S) a Compute an initial state `zi` for the lfilter function that corresponds to the steady state of the step response. A typical use of this function is to set the initial state so that the output of the filter starts at the same value as the first element of the signal to be filtered. Parameters ---------- b, a : array_like (1-D) The IIR filter coefficients. See `lfilter` for more information. Returns ------- zi : 1-D ndarray The initial state for the filter. See Also -------- lfilter, lfiltic, filtfilt Notes ----- A linear filter with order m has a state space representation (A, B, C, D), for which the output y of the filter can be expressed as:: z(n+1) = A*z(n) + B*x(n) y(n) = C*z(n) + D*x(n) where z(n) is a vector of length m, A has shape (m, m), B has shape (m, 1), C has shape (1, m) and D has shape (1, 1) (assuming x(n) is a scalar). lfilter_zi solves:: zi = A*zi + B In other words, it finds the initial condition for which the response to an input of all ones is a constant. Given the filter coefficients `a` and `b`, the state space matrices for the transposed direct form II implementation of the linear filter, which is the implementation used by scipy.signal.lfilter, are:: A = scipy.linalg.companion(a).T B = b[1:] - a[1:]*b[0] assuming `a[0]` is 1.0; if `a[0]` is not 1, `a` and `b` are first divided by a[0]. Examples -------- The following code creates a lowpass Butterworth filter. Then it applies that filter to an array whose values are all 1.0; the output is also all 1.0, as expected for a lowpass filter. If the `zi` argument of `lfilter` had not been given, the output would have shown the transient signal. >>> from numpy import array, ones >>> from scipy.signal import lfilter, lfilter_zi, butter >>> b, a = butter(5, 0.25) >>> zi = lfilter_zi(b, a) >>> y, zo = lfilter(b, a, ones(10), zi=zi) >>> y array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]) Another example: >>> x = array([0.5, 0.5, 0.5, 0.0, 0.0, 0.0, 0.0]) >>> y, zf = lfilter(b, a, x, zi=zi*x[0]) >>> y array([ 0.5 , 0.5 , 0.5 , 0.49836039, 0.48610528, 0.44399389, 0.35505241]) Note that the `zi` argument to `lfilter` was computed using `lfilter_zi` and scaled by `x[0]`. Then the output `y` has no transient until the input drops from 0.5 to 0.0. r zNumerator b must be 1-D.zDenominator a must be 1-D.r g Nz3There must be at least one nonzero `a` coefficient.g �?)r| r rz ri r� r{ r� r* r5 Zeyer Z companionr Zsolve)r� r� r� ZIminusA�Br� rl rl rm r[ � s, Y % )&#&c C s� t j | � } | j d k s1 | j d d k r= t d � � | j d } t j | d f � } d } xq t | � D]c } | | d d � f } | | d d � f } | t | | � | | <| | j � | j � 9} qr W| S) a� Compute an initial state `zi` for the sosfilt function that corresponds to the steady state of the step response. A typical use of this function is to set the initial state so that the output of the filter starts at the same value as the first element of the signal to be filtered. Parameters ---------- sos : array_like Array of second-order filter coefficients, must have shape ``(n_sections, 6)``. See `sosfilt` for the SOS filter format specification. Returns ------- zi : ndarray Initial conditions suitable for use with ``sosfilt``, shape ``(n_sections, 2)``. See Also -------- sosfilt, zpk2sos Notes ----- .. versionadded:: 0.16.0 Examples -------- Filter a rectangular pulse that begins at time 0, with and without the use of the `zi` argument of `scipy.signal.sosfilt`. >>> from scipy import signal >>> import matplotlib.pyplot as plt >>> sos = signal.butter(9, 0.125, output='sos') >>> zi = signal.sosfilt_zi(sos) >>> x = (np.arange(250) < 100).astype(int) >>> f1 = signal.sosfilt(sos, x) >>> f2, zo = signal.sosfilt(sos, x, zi=zi) >>> plt.plot(x, 'k--', label='x') >>> plt.plot(f1, 'b', alpha=0.5, linewidth=2, label='filtered') >>> plt.plot(f2, 'g', alpha=0.25, linewidth=4, label='filtered with zi') >>> plt.legend(loc='best') >>> plt.show() rd r � z!sos must be shape (n_sections, 6)r g �?Nr@ ) r| r rz r} ri r~ r� r[ r0 )�sos� n_sectionsr� �scale�sectionr� r� rl rl rm r\ s 3" c ! C s� t j | � } t j | � } t t | � t | � � d } | d k r� | d | d d } | | } | t j g � t j g � f S| d k s� | | j d k r� t j | | | j d � } | j d } | d k s� | d | k r� | } n | } t j | | f � } t j | � } d | d <t | | t j | � d | �d | d d � d f <x> t d | � D]- } | d | � d f | | d � | f <qnW| d d d � } t | | | d d d � d d �} | d d d � } | | k rt j | | | | f � } n] t j d | d | f � } | | | d | � d | � f <| | | | d � | d � f <t | | | � } t | | | d d d d � f � d d d d � f } t | | | d d d d � f � d d d d � f } t | | | � } | | } | | k r&| } nH | d d | � f } | d | d � f } t j | | f d d �} | j d k r�t j | | � d } n_ | j d | j d � j } t j | | � d j } | j | j d d � | j d f � } | | k rt j | | f � } nU t j d | d | f � } | | d | � d | � f <| | | d � | d � f <| j | j � } | } | | k r�| | 7} nV | d d | � f | d d | � f 7<| d | d � f | d | d � f 7<| d d | � f } | d | d � f } | d k sA| | j d k r�t j | | | j d � } t j | | | j d � } t j | | | j d � } | | | f S)a7 Forward-backward IIR filter that uses Gustafsson's method. Apply the IIR filter defined by `(b,a)` to `x` twice, first forward then backward, using Gustafsson's initial conditions [1]_. Let ``y_fb`` be the result of filtering first forward and then backward, and let ``y_bf`` be the result of filtering first backward then forward. Gustafsson's method is to compute initial conditions for the forward pass and the backward pass such that ``y_fb == y_bf``. Parameters ---------- b : scalar or 1-D ndarray Numerator coefficients of the filter. a : scalar or 1-D ndarray Denominator coefficients of the filter. x : ndarray Data to be filtered. axis : int, optional Axis of `x` to be filtered. Default is -1. irlen : int or None, optional The length of the nonnegligible part of the impulse response. If `irlen` is None, or if the length of the signal is less than ``2 * irlen``, then no part of the impulse response is ignored. Returns ------- y : ndarray The filtered data. x0 : ndarray Initial condition for the forward filter. x1 : ndarray Initial condition for the backward filter. Notes ----- Typically the return values `x0` and `x1` are not needed by the caller. The intended use of these return values is in unit tests. References ---------- .. [1] F. Gustaffson. Determining the initial states in forward-backward filtering. Transactions on Signal Processing, 46(4):988-992, 1996. r r rd Nr� r� .ry ry ry ry ry ry ry ry ry ry ry ry ry ry ry )r| r r� r� r rz Zswapaxesr} r5 rL r� Zhstackr� r r r- r r )!r� r� r� r� �irlenr� r r� r� r� ZObsr� r� ZObsr�SZSrr� Zy_fZy_fbZy_bZy_bfZ delta_y_bf_fbZdeltaZstart_mZend_mZic_optZdelta2dZic_opt0r� ZwicZy_opt�x0Zx1rl rl rm �_filtfilt_gustd sx 1 5+ % 88 * *, r �oddc C s� t j | � } t j | � } t j | � } | d k rE t d � � | d k r| t | | | d | d | �\ } } } | St | | | | d t t | � t | � � �\ } } t | | � } d g | j } | j | | <t j | | � } t | d d d | �} t | | | d | d | | �\ } } t | d d d | �} t | | t | d | �d | d | | �\ } } t | d | �} | d k r�t | d | d | d | �} | S)a� A forward-backward filter. This function applies a linear filter twice, once forward and once backwards. The combined filter has linear phase. The function provides options for handling the edges of the signal. When `method` is "pad", the function pads the data along the given axis in one of three ways: odd, even or constant. The odd and even extensions have the corresponding symmetry about the end point of the data. The constant extension extends the data with the values at the end points. On both the forward and backward passes, the initial condition of the filter is found by using `lfilter_zi` and scaling it by the end point of the extended data. When `method` is "gust", Gustafsson's method [1]_ is used. Initial conditions are chosen for the forward and backward passes so that the forward-backward filter gives the same result as the backward-forward filter. Parameters ---------- b : (N,) array_like The numerator coefficient vector of the filter. a : (N,) array_like The denominator coefficient vector of the filter. If ``a[0]`` is not 1, then both `a` and `b` are normalized by ``a[0]``. x : array_like The array of data to be filtered. axis : int, optional The axis of `x` to which the filter is applied. Default is -1. padtype : str or None, optional Must be 'odd', 'even', 'constant', or None. This determines the type of extension to use for the padded signal to which the filter is applied. If `padtype` is None, no padding is used. The default is 'odd'. padlen : int or None, optional The number of elements by which to extend `x` at both ends of `axis` before applying the filter. This value must be less than ``x.shape[axis] - 1``. ``padlen=0`` implies no padding. The default value is ``3 * max(len(a), len(b))``. method : str, optional Determines the method for handling the edges of the signal, either "pad" or "gust". When `method` is "pad", the signal is padded; the type of padding is determined by `padtype` and `padlen`, and `irlen` is ignored. When `method` is "gust", Gustafsson's method is used, and `padtype` and `padlen` are ignored. irlen : int or None, optional When `method` is "gust", `irlen` specifies the length of the impulse response of the filter. If `irlen` is None, no part of the impulse response is ignored. For a long signal, specifying `irlen` can significantly improve the performance of the filter. Returns ------- y : ndarray The filtered output with the same shape as `x`. See Also -------- sosfiltfilt, lfilter_zi, lfilter, lfiltic, savgol_filter, sosfilt Notes ----- The option to use Gustaffson's method was added in scipy version 0.16.0. References ---------- .. [1] F. Gustaffson, "Determining the initial states in forward-backward filtering", Transactions on Signal Processing, Vol. 46, pp. 988-992, 1996. Examples -------- The examples will use several functions from `scipy.signal`. >>> from scipy import signal >>> import matplotlib.pyplot as plt First we create a one second signal that is the sum of two pure sine waves, with frequencies 5 Hz and 250 Hz, sampled at 2000 Hz. >>> t = np.linspace(0, 1.0, 2001) >>> xlow = np.sin(2 * np.pi * 5 * t) >>> xhigh = np.sin(2 * np.pi * 250 * t) >>> x = xlow + xhigh Now create a lowpass Butterworth filter with a cutoff of 0.125 times the Nyquist rate, or 125 Hz, and apply it to ``x`` with `filtfilt`. The result should be approximately ``xlow``, with no phase shift. >>> b, a = signal.butter(8, 0.125) >>> y = signal.filtfilt(b, a, x, padlen=150) >>> np.abs(y - xlow).max() 9.1086182074789912e-06 We get a fairly clean result for this artificial example because the odd extension is exact, and with the moderately long padding, the filter's transients have dissipated by the time the actual data is reached. In general, transient effects at the edges are unavoidable. The following example demonstrates the option ``method="gust"``. First, create a filter. >>> b, a = signal.ellip(4, 0.01, 120, 0.125) # Filter to be applied. >>> np.random.seed(123456) `sig` is a random input signal to be filtered. >>> n = 60 >>> sig = np.random.randn(n)**3 + 3*np.random.randn(n).cumsum() Apply `filtfilt` to `sig`, once using the Gustafsson method, and once using padding, and plot the results for comparison. >>> fgust = signal.filtfilt(b, a, sig, method="gust") >>> fpad = signal.filtfilt(b, a, sig, padlen=50) >>> plt.plot(sig, 'k-', label='input') >>> plt.plot(fgust, 'b-', linewidth=4, label='gust') >>> plt.plot(fpad, 'c-', linewidth=1.5, label='pad') >>> plt.legend(loc='best') >>> plt.show() The `irlen` argument can be used to improve the performance of Gustafsson's method. Estimate the impulse response length of the filter. >>> z, p, k = signal.tf2zpk(b, a) >>> eps = 1e-9 >>> r = np.max(np.abs(p)) >>> approx_impulse_len = int(np.ceil(np.log(eps) / np.log(r))) >>> approx_impulse_len 137 Apply the filter to a longer signal, with and without the `irlen` argument. The difference between `y1` and `y2` is small. For long signals, using `irlen` gives a significant performance improvement. >>> x = np.random.randn(5000) >>> y1 = signal.filtfilt(b, a, x, method='gust') >>> y2 = signal.filtfilt(b, a, x, method='gust', irlen=approx_impulse_len) >>> print(np.max(np.abs(y1 - y2))) 1.80056858312e-10 re �gustz method must be 'pad' or 'gust'.r� r �ntapsr �stopr� �startr )re r ry )r| r r ri r � _validate_padr� r� r[ rz r{ r- r9 rL r: )r� r� r� r� �padtype�padlen�methodr r� Zz1Zz2�edge�extr� �zi_shaper r� Zy0rl rl rm r^ s, � '$ (4 c C s� | d k r t d | � � | d k r. d } | d k rG | d } n | } | j | | k rp t d | � � | d k r� | d k r� | d k r� t | | d | �} q� | d k r� t | | d | �} q� t | | d | �} n | } | | f S) z'Helper to validate padding for filtfilt�evenr r NzYUnknown value '%s' given to padtype. padtype must be 'even', 'odd', 'constant', or None.r r@ zFThe length of the input vector x must be at least padlen, which is %d.r� )r% r r N)ri r} r< r; r= )r r r� r� r r" r# rl rl rm r � s& r c C sh t j | � } t | � \ } } | d k } | r� t j | � } t | j � } d | | <t | g | � } | j | k r� t d | | j | | | j f � � t | � } x� t | � D]� } | rt | | d d � f | | d d � f | | d | | �\ } | | <q� t | | d d � f | | d d � f | | � } q� W| r^| | f n | } | S)aO Filter data along one dimension using cascaded second-order sections Filter a data sequence, `x`, using a digital IIR filter defined by `sos`. This is implemented by performing `lfilter` for each second-order section. See `lfilter` for details. Parameters ---------- sos : array_like Array of second-order filter coefficients, must have shape ``(n_sections, 6)``. Each row corresponds to a second-order section, with the first three columns providing the numerator coefficients and the last three providing the denominator coefficients. x : array_like An N-dimensional input array. axis : int, optional The axis of the input data array along which to apply the linear filter. The filter is applied to each subarray along this axis. Default is -1. zi : array_like, optional Initial conditions for the cascaded filter delays. It is a (at least 2D) vector of shape ``(n_sections, ..., 2, ...)``, where ``..., 2, ...`` denotes the shape of `x`, but with ``x.shape[axis]`` replaced by 2. If `zi` is None or is not given then initial rest (i.e. all zeros) is assumed. Note that these initial conditions are *not* the same as the initial conditions given by `lfiltic` or `lfilter_zi`. Returns ------- y : ndarray The output of the digital filter. zf : ndarray, optional If `zi` is None, this is not returned, otherwise, `zf` holds the final filter delay values. See Also -------- zpk2sos, sos2zpk, sosfilt_zi, sosfiltfilt Notes ----- The filter function is implemented as a series of second-order filters with direct-form II transposed structure. It is designed to minimize numerical precision errors for high-order filters. .. versionadded:: 0.16.0 Examples -------- Plot a 13th-order filter's impulse response using both `lfilter` and `sosfilt`, showing the instability that results from trying to do a 13th-order filter in a single stage (the numerical error pushes some poles outside of the unit circle): >>> import matplotlib.pyplot as plt >>> from scipy import signal >>> b, a = signal.ellip(13, 0.009, 80, 0.05, output='ba') >>> sos = signal.ellip(13, 0.009, 80, 0.05, output='sos') >>> x = np.zeros(700) >>> x[0] = 1. >>> y_tf = signal.lfilter(b, a, x) >>> y_sos = signal.sosfilt(sos, x) >>> plt.plot(y_tf, 'r', label='TF') >>> plt.plot(y_sos, 'k', label='SOS') >>> plt.legend(loc='best') >>> plt.show() Nrd zyInvalid zi shape. With axis=%r, an input with shape %r, and an sos array with %d sections, zi must have shape %r, got %r.r@ r� ) r| r � _validate_sosr� r} r� ri r6 r� rL ) r r� r� r� r Zuse_ziZ x_zi_shaper� r r� rl rl rm rN � s& H )#9c C s� t | � \ } } d | d } | t | d d � d f d k j � | d d � d f d k j � � 8} t | | | | d | �\ } } t | � } d g | j } d | | <| g | | _ t | d d d | �} t | | d | d | | �\ } } t | d d d | �} t | t | d | �d | d | | �\ } } t | d | �} | d k r�t | d | d | d | �} | S) a% A forward-backward filter using cascaded second-order sections. See `filtfilt` for more complete information about this method. Parameters ---------- sos : array_like Array of second-order filter coefficients, must have shape ``(n_sections, 6)``. Each row corresponds to a second-order section, with the first three columns providing the numerator coefficients and the last three providing the denominator coefficients. x : array_like The array of data to be filtered. axis : int, optional The axis of `x` to which the filter is applied. Default is -1. padtype : str or None, optional Must be 'odd', 'even', 'constant', or None. This determines the type of extension to use for the padded signal to which the filter is applied. If `padtype` is None, no padding is used. The default is 'odd'. padlen : int or None, optional The number of elements by which to extend `x` at both ends of `axis` before applying the filter. This value must be less than ``x.shape[axis] - 1``. ``padlen=0`` implies no padding. The default value is:: 3 * (2 * len(sos) + 1 - min((sos[:, 2] == 0).sum(), (sos[:, 5] == 0).sum())) The extra subtraction at the end attempts to compensate for poles and zeros at the origin (e.g. for odd-order filters) to yield equivalent estimates of `padlen` to those of `filtfilt` for second-order section filters built with `scipy.signal` functions. Returns ------- y : ndarray The filtered output with the same shape as `x`. See Also -------- filtfilt, sosfilt, sosfilt_zi Notes ----- .. versionadded:: 0.18.0 rd r Nr rA r r r� r� r ry ) r& r� r0 r r\ rz r} r9 rN r: )r r� r� r r r r r" r# r� r$ Zx_0r� r� Zy_0rl rl rm r] _ s" 3K %1 c C s� t | � } | j d k r' t d � � | j \ } } | d k rN t d � � | d d � d f d k j � s| t d � � | | f S) z Helper to validate a SOS inputrd zsos array must be 2Dr z'sos array must be shape (n_sections, 6)Nr@ r z sos[:, 3] should be all ones)r rz ri r} �all)r r r� rl rl rm r& � s " r& �iirc C sS t | t � s t d � � | d k rC t | t � rC t d � � | d k r� | d k ra d } t t | d d | d d �d � } n� | d k r� | d k r� d } t t | d d | � � } nO t | t � r | j � } t j | j j | j j f � d } n t d � � | d k r8t j d t � d } t d � g | j } t | j � d k r�| r�t | d | d | d | j �} qK| j | | t | j | | � } t | j | d d d | d | �} t d | d � | | <n[ | rt | j | j | d | �} n t | j | j | d | �} t d d | � | | <| | S)a/ Downsample the signal after applying an anti-aliasing filter. By default, an order 8 Chebyshev type I filter is used. A 30 point FIR filter with Hamming window is used if `ftype` is 'fir'. Parameters ---------- x : ndarray The signal to be downsampled, as an N-dimensional array. q : int The downsampling factor. For downsampling factors higher than 13, it is recommended to call `decimate` multiple times. n : int, optional The order of the filter (1 less than the length for 'fir'). Defaults to 8 for 'iir' and 30 for 'fir'. ftype : str {'iir', 'fir'} or ``dlti`` instance, optional If 'iir' or 'fir', specifies the type of lowpass filter. If an instance of an `dlti` object, uses that object to filter before downsampling. axis : int, optional The axis along which to decimate. zero_phase : bool, optional Prevent phase shift by filtering with `filtfilt` instead of `lfilter` when using an IIR filter, and shifting the outputs back by the filter's group delay when using an FIR filter. A value of ``True`` is recommended, since a phase shift is generally not desired. Using ``None`` defaults to ``False`` for backwards compatibility. This default will change to ``True`` in a future release, so it is best to set this argument explicitly. .. versionadded:: 0.18.0 Returns ------- y : ndarray The down-sampled signal. See Also -------- resample : Resample up or down using the FFT method. resample_poly : Resample using polyphase filtering and an FIR filter. Notes ----- The ``zero_phase`` keyword was added in 0.18.0. The possibility to use instances of ``dlti`` as ``ftype`` was added in 0.18.0. zq must be an integerNzn must be an integerZfir� r g �?r� Zhammingr( � g�������?g�������?z invalid ftypez� Note: Decimate's zero_phase keyword argument will default to True in a future release. Until then, decimate defaults to one-way filtering for backwards compatibility. Ideally, always set this argument explicitly.Fr� r r )r� r� � TypeErrorr r? r> Z_as_tfr| r� r� r{ r� ri r� �warn� FutureWarningrx rz r� rY r} r� r r^ rL ) r� �qr� Zftyper� Z zero_phase�systemr� r� r rl rl rm r_ � s@ 2 ) ( $&$! ry ry )r� r� ry ry ry ry ry ry )Z __future__r r r r� � threading�sys� r r Z_upfirdnr r r Zscipy._lib.sixr Zscipy._lib._versionr Zscipyr r Znumpyr r r r r r r r r r r r r r r r r r r! r" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r| Z scipy.specialr7 Zwindowsr8 Z _arraytoolsr9 r: r; r< r= Z filter_designr> Zfir_filter_designr? � version_info�major�minor�mathrB Z fractions�__all__rg ro � __version__r� �Lockr� rn rq rs rC r� rD rE rH rI rK rF rG rJ rL rM rO rP rQ rR rS rT rV rW rU rX rY r` rZ r[ r\ r r^ r rN r] r& r_ rl rl rl rm �<module> s� � ($ � �V >*3`e'�D 8m< LWU]Vv� NR � F� � #aJ
Edit
Rename
Chmod
Delete
FILE
FOLDER
Name
Size
Permission
Action
__init__.cpython-35.opt-1.pyc
12413 bytes
0644
__init__.cpython-35.pyc
12413 bytes
0644
_arraytools.cpython-35.opt-1.pyc
5169 bytes
0644
_arraytools.cpython-35.pyc
5169 bytes
0644
_max_len_seq.cpython-35.opt-1.pyc
4571 bytes
0644
_max_len_seq.cpython-35.pyc
4571 bytes
0644
_peak_finding.cpython-35.opt-1.pyc
16682 bytes
0644
_peak_finding.cpython-35.pyc
16682 bytes
0644
_savitzky_golay.cpython-35.opt-1.pyc
10925 bytes
0644
_savitzky_golay.cpython-35.pyc
10925 bytes
0644
_upfirdn.cpython-35.opt-1.pyc
5062 bytes
0644
_upfirdn.cpython-35.pyc
5062 bytes
0644
bsplines.cpython-35.opt-1.pyc
12779 bytes
0644
bsplines.cpython-35.pyc
12779 bytes
0644
filter_design.cpython-35.opt-1.pyc
107048 bytes
0644
filter_design.cpython-35.pyc
107328 bytes
0644
fir_filter_design.cpython-35.opt-1.pyc
24042 bytes
0644
fir_filter_design.cpython-35.pyc
24042 bytes
0644
lti_conversion.cpython-35.opt-1.pyc
13089 bytes
0644
lti_conversion.cpython-35.pyc
13089 bytes
0644
ltisys.cpython-35.opt-1.pyc
106889 bytes
0644
ltisys.cpython-35.pyc
107162 bytes
0644
setup.cpython-35.opt-1.pyc
1246 bytes
0644
setup.cpython-35.pyc
1246 bytes
0644
signaltools.cpython-35.opt-1.pyc
93816 bytes
0644
signaltools.cpython-35.pyc
93816 bytes
0644
spectral.cpython-35.opt-1.pyc
31743 bytes
0644
spectral.cpython-35.pyc
31743 bytes
0644
waveforms.cpython-35.opt-1.pyc
13560 bytes
0644
waveforms.cpython-35.pyc
13560 bytes
0644
wavelets.cpython-35.opt-1.pyc
10619 bytes
0644
wavelets.cpython-35.pyc
10619 bytes
0644
windows.cpython-35.opt-1.pyc
54254 bytes
0644
windows.cpython-35.pyc
54254 bytes
0644
N4ST4R_ID | Naxtarrr
