˽Xc @`sddlmZmZmZddlZddlZddlZddlZddlm Z m Z ddl m Z m Z ddlmZddlmZddlmZmZdd lmZmZmZmZmZmZmZmZmZmZm 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/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;ddlZ<ddl=Z=dd l>m?Z?dd l@mAZAdd lBmCZCmDZDmEZEmFZFmGZGdd lHmIZImJZJddlKmLZLejMjNdkrYejMjOdkrYddl=mPZPnddlQmPZPddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0gZRidd16dd26d3d46ZSidd56dd66d3d76d3d86dd96dd:6d;d<6ZTee<jUd=kZVejWZXd>ZYd?ZZd@Z[d4dAdBZ\dCZ]d4dDZ^dEdFZ_dGZ`dHZadIZbdJZcdKZddLdLddMZed4efdNZgd4dAdOZhdPZiddQZkdddRZld4d5ddSZmd4d5ddTZnddUZodVddWZpddXZqdYZrddVdZZsdd[Ztd\Zud]d^d_Zvd]d`daZwd]d`dbZxd]d`dcZyd]d`ddZzddddeZ{ddvdhZ|diZ}dVdjddkZ~dlZdmZdVddnZdVdodd6ddpZdqZdVddrZdVdoddsZddtdVdduZdS(wi(tdivisiontprint_functiontabsolute_importNi(tsigtoolstdlti(tupfirdnt _output_len(tcallable(t NumpyVersion(tfftpacktlinalg(&tallclosetangletarangetargsorttarraytasarrayt atleast_1dt atleast_2dtcasttdottexpt expand_dimst iscomplexobjtmeantndarraytnewaxistonestpitpolytpolyaddtpolydertpolydivtpolymultpolysubtpolyvaltproducttr_travelt real_if_closetreshapetrootstsortttaket transposetuniquetwheretzerost zeros_like(t factorial(t get_window(t axis_slicet axis_reversetodd_extteven_extt const_ext(tcheby1t _validate_sos(tfirwinii(tgcdt correlatet fftconvolvetconvolvet convolve2dt correlate2dt order_filtertmedfiltt medfilt2dtwienertlfiltertlfiltictsosfiltt deconvolvethilbertthilbert2t cmplx_sortt unique_rootstinvrestinvresztresiduetresidueztresamplet resample_polytdetrendt lfilter_zit sosfilt_zit sosfiltfilttchoose_conv_methodtfiltfilttdecimatetvectorstrengthtvalidtsameitfulltfilltpadtwraptcirculartsymmt symmetricitreflects1.9.0.dev-e24486ecC`sGyt|}Wn2tk rB|dkr9tdn|}nX|S(NiiisAAcceptable mode flags are 'valid' (0), 'same' (1), or 'full' (2).(iii(t _modedicttKeyErrort ValueError(tmodetval((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyt _valfrommode9s   cC`sOyt|d>}Wn6tk rJ|dkr=tdn|d>}nX|S(Niiis]Acceptable boundary flags are 'fill', 'wrap' (or 'circular'), and 'symm' (or 'symmetric').(iii(t _boundarydictRfRg(tboundaryRi((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyt_bvalfromboundaryDs  cC`s|dkrtt}}xGt||D]6\}}||ksJt}n||ks)t}q)q)W|pl|s~tdn| StS(s If in 'valid' mode, returns whether or not the input arrays need to be swapped depending on whether `shape1` is at least as large as `shape2` in every dimension. 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. R[sOFor 'valid' mode, one must be at least as large as the other in every dimension(tTruetziptFalseRg(Rhtshape1tshape2tok1tok2td1td2((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyt_inputs_swap_neededPs       tautoc C`st|}t|}|j|jko5dknrB||S|j|jkrctdnyt|}Wntk rtdnX|d krt|t|||St|||rtj |||S|dkr|j |j kpt ||j |j }|r'||}}n|dkrgt |j |j D]\}}||d^qI}tj||j} tj||| |} ngt |j |j D]\}}||d^q}tj||j} g|j D]}td|^q} |j| | <|dkr=tj||j} n'|d krdtj|j |j} ntj| || |} |rt| } n| S( s 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`. 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. In 'valid' mode, either `in1` or `in2` must be at least as large as the other in every dimension. ``same`` The output is the same size as `in1`, centered with respect to the 'full' output. method : str {'auto', 'direct', 'fft'}, optional A string indicating which method to use to calculate the correlation. ``direct`` The correlation is determined directly from sums, the definition of correlation. ``fft`` The Fast Fourier Transform is used to perform the correlation more quickly (only available for numerical arrays.) ``auto`` Automatically chooses direct or Fourier method based on an estimate of which is faster (default). See `convolve` Notes for more detail. .. versionadded:: 0.19.0 Returns ------- correlate : array An N-dimensional array containing a subset of the discrete linear cross-correlation of `in1` with `in2`. See Also -------- choose_conv_method : contains more documentation on `method`. 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,...]) This way, if x and y are 1-D arrays and ``z = correlate(x, y, 'full')`` then .. math:: z[k] = (x * y)(k - N + 1) = \sum_{l=0}^{||x||-1}x_l y_{l-k+N-1}^{*} for :math:`k = 0, 1, ..., ||x|| + ||y|| - 2` where :math:`||x||` is the length of ``x``, :math:`N = \max(||x||,||y||)`, and :math:`y_m` is 0 when m is outside the range of y. ``method='fft'`` only works for numerical arrays as it relies on `fftconvolve`. In certain cases (i.e., arrays of objects or when rounding integers can lose precision), ``method='direct'`` is always used. 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() is/in1 and in2 should have the same dimensionalitys5Acceptable mode flags are 'valid', 'same', or 'full'.tfftRxR]R[iR\(sfftRx(RtndimRgReRfR>t_reverse_and_conjt _np_conv_oktnpR<tsizeRwtshapeRotemptytdtypeRt _correlateNDR/tslicetcopy( tin1tin2RhtmethodRitswapped_inputstitjtpstouttzt in1zpaddedtsc((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyR<osDd  "   66%  cC`swt|}t|j}||d}||}gtt|D]}t||||^qF}|t|S(Ni(RRRtrangetlenRttuple(tarrtnewshapet currshapetstartindtendindtktmyslice((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyt _centereds   6c C`st|}t|}|j|jko5dknrB||S|j|jksctdn(|jdks|jdkrtgSt|j}t|j}tj|jt ptj|jt }||d}t |||r||||f\}}}}ng|D]}t j j t|^q}tg|D]} tdt| ^qI} | rtstjtrzQtjj||} tjj||} tjj| | || j} WdtstjnXnSt j||} t j||} t j| | | j} |sG| j} n|dkrW| S|dkrpt| |S|dkrt| ||dStddS( s 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). As of v0.19, `convolve` automatically chooses this method or the direct method based on an estimation of which is faster. 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. >>> 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() is/in1 and in2 should have the same dimensionalityiNR]R\R[s5Acceptable mode flags are 'valid', 'same', or 'full'.(RRzRgR~RRR}t issubdtypeRtcomplexRwR thelpert next_fast_lentintRRt _rfft_mt_safet _rfft_locktacquireRpRytrfftntirfftnRtreleasetfftntifftntrealR(RRRhts1ts2tcomplex_resultRtdtfshapetsztfslicetsp1tsp2tret((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyR=sHQ  " !+.'     tbuifccC`sMt|tkr"|jj|kSx$|D]}|jj|kr)tSq)WtS(sl See if a list of arrays are all numeric. Parameters ---------- ndarrays : array or list of arrays arrays to check if numeric. numeric_kinds : string-like The dtypes of the arrays to be checked. If the dtype.kind of the ndarrays are not in this string the function returns False and otherwise returns True. (ttypeRRtkindRpRn(tarraystkindstarray_((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyt_numeric_arrayss  cC`s%d}x|D]}||9}q W|S(sb Product of a list of numbers. Faster than np.prod for short lists like array shapes. i((titerableR$tx((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyt_prods c C`so|dkr`gt|j|jD]\}}||d^q"}|jdkrWdnd}n|dkr|j}|jdkr|j|jkrd}qd}qd}nl|d krgt|j|jD]\}}||d^q}|jdkrd nd }n td |j|jt|}td |j|jt|D}|||kS(s See if using `fftconvolve` or `_correlateND` is faster. The boolean value returned depends on the sizes and shapes of the input values. The big O ratios were found to hold across different machines, which makes sense as it's the ratio that matters (the effective speed of the computer is found in both big O constants). Regardless, this had been tuned on an early 2015 MacBook Pro with 8GB RAM and an Intel i5 processor. R]igyNi@g|s$a@R\gbξi@g{AƊ@g@R[gsGH|@g~JS9@smode is invalidcs`s"|]}|tj|VqdS(N(tmathtlog(t.0tn((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pys s(RoRRzR~RgRtsumR( RthRhRRt out_shapetbig_O_constantt direct_timetfft_time((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyt_fftconv_fasters$ 6      6 cC`s*tdddg|j}||jS(sO Reverse array `x` in all dimensions and perform the complex conjugate iN(RtNoneRztconj(Rtreverse((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyR{scC`sD|j|jkodkn}|oC|j|jkpC|dkS(s See if numpy supports convolution of `volume` and `kernel` (i.e. both are 1D ndarrays and of the appropriate shape). Numpy's 'same' mode uses the size of the larger input, while Scipy's uses the size of the first input. iR\(RzR~(tvolumetkernelRht np_conv_ok((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyR|s"cC`sxHddgD]:}tt|r |j|ks@|j|krGtSq q Wtg||gD]}t|gdd^q[rttj|jttj|j}|tt |j |j 9}|dtj dj dkrtSnt||grtSt S(Nt complex256t complex192Rtuiitfloati(thasattrR}RRptanyRRtabstmaxtminR~tfinfotnmantRn(RRtnot_fft_conv_suppRt max_value((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyt_fftconvolve_valids 44 tpassc C`stj||}d}x@tddD]/}d|}|j|}|dkr(Pq(q(W|dkrp|}n(|d9}|j||}t|}||} | S(s Returns the time the statement/function took, in seconds. Faster, less precise version of IPython's timeit. `stmt` can be a statement written as a string or a callable. Will do only 1 loop (like IPython's timeit) with no repetitions (unlike IPython) for very slow functions. For fast functions, only does enough loops to take 5 ms, which seems to produce similar results (on Windows at least), and avoids doing an extraneous cycle that isn't measured. ii g{Gzt?igMb@?(ttimeittTimerRtrepeatR( tstmttsetupRttimerRtptnumbertbesttrtsec((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyt _timeit_fasts       c `st|t||ri}x6ddgD](tfd|>> from scipy import signal >>> a = np.random.randn(1000) >>> b = np.random.randn(1000000) >>> method = signal.choose_conv_method(a, b, mode='same') >>> method 'fft' This can then be applied to other arrays of the same dtype and shape: >>> c = np.random.randn(1000) >>> d = np.random.randn(1000000) >>> # `method` works with correlate and convolve >>> corr1 = signal.correlate(a, b, mode='same', method=method) >>> corr2 = signal.correlate(c, d, mode='same', method=method) >>> conv1 = signal.convolve(a, b, mode='same', method=method) >>> conv2 = signal.convolve(c, d, mode='same', method=method) Rytdirectc`stddS(NRhR(R>((RRRhR(s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyts ii RRRRRiI(RRtsystmaxsizeRR}RRRRRRRR~RRR( RRRhtmeasurettimest chosen_methodt fftconv_unsupRR((RRRhRs7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRW2s*Y  &  44 cC`s!t|}t|}|j|jko5dknrB||St||j|jrj||}}n|dkrt||d|}n|dkrt||d|}|jjdkrtj |}n|j |jSt |||rtj |||St |t||dS(s 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`. 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. In 'valid' mode, either `in1` or `in2` must be at least as large as the other in every dimension. ``same`` The output is the same size as `in1`, centered with respect to the 'full' output. method : str {'auto', 'direct', 'fft'}, optional A string indicating which method to use to calculate the convolution. ``direct`` The convolution is determined directly from sums, the definition of convolution. ``fft`` The Fourier Transform is used to perform the convolution by calling `fftconvolve`. ``auto`` Automatically chooses direct or Fourier method based on an estimate of which is faster (default). See Notes for more detail. .. versionadded:: 0.19.0 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) choose_conv_method : chooses the fastest appropriate convolution method fftconvolve Notes ----- By default, `convolve` and `correlate` use ``method='auto'``, which calls `choose_conv_method` to choose the fastest method using pre-computed values (`choose_conv_method` can also measure real-world timing with a keyword argument). Because `fftconvolve` relies on floating point numbers, there are certain constraints that may force `method=direct` (more detail in `choose_conv_method` docstring). 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() iRxRhRyRR(RRzRwRRWR=RRR}taroundtastypeR|R>R<R{(RRRhRRRR((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyR>s W  "  cC`sht|}|j}x=tt|D])}||ddkr(tdq(q(Wtj|||S(s 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.]]) iisIEach dimension of domain argument should have an odd number of elements.(RRRRRgRt_order_filterND(tatdomaintrankR~R((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRAs 5  cC`st|}|dkr+dg|j}nt|}|jdkrdtj|j|j}nx:t|jD])}||ddkrtt dqtqtWt |}t |dd}|d}t j |||S( s 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. iiis*Each element of kernel_size should be odd.taxisiN((RRRzRRR}RtitemRRgRR$RR(Rt kernel_sizeRRtnumelstorder((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRB\s     cC`s)t|}|dkr+dg|j}nt|}|jdkrdtj|j|j}nt|t|dt |dd}t|dt|dt |dd|d}|dkrt t |dd}n||}|d||9}||7}t ||k||}|S( s 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`. iR\RiiiN(( RRRzRR}RRR<RR$RR&R.(timtmysizetnoisetlMeantlVartresR((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRDs    (   c C`st|}t|}|j|jko5dknsItdnt||j|jrq||}}nt|}t|}tj6tj dt j t j ||d|||}WdQX|S(sN 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() is(convolve2d inputs must both be 2D arraystignoreiN(RRzRgRwRRjRmtwarningstcatch_warningst simplefilterR}tComplexWarningRt _convolve2d(RRRhRlt fillvalueRitbvalR((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyR?sL  "   $c C`st|}t|}|j|jko5dknsItdnt||j|j}|rw||}}nt|}t|}tj6tj dt j t j ||d|||}WdQX|r|ddddddf}n|S(s 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() is)correlate2d inputs must both be 2D arraysRiNi(RRzRgRwRRjRmRRRR}RRR( RRRhRlRRRiR R((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyR@sM  "   $%cC`st|}|dkr(dgd}nt|}|jdkr^tj|jd}nx-|D]%}|ddkretdqeqeWtj||S(s 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. iiis*Each element of kernel_size should be odd.N(( RRRR}RRRgRt _medfilt2d(tinputRtimageR~((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRC~s    ic `stj|}t|dkrtjtj|}jdkrl|jdkrltdntj|}||g}|d k r,tj|}|j|jkrtdnt|j}jdd||>> 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() is+object of too small depth for desired arrayis/Unexpected shape for zi: expected %s, found %s.tfdgFDGOsinput type '%s' not supportedRRc`stj|S(N(R}R>(ty(tb(s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRLsN(R}RRRRzRgRtlistRRRtstridestlibt stride_trickst as_stridedtappendt result_typetchartNotImplementedErrorRRptapply_along_axisRRt_linear_filter(RRRRtzitinputstexpected_shapeRRRtout_fulltindRtzf((Rs7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyREsjv   ##   %  (   c C`stj|d}tj|d}t||}t|}|jjdkrh|jtj}nt||j}|dkrt||j}nDt|}tj|}||krt |t||f}ntj|}||krt |t||f}nxAt |D]3} tj || d|||  dd|| >> 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) iiRhR](RRRRRER>( tsignaltdivisortnumtdenR#tDtquottremR ((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRHs)       cC`s4t|}t|r'tdn|dkrC|j|}n|dkr^tdntj||d|}t|}|ddkrd|d<||d>> 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 sx must be real.isN must be positive.RiiN( RRRgRRR RyR/RzRRtifft(RR#RtXfRR((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRIs(Z       c B`sCe|}|jdkr*edne|rEedn|d kr]|j}nxe|er|dkredn||f}n?e|dkse j e j |dkredne j ||dd }e|dd }e|dd }xedD]}ed |d}||}|ddkr~d|d<||d>> 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]) RtmaximumRtminimumtavgRsJ`rtype` must be one of {'max', 'maximum', 'min', 'minimum', 'avg', 'mean'}g?iiii(smaxsmaximum(sminsminimum(savgsmean( R}RRRRgRRRKRRRR( RttoltrtypetcomprootR;tpouttmulttcurpt samerootsRttr((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRLs8+               R>cC`s|}t|\}}t||d}t|d|d|\}}g}x6tt|D]"}|j||g||qaWtt|} t|dkrt|| } n dg} d}xtt|D]}g} xEtt|D]1} | |kr| j|| g|| qqWxpt||D]^} | }|j||g||| dt | ||tt|} |d7}qDWqWt | } x:t | ddddr| j ddkr| d} qW| | fS(s$ 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 iR?R@itrtolg+=i( RKR+RLRRtextendRRR!RR'R R(RRRR?R@textraR;RBRCRRttemptlR'tt2((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRMs4:   #$# /cC`s%tt||f\}}|d}t||\}}t|}|d}t|d|d|\}} g}x6tt|D]"} |j|| g| | qWt|}d} xRtt|D]>} |j} g} xEtt|D]1}|| kr| j||g| |qqWt t | }| | }xt|ddD]}||krt t | d|}t | t |d}t ||} t ||}nt| || t||| t|||| |d>> 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() Rs(window must have the same length as dataiR,iitFN(RYR,(RR RyRRRtfftfreqR2RRgt ifftshiftR2RzRRRRR}R=R/R/RRRRR (RR*ttRtwindowtXtNxtWRtslR#tYRtnew_t((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRQPs@Q        )  5tkaiserg@c C`sJt|}t|}t|}|dks<|dkrKtdnt||}||}||}||kodknr|jS|j||}||t||}t|tt j frt|}|j dkrtdn|j dd}|}n@t ||} d| } d| }td|d| d|}||9}|||} d} || |} xBtt|| | |j||||| kr| d7} qWt jt j| |t j| f}| |}t||||d |}td g|j }t| |||<||S( s 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() isup and down must be >= 1swindow must be 1-Dig?i R]iRN(RRRgR;RRtboolR2RR}RRzR~RR:RRt concatenateR/RRR(RtuptdownRR]tg_tn_outthalf_lenRtmax_ratetf_ct n_pre_padt n_post_padt n_pre_removetn_pre_remove_endRtkeep((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRRsFS           !* cC`st|}t|}|jdkr6tdn|jdkrTtdn|j }t|}t|}|dkjrtdnttdt|j|}t |dd}t |}t |}|r|d}|d}n||fS(s 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`. is)events cannot have dimensions more than 1s)period cannot have dimensions more than 1isperiods must be positivey@R( RRzRgRRRRRtTRRR (teventstperiodt scalarperiodtvectorst vectormeantstrengthtphase((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRZK s&/          tlinearcC`s|dkrtdnt|}|jj}|dkrHd}n|dkrt|tt|||}|S|j}||}ttt d||f}t j ||krtd nt |d }t |} |dkr|| }nt |d||d | f} t t|t| |t||f} | j} | jjdkr| j|} nxt|D]} || d || } t| d f|}t|td | d d | |d d df>> 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{RKtconstanttcs*Trend type must be 'linear' or 'constant'.tdfDFRis>Breakpoints must be less than length of data along given axis.iig?N(R{RKR|R}(R|R}(RgRRRRRRR*R-R%R}RRR(R,RRRRRRRR RR tlstsqRR+R(tdataRRtbpRRtdshapeR#tNregtrnktnewdimstnewdataR'tNptstARatcoeftresidsRtsttdshapetvalstolddims((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRS sJ%           # 5"cC`stj|}|jdkr-tdntj|}|jdkrZtdnx0t|dkr|ddkr|d}q]W|jdkrtdn|ddkr||d}||d}ntt|t|}t||kr0tj|tj|t|f}n;t||krktj|tj|t|f}ntj |dt j |j }|d|d|d}tj j ||}|S(s 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. isNumerator b must be 1-D.sDenominator a must be 1-D.igs3There must be at least one nonzero `a` coefficient.g?(R}RRzRgRR~RR%R/teyeR t companionRstsolve(RRRtIminusAtBR((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRT s,Y%))#cC`stj|}|jdks1|jddkr@tdn|jd}tj|df}d}xqt|D]c}||ddf}||ddf}|t||||<||j|j9}quW|S( s 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() iiis!sos must be shape (n_sections, 6)ig?Ni( R}RRzRRgRRRTR(tsost n_sectionsRtscaletsectionRR((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRUq s3" c! C`stj|}tj|}tt|t|d}|dkr|d|dd}||}|tjgtjgfS|dks||jdkrtj|||jd}n|jd}|dks|d|kr|} n|} tj | |f} tj |} d| dt d|D]-} | d| df| | d| f>> 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 R_tgustsmethod must be 'pad' or 'gust'.RRtntapsitstopRtstartii(spadR(R}RRRgRt _validate_padRRRTRzR~R(R3RER4(RRRRtpadtypetpadlenRRRtz1tz2tedgetextRtzi_shapeRR ty0((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRXj s,  '$ (4 "cC`s|d krtd|n|d kr4d}n|d krM|d}n|}|j||krytd|n|d k r|dkr|dkrt||d|}q|dkrt||d|}qt||d|}n|}||fS( s'Helper to validate padding for filtfilttevenRR|sYUnknown value '%s' given to padtype. padtype must be 'even', 'odd', 'constant', or None.iisFThe length of the input vector x must be at least padlen, which is %d.RN(RRsconstantN(RRgRR6R5R7(RRRRRRR((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyR. s&         c C`sntj|}t|\}}|dk }|rtj|}t|j}d||>> 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 = signal.unit_impulse(700) >>> 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() isyInvalid zi shape. With axis=%r, an input with shape %r, and an sos array with %d sections, zi must have shape %r, got %r.NiR( R}RR9RRRRRgR0RRE( RRRRRtuse_zit x_zi_shapeR RR((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRGQ s&G  ")#9cC`st|\}}d|d}|t|dddfdkj|dddfdkj8}t||||d|\}}t|} dg|j} d| |<|g| | _t|ddd|} t||d|d | | \} } t| d d d|}t|t | d|d|d | |\} } t | d|} |dkrt| d |d| d|} n| S( s/ 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, sosfreqz Notes ----- .. versionadded:: 0.18.0 iiNiiRRRRRi( R9RRRRURzRR3RGR4(RRRRRRRRRRRtx_0RR ty_0((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyRV s"3K  %1 "tiirc C`sbt|tstdn|dk rIt|t rItdn|dkr|dkrjd}ntt|dd|ddd}n|d kr|dkrd }ntt|d d |}nOt|tr|j}tj |j j |j j fd}n t d |dkrGtjdtt}ntdg|j}t|j dkr|rt|d|d|d|j }qZ|j||t|j||} t|j |ddd|d|}td| d||RARRBRDR?R@RCRERFRHRIRJRKRLRMRORPRNRQRRRZRSRTRURRXRRGRVRY(((s7/tmp/pip-build-7oUkmx/scipy/scipy/signal/signaltools.pyts      ($  &    $  #{q > *3`e ' D 8s < LWU]Vw NR F  #`J