(phB^SSKJr SSKrSSKrSSKJr SSKrSSKrSSKJ r SSK J r SSK J r SSKJr SS KJr SS KJrJrJr SS KJrJr SS KJr SS KJr SSKrSSKJ r SSK!J"r" SSK#J$r$J%r%J&r&J'r'J(r( SSK)J*r*J+r+J,r, SSK-J.r. SSK/J/r/ /SQr0SSSS.r1SSSSSSSS.r2Sr3Sr4STSjr5Sr6SUSjr7SVSjr8Sr9SWS!jr:SWS"jr;S#rSXS&jr?SYS'jr@S(rAS)rBS*rCS+rDSZS,jrES[S-jrFSUS.jrGS/rHSTS0jrIS\S1jrJS]S2jrKS]S3jrLS^S4jrMS_S6jrNSTS7jrOS8rPS`S9jrQSTS:jrRSaSS S;S5S<.SbS=jjjrSS>rTScS?jrUSdS@jrVSWSAjrWSBrXSdSCjrYSdSDjrZSEr[SdSFjr\SeSGjr]SfSHjr^SIr_SgShSJjjr`SKraSLrbS_SMjrcSiSNjrdSOreSPrfS_SQjrgSjSRjrhSkSSjrig)l) annotationsN)prod)Literal) ArrayLike)cKDTree) _sigtools)dlti)upfirdn _output_len_upfirdn_modes)linalgfft)ndimage)_init_nd_shape_and_axes)lambertw) get_window) axis_slice axis_reverseodd_exteven_ext const_ext)cheby1 _validate_soszpk2sos)firwin)_sosfilt)! correlatecorrelation_lags correlate2dconvolve convolve2d fftconvolve oaconvolve order_filtermedfilt medfilt2dwienerlfilterlfilticsosfilt deconvolvehilberthilbert2envelope unique_rootsinvresinvreszresidueresiduezresample resample_polydetrend lfilter_zi sosfilt_zi sosfiltfiltchoose_conv_methodfiltfiltdecimatevectorstrength)validsamefull)fillpadwrapcircularsymm symmetricreflectcR[U$![an[S5UeSnAff=f)N5Acceptable mode flags are 'valid', 'same', or 'full'.) _modedictKeyError ValueError)modees L/var/www/html/venv/lib/python3.13/site-packages/scipy/signal/_signaltools.py _valfrommoderS.s67 7/056 77s & !&cX[US-$![an[S5UeSnAff=f)Nr?zZAcceptable boundary flags are 'fill', 'circular' (or 'wrap'), and 'symmetric' (or 'symm').) _boundarydictrNrO)boundaryrQs rR_bvalfromboundaryrW6sBMX&!++ MEFKL MMs  ) $)c^^US:wagT(dgUc[[T55n[UU4SjU55n[UU4SjU55nU(dU(d [S5eU(+$)aDetermine if inputs arrays need to be swapped in `"valid"` mode. 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 calculated 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@Fc3:># UHnTUTU:v M g7fN.0ishape1shape2s rR &_inputs_swap_needed..V 3dfQi6!9$dc3:># UHnTUTU:v M g7frZr[r\s rRrarbWrcrdzOFor 'valid' mode, one must be at least as large as the other in every dimension)rangelenallrO)rPr_r`axesok1ok2s `` rR_inputs_swap_neededrl>sk w  |S[! 3d 3 3C 3d 3 3C 3DE E7Nc[R"U5Rn[R"U[R5(dU[R [R [R[R[R[R4;d$SUSUS3n[R"U[SS9 ggg)z/Warn if arr.dtype is object or longdouble. dtype=z is not supported by z and will raise an error in SciPy 1.17.0. Supported dtypes are: boolean, integer, `np.float16`,`np.float32`, `np.float64`, `np.complex64`, `np.complex128`.category stacklevelN)npasarraydtype issubdtypeintegerbool_float16float32float64 complex64 complex128warningswarnDeprecationWarning)arrnamedtmsgs rR_reject_objectsr`s C  B MM"bjj ) )bhh BJJ llBMM33RD-dV4K L  c$61E3 *rmc[R"U5n[R"U5n[US5 [US5 URURs=:XaS:XaO OXR 5-$URUR:wa [ S5e[ UnUS;a[U[U5X#5$US:XGa[XU5(a[R"XU5$US:H=(a URUR:=(d [X RUR5nU(aXpUS :Xaq[URUR5VVs/sH upxXx- S -PM n nn[R "XR"5n [$R&"XX5n O[URUR5VVs/sH upxXx-S - PM n nn[R("XR"5n [+S UR55n UR-5X'US:Xa![R "XR"5n O1US :Xa+[R "URUR"5n [$R&"XW U5n U(a [U 5n U $[ S 5e![an[ S5UeSnAff=fs snnfs snnf)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`. 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`. correlation_lags : calculates the lag / displacement indices array for 1D cross-correlation. 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. When using "same" mode with even-length inputs, the outputs of `correlate` and `correlate2d` differ: There is a 1-index offset between them. Examples -------- Implement a matched filter using cross-correlation, to recover a signal that has passed through a noisy channel. >>> import numpy as np >>> from scipy import signal >>> import matplotlib.pyplot as plt >>> rng = np.random.default_rng() >>> sig = np.repeat([0., 1., 1., 0., 1., 0., 0., 1.], 128) >>> sig_noise = sig + rng.standard_normal(len(sig)) >>> corr = signal.correlate(sig_noise, np.ones(128), mode='same') / 128 >>> 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() >>> plt.show() Compute the cross-correlation of a noisy signal with the original signal. >>> x = np.arange(128) / 128 >>> sig = np.sin(2 * np.pi * x) >>> sig_noise = sig + rng.standard_normal(len(sig)) >>> corr = signal.correlate(sig_noise, sig) >>> lags = signal.correlation_lags(len(sig), len(sig_noise)) >>> corr /= np.max(corr) >>> fig, (ax_orig, ax_noise, ax_corr) = plt.subplots(3, 1, figsize=(4.8, 4.8)) >>> ax_orig.plot(sig) >>> ax_orig.set_title('Original signal') >>> ax_orig.set_xlabel('Sample Number') >>> ax_noise.plot(sig_noise) >>> ax_noise.set_title('Signal with noise') >>> ax_noise.set_xlabel('Sample Number') >>> ax_corr.plot(lags, corr) >>> ax_corr.set_title('Cross-correlated signal') >>> ax_corr.set_xlabel('Lag') >>> ax_orig.margins(0, 0.1) >>> ax_noise.margins(0, 0.1) >>> ax_corr.margins(0, 0.1) >>> fig.tight_layout() >>> plt.show() rr/in1 and in2 should have the same dimensionalityrLN)rautodirectrBr@rc3:# UHn[SU5v M g7f)rN)slice)r]r^s rRracorrelate..%s6IquQ{{IsrA7Acceptable method flags are 'auto', 'direct', or 'fft'.)rtrurndimconjrOrMrNr!_reverse_and_conj _np_conv_okrsizerlshapezipemptyrvr _correlateNDzerostuplecopy)in1in2rPmethodvalrQswapped_inputsr^jpsoutz in1zpaddedscs rRrrpsiL **S/C **S/CC%C% xx388 q XXZ SXX JKK7o  .s3TBB 8  s & &<<$/ /  6>D3880CJ-dIIsyyI   7?(+CIIsyy(AB(A!%!)(ABB((2yy)C&&s:A),CIIsyy(AB(A!%!)(ABB"ii0J6CII66B XXZJNv~hhr99-hhsyy#))4&&zSAA !!$A01 1g 7/056 770C Cs$! K3K5$K; K2! K--K2cUS:Xa[R"U*S-U5nU$US:XaR[R"U*S-U5nURS-nUS-nUS-S:Xa X4U- XE-nU$X4U- XE-S-nU$US:Xa?X- nUS:a"US-5nU$[R"US5nU$[SUS35e) aK Calculates the lag / displacement indices array for 1D cross-correlation. Parameters ---------- in1_len : int First input size. in2_len : int Second input size. mode : str {'full', 'valid', 'same'}, optional A string indicating the size of the output. See the documentation `correlate` for more information. Returns ------- lags : array Returns an array containing cross-correlation lag/displacement indices. Indices can be indexed with the np.argmax of the correlation to return the lag/displacement. See Also -------- correlate : Compute the N-dimensional cross-correlation. Notes ----- Cross-correlation for continuous functions :math:`f` and :math:`g` is defined as: .. math:: \left ( f\star g \right )\left ( \tau \right ) \triangleq \int_{t_0}^{t_0 +T} \overline{f\left ( t \right )}g\left ( t+\tau \right )dt Where :math:`\tau` is defined as the displacement, also known as the lag. Cross correlation for discrete functions :math:`f` and :math:`g` is defined as: .. math:: \left ( f\star g \right )\left [ n \right ] \triangleq \sum_{-\infty}^{\infty} \overline{f\left [ m \right ]}g\left [ m+n \right ] Where :math:`n` is the lag. Examples -------- Cross-correlation of a signal with its time-delayed self. >>> import numpy as np >>> from scipy import signal >>> rng = np.random.default_rng() >>> x = rng.standard_normal(1000) >>> y = np.concatenate([rng.standard_normal(100), x]) >>> correlation = signal.correlate(x, y, mode="full") >>> lags = signal.correlation_lags(x.size, y.size, mode="full") >>> lag = lags[np.argmax(correlation)] rBrrAr?rr@zMode z is invalid)rtarangerrO)in1_lenin2_lenrPlagsmid lag_bounds rRrr:s~ v~yy'Aw/< K; yy'Aw/ii1nqL Q;! Y8D" KY(9:D K % >99Y]+D K99Y*D K5k233rmc[R"U5n[R"UR5nX!- S-nX1-n[ [ U55Vs/sHn[ X5XE5PM nnU[U5$s snf)Nr?)rtruarrayrrfrgrr)rnewshape currshapestartindendindkmyslices rR _centeredrsvzz(#H#I$*H  F6;CK6HI6HuX[&),6HGI uW~ JsBFc^^^ URmURm TSLn[USTS9unmU(d[T5(d [S5eTVs/sHnTUS:wdMT US:wdMUPM snmU(aTR 5 [ UUU 4Sj[ UR555(d[STST 35e[UTT TS9(aXpXT4$s snf) aBHandle the axes argument for frequency-domain convolution. Returns the inputs and axes in a standard form, eliminating redundant axes, swapping the inputs if necessary, and checking for various potential errors. Parameters ---------- in1 : array First input. in2 : array Second input. mode : str {'full', 'valid', 'same'}, optional A string indicating the size of the output. See the documentation `fftconvolve` for more information. axes : list of ints Axes over which to compute the FFTs. sorted_axes : bool, optional If `True`, sort the axes. Default is `False`, do not sort. Returns ------- in1 : array The first input, possible swapped with the second input. in2 : array The second input, possible swapped with the first input. axes : list of ints Axes over which to compute the FFTs. N)rriz#when provided, axes cannot be emptyrc3># UH5oT;dM TUTU:H=(d TUS:H=(d TUS:Hv M7 g7frNr[)r]aris1s2s rRra'_init_freq_conv_axes..sG:'1D=:r!u1~9A!9r!uz9's A0Az%incompatible shapes for in1 and in2: z and ri) rrrgrOsortrhrfrrl) rrrPri sorted_axesnoaxes_rrrs ` @@rR_init_freq_conv_axesrs@ B B T\F%cDAGAt #d))>?? 9t!r!uzAbeqjAt 9D :chh: : :DbT+, ,4Rd3S T> :s C'%C'0C'c>[U5(dX-$URRS:H=(d URRS:HnU(a/UVs/sH!n[R"X6U(+5PM# nnOUnU(d [R [R pO[R[RpU"XUS9n U"XUS9n U "X-XrS9n U(a)[UV s/sHn [U 5PM sn 5nXn U $s snfs sn f)aConvolve two arrays in the frequency domain. This function implements only base the FFT-related operations. Specifically, it converts the signals to the frequency domain, multiplies them, then converts them back to the time domain. Calculations of axes, shapes, convolution mode, etc. are implemented in higher level-functions, such as `fftconvolve` and `oaconvolve`. Those functions should be used instead of this one. Parameters ---------- in1 : array_like First input. in2 : array_like Second input. Should have the same number of dimensions as `in1`. axes : array_like of ints Axes over which to compute the FFTs. shape : array_like of ints The sizes of the FFTs. calc_fast_len : bool, optional If `True`, set each value of `shape` to the next fast FFT length. Default is `False`, use `axes` as-is. Returns ------- out : array An N-dimensional array containing the discrete linear convolution of `in1` with `in2`. cr) rgrvkindsp_fft next_fast_lenrfftnirfftnfftnifftnrr)rrrir calc_fast_lencomplex_resultrfshaperifftsp1sp2retszfslices rR_freq_domain_convrs> t99yiinn+Dsyy~~/DNIMNHL1F ~+= > N LL&--TKKT c %C c %C sy& ,CE2Ebb E23k J'N 3s (D3DcPUS:XaUR5$US:Xa[X5R5$US:Xa\[UR5Vs/sH#nXT;aURUO XX%- S-PM% nn[X5R5$[ S5es snf)aCalculate the convolution result shape based on the `mode` argument. Returns the result sliced to the correct size for the given mode. Parameters ---------- ret : array The result array, with the appropriate shape for the 'full' mode. s1 : list of int The shape of the first input. s2 : list of int The shape of the second input. mode : str {'full', 'valid', 'same'} A string indicating the size of the output. See the documentation `fftconvolve` for more information. axes : list of ints Axes over which to compute the convolution. Returns ------- ret : array A copy of `res`, sliced to the correct size for the given `mode`. rBrAr@rz4acceptable mode flags are 'valid', 'same', or 'full')rrrfrrrO)rrrrPrir shape_valids rR_apply_conv_moder s2 v~xxz !&&((  %chh1 /1()}syy|"%"%-!:KK / 1*//11./ / 1s*B#cn[R"U5n[R"U5nURURs=:Xa S:XaX-$ URUR:wa [S5eURS:XdURS:Xa[R "/5$[ XX#SS9upnURnURn[UR5Vs/sH%nXc;a[XFXV45O XFXV-S- PM' nn[XX7SS9n[XXRU5$s snf)a 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`. 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. axes : int or array_like of ints or None, optional Axes over which to compute the convolution. The default is over all axes. Returns ------- out : array An N-dimensional array containing a subset of the discrete linear convolution of `in1` with `in2`. See Also -------- convolve : Uses the direct convolution or FFT convolution algorithm depending on which is faster. oaconvolve : Uses the overlap-add method to do convolution, which is generally faster when the input arrays are large and significantly different in size. Examples -------- Autocorrelation of white noise is an impulse. >>> import numpy as np >>> from scipy import signal >>> rng = np.random.default_rng() >>> sig = rng.standard_normal(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 datasets >>> face = datasets.face(gray=True) >>> kernel = np.outer(signal.windows.gaussian(70, 8), ... signal.windows.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() rrFrrTr) rtrurrOrrrrrfmaxrr) rrrPrirrr^rrs rRr#r#Fs| **S/C **S/C xx388 q y! SXX JKK Q#((a-xx|)#D6;=NCd B BCHHo '%%&MS"% ruru}q7H H%  ' Cd FC CRt 44  's,,D2cnX-S- SX4nX:Xd US:XdUS:XaU$X:aXpSnOSnXS- :aU$US- nU*[SS[R-U-- SS9R-n[R "[R "U55nX`:aU$U(d Xa- S-nUnO UnXa- S-nXdXx4$)aCalculate the optimal FFT lengths for overlap-add convolution. The calculation is done for a single dimension. Parameters ---------- s1 : int Size of the dimension for the first array. s2 : int Size of the dimension for the second array. Returns ------- block_size : int The size of the FFT blocks. overlap : int The amount of overlap between two blocks. in1_step : int The size of each step for the first array. in2_step : int The size of each step for the first array. rNTFr?)r)rmathrQrealrrceil) rrfallbackswappedoverlapopt_size block_sizein1_stepin2_steps rR _calc_oa_lensrs2ar&H x27bAg wB TzldGxQtvvXg%5!6"=BBBH%%dii&9:J =?=?  22rmc* ^^#^$[R"U5n[R"U5nURURs=:Xa S:XaX-$ URUR:wa [S5eURS:XdURS:Xa[R "/5$UR UR :Xa [XUTS9$[XUTSS9upmUR m#UR m$T(dX-n[UT#T$UT5$[UR5Vs/sHnUT;aSO T#UT$U-S- PM nnUU#U$4Sj[UR55n[U6uppU T#:XaU T$:Xa [XUTS9$/n /n /n/n[UR5HnUT;aUS /- nUS /- nMT#UX:aF[R"T#US-X- 5nXX- U-Xe:aUS- nUX-T#U- nOSnSnT$UX:aF[R"T$US-X- 5nXX- U-Xe:aUS- nUX-T$U- nOSnSnU U/- n U U/- n USU4/- nUSU4/- nM [S U55(d[R"XS SS 9n[S U55(d[R"XS SS 9n[!T5VVs/sH unnUU-PM nnnUVs/sHnUS-PM nn[#U 5n[#U 5n[!U5H.unnUR%UX5 UR%UX5 M0 UR&"U6nUR&"U6nTVs/sHoXUPM nn[)XUUSS9n[TUU5HunnnU UnUcM[R*"UU*/U5unn[R*"US/U5Sn[R*"UU/U5Sn[R*"US/U5SnUU- nM [UR5Vs/sHAoUU;dM UU;aUR UO!UR UUR US- -PMC n nUR&"U 6n[-UV!s/sHn![/U!5PM sn!5n"UU"n[UT#T$UT5$s snfs snnfs snfs snfs snfs sn!f)a Convolve two N-dimensional arrays using the overlap-add method. Convolve `in1` and `in2` using the overlap-add method, with the output size determined by the `mode` argument. This is generally much faster than `convolve` for large arrays (n > ~500), and generally much faster than `fftconvolve` when one array is much larger than the other, but can be slower when only a few output values are needed or when the arrays are very similar in shape, 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`. 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. axes : int or array_like of ints or None, optional Axes over which to compute the convolution. The default is over all axes. Returns ------- out : array An N-dimensional array containing a subset of the discrete linear convolution of `in1` with `in2`. See Also -------- convolve : Uses the direct convolution or FFT convolution algorithm depending on which is faster. fftconvolve : An implementation of convolution using FFT. Notes ----- .. versionadded:: 1.4.0 References ---------- .. [1] Wikipedia, "Overlap-add_method". https://en.wikipedia.org/wiki/Overlap-add_method .. [2] Richard G. Lyons. Understanding Digital Signal Processing, Third Edition, 2011. Chapter 13.10. ISBN 13: 978-0137-02741-5 Examples -------- Convolve a 100,000 sample signal with a 512-sample filter. >>> import numpy as np >>> from scipy import signal >>> rng = np.random.default_rng() >>> sig = rng.standard_normal(100000) >>> filt = signal.firwin(512, 0.01) >>> fsig = signal.oaconvolve(sig, filt) >>> 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(fsig) >>> ax_mag.set_title('Filtered noise') >>> fig.tight_layout() >>> fig.show() rr)rPriTrNrc3l># UH)nUT;a SSTUTU4O[TUTU5v M+ g7frN)r)r]r^rirrs rRraoaconvolve..sGK:IQ01}b"beRU+"2a5"Q%01:Is14rrc3*# UH oS:Hv M g7frNr[r]curpads rRrar8iFiconstant)rPconstant_valuesc3*# UH oS:Hv M g7frr[rs rRrarrrFrr)rtrurrOrrrr#rrrfrrrrhrE enumeratelistinsertreshapersplitrr)%rrrPrirr^ shape_final optimal_sizesroverlapsrrnsteps1nsteps2 pad_size1 pad_size2 curnstep1curpad1 curnstep2curpad2iax split_axesfft_axes reshape_size1 reshape_size2 fft_shapeaxax_fftax_splitroverpart ret_overpart shape_retislice slice_finalrrs% ` @@rRr$r$+sT` **S/C **S/C xx388 q y! SXX JKK Q#((a-xx| cii 3$T::)#D$6:J W_/1x"'A++bgkR=OJ V^%'W"''R1W"q&Q$??  6>U2Yb 2U95EEJ W_U2Yb 2U95EEJ V^rU2Y.J,/,AB,ADAaeai,ANB nA!ebffQiG J =BF2CsF-F3,F9c*[URURU5up4URS:XaSOSnURS:Xa+SSU4SSU4URUR::aSS U4OS S .OS S U4SSU4SSU4S .nXbupxn Xs-X-U -:$)an See if using fftconvolve or convolve is faster. Parameters ---------- x : np.ndarray Signal h : np.ndarray Kernel mode : str Mode passed to convolve Returns ------- fft_faster : bool Notes ----- See docstring of `choose_conv_method` for details on tuning hardware. See pull request 11031 for more detail: https://github.com/scipy/scipy/pull/11031. rgMbPg-C6g^]B> >g "]=g{$R>gen=gr0 < ,>gg=)gd[֠+>g@jHI>gh㈵)r@rBrAg.w'>gvlV>gG[*!>gʑQ>gVN+!>g4RP>)r*rrr) xhrPr)r&offset constantsO_fftO_directO_offsets rR_fftconv_fasterr3;s2$AGGQWWd;GffkUuF 1 $]F;!=&9vv"=&95 !*f5V4V4 !*EX ?X2X= ==rmc\[SSS54UR-nXR5$)zG Reverse array `x` in all dimensions and perform the complex conjugate Nr)rrr)r,reverses rRrres-T4$&/G :?? rmcURURs=:XaS:Xa*O gUS;agUS:XaURUR:$gg)a) 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. Invalid mode strings will return False and be caught by the calling func. r)rBr@TrAFN)rr)volumekernelrPs rRrrmsP{{fkk&Q&  $ $ V^;;&++- -rmc[R"X5nSn[SS5H!nSU-nURU5nUS:dM! O US:aUnO!WS-nURX&5n[ U5nUW- n U $)a 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. r gMb@?r)timeitTimerrfrepeatr) stmtsetupr=timerr,pnumberbestrsecs rR _timeit_fastrF~s LL %E A 1b\Q LL  >    1u"  LL (1v -C Jrmc <^^^ ^ [R"U5m [R"U5m[T S5 [TS5 U(a30nSHm [UU UU 4Sj5UT 'M USUS:aSOSnXT4$[ T T4Vs/sHn[ U/SS9PM sn5(a[ [R"T 5R55[ [R"T5R55-nU[ [T RTR55-nUS[R"S 5R-S - :ag[ T T/S S9(ag[ T T/5(a[T TT5(aggs snf) as Find the fastest convolution/correlation method. This primarily exists to be called during the ``method='auto'`` option in `convolve` and `correlate`. It can also be used to determine the value of ``method`` for many different convolutions of the same dtype/shape. In addition, it supports timing the convolution to adapt the value of ``method`` to a particular set of inputs and/or hardware. Parameters ---------- in1 : array_like The first argument passed into the convolution function. in2 : array_like The second argument passed into the convolution function. 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. measure : bool, optional If True, run and time the convolution of `in1` and `in2` with both methods and return the fastest. If False (default), predict the fastest method using precomputed values. Returns ------- method : str A string indicating which convolution method is fastest, either 'direct' or 'fft' times : dict, optional A dictionary containing the times (in seconds) needed for each method. This value is only returned if ``measure=True``. See Also -------- convolve correlate Notes ----- Generally, this method is 99% accurate for 2D signals and 85% accurate for 1D signals for randomly chosen input sizes. For precision, use ``measure=True`` to find the fastest method by timing the convolution. This can be used to avoid the minimal overhead of finding the fastest ``method`` later, or to adapt the value of ``method`` to a particular set of inputs. Experiments were run on an Amazon EC2 r5a.2xlarge machine to test this function. These experiments measured the ratio between the time required when using ``method='auto'`` and the time required for the fastest method (i.e., ``ratio = time_auto / min(time_fft, time_direct)``). In these experiments, we found: * There is a 95% chance of this ratio being less than 1.5 for 1D signals and a 99% chance of being less than 2.5 for 2D signals. * The ratio was always less than 2.5/5 for 1D/2D signals respectively. * This function is most inaccurate for 1D convolutions that take between 1 and 10 milliseconds with ``method='direct'``. A good proxy for this (at least in our experiments) is ``1e6 <= in1.size * in2.size <= 1e7``. The 2D results almost certainly generalize to 3D/4D/etc because the implementation is the same (the 1D implementation is different). All the numbers above are specific to the EC2 machine. However, we did find that this function generalizes fairly decently across hardware. The speed tests were of similar quality (and even slightly better) than the same tests performed on the machine to tune this function's numbers (a mid-2014 15-inch MacBook Pro with 16GB RAM and a 2.5GHz Intel i7 processor). There are cases when `fftconvolve` supports the inputs but this function returns `direct` (e.g., to protect against floating point integer precision). .. versionadded:: 0.19 Examples -------- Estimate the fastest method for a given input: >>> import numpy as np >>> from scipy import signal >>> rng = np.random.default_rng() >>> img = rng.random((32, 32)) >>> filter = rng.random((8, 8)) >>> method = signal.choose_conv_method(img, filter, mode='same') >>> method 'fft' This can then be applied to other arrays of the same dtype and shape: >>> img2 = rng.random((32, 32)) >>> filter2 = rng.random((8, 8)) >>> corr2 = signal.correlate(img2, filter2, mode='same', method=method) >>> conv2 = signal.convolve(img2, filter2, mode='same', method=method) The output of this function (``method``) works with `correlate` and `convolve`. r;)rrc>[TTTTS9$)N)rPr)r!)r8rrPr7srR$choose_conv_method..s&&.262Crmrrui)rr?floatrb)rtrurrFanyrintrrrrfinfonmantr3) rrrPmeasuretimes chosen_methodr, max_valuer8rr7s ` @@@rRr;r;s_XZZ_F ZZ_FF01F01'F(*CDE&M("'uh!?X ##  vv6F G6FOQCt ,6F GHHv**,-BFF6N4F4F4H0II SV[[&++677 q"((7+111A5 5's3'(( 664 0 0  HsFc[R"U5n[R"U5n[US5 [US5 URURs=:Xa S:XaXE-$ URUR:wa [ S5e[ X$R UR 5(aXTpTUS:Xa [XEUS9nUS:Xa[XEUS9n[R"XE5nURS;a[R"U5n[R"URS5(d([R"URS5(a[R "S["S S 9 UR%U5$US :Xa?['XEU5(a[R("XEU5$[+U[-U5US 5$[ S 5e) az 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`. Warns ----- RuntimeWarning Use of the FFT convolution on input containing NAN or INF will lead to the entire output being NAN or INF. Use method='direct' when your input contains NAN or INF values. See Also -------- numpy.polymul : performs polynomial multiplication (same operation, but also accepts poly1d objects) choose_conv_method : chooses the fastest appropriate convolution method fftconvolve : Always uses the FFT method. oaconvolve : Uses the overlap-add method to do convolution, which is generally faster when the input arrays are large and significantly different in size. 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: >>> import numpy as np >>> from scipy import signal >>> sig = np.repeat([0., 1., 0.], 100) >>> win = signal.windows.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() rrz5volume and kernel should have the same dimensionalityrrPr>r^uzuUse of fft convolution on input with NAN or inf results in NAN or inf output. Consider using method='direct' instead.r?rqrr)rtrurrrOrlrr;r# result_typeraroundisnanflatisinfrrRuntimeWarningastyperr!rr)rrrPrr7r8rrYs rRr!r!/sDZZ_F ZZ_FFK(FK( {{fkk&Q&'  #*+ +4v||<< #F> &t4nnV4   z )))C.C 88CHHQK BHHSXXa[$9$9 MM6$2a A zz+&& 8  vt , ,;;vt4 4!26!:D(KK01 1rmc[R"U5nURHnUS-S:wdM[S5e [R"U5n[R"UR [R 5(dGUR [R[R4;d[SUR S35e[R"XUSS9nU$)a Perform an order filter on an N-D 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 -------- >>> import numpy as np >>> 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]]) r?rzHEach dimension of domain argument should have an odd number of elements.roz! is not supported by order_filterr) footprintrP) rtrurrOrwrvrxr{r|r rank_filter)rdomainrankdimsizeresults rRr%r%slZZ F<< aKA FG G 1 A MM!''2:: . .ww2::rzz226!''*KLMM  F LF Mrmc8[R"U5n[R"UR[R5(dGUR[R [R 4;d[SURS35eUcS/UR-n[R"U5nURS:Xa/[R"UR5UR5n[UR5HnXS-S:wdM[S5e [S[XR555(a[ R""S SS 9 [$R&"U5n[(R*"XS-US S 9nU$) ay 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`. The array will automatically be zero-padded. 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. Warns ----- UserWarning If array size is smaller than kernel size along any dimension See Also -------- scipy.ndimage.median_filter scipy.signal.medfilt2d Notes ----- The more general function `scipy.ndimage.median_filter` has a more efficient implementation of a median filter and therefore runs much faster. For 2-dimensional images with ``uint8``, ``float32`` or ``float64`` dtypes, the specialised function `scipy.signal.medfilt2d` may be faster. roz is not supported by medfiltrpr[r?r*Each element of kernel_size should be odd.c3.# UH upX:v M g7frZr[)r]rss rRramedfilt..9s <;TQ15;szBkernel_size exceeds volume extent: the volume will be zero-padded.)rsr)rrP)rt atleast_1drwrvrxr{r|rOrrurr=itemrfrNrrrrrrrb)r7 kernel_sizerrrfs rRr&r&s=T]]6 "F MM&,, 3 3|| BJJ776&,,/KLMMcFKK' **[)KBii 0 0 2FKK@ 6;;  NQ 1 $IJ J  >> from scipy.datasets import face >>> from scipy.signal import wiener >>> import matplotlib.pyplot as plt >>> import numpy as np >>> rng = np.random.default_rng() >>> img = rng.random((40, 40)) #Create a random image >>> filtered_img = wiener(img, (5, 5)) #Filter the image >>> f, (plot1, plot2) = plt.subplots(1, 2) >>> plot1.imshow(img) >>> plot2.imshow(filtered_img) >>> plt.show() rpr[rAr?raxisr) rtrurrr=rmrrronesmeanravelwhere)immysizenoiserlMeanlVarresrs rRr(r(Esb BB ~rww ZZ F ||r6;;="''2 99V D b"''&/6 2T 9E bAgrwwv 7$ >! KD }Q/ :CA CLC ((4< ,C Jrmcf[R"U5n[R"U5nURURs=:XaS:Xd O [S5e[ X R UR 5(aXp[ U5n[U5n[R"XSXVU5nU$)ab 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`. 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. 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. >>> import numpy as np >>> from scipy import signal >>> from scipy import datasets >>> ascent = datasets.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() r?z)convolve2d inputs must both be 2-D arraysr) rtrurrOrlrrSrWr _convolve2d)rrrPrV fillvaluerbvalrs rRr"r"sV **S/C **S/C 88sxx $1 $DEE4CII66S t C X &D   !S BC Jrmc[R"U5n[R"U5nURURs=:XaS:Xd O [S5e[ X R UR 5nU(aXp[ U5n[U5n[R"XR5SXgU5nU(a USSS2SSS24nU$)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`. 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. 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`. Notes ----- When using "same" mode with even-length inputs, the outputs of `correlate` and `correlate2d` differ: There is a 1-index offset between them. Examples -------- Use 2D cross-correlation to find the location of a template in a noisy image: >>> import numpy as np >>> from scipy import signal, datasets, ndimage >>> rng = np.random.default_rng() >>> face = datasets.face(gray=True) - datasets.face(gray=True).mean() >>> face = ndimage.zoom(face[30:500, 400:950], 0.5) # extract the face >>> template = np.copy(face[135:165, 140:175]) # right eye >>> template -= template.mean() >>> face = face + rng.standard_normal(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() r?z*correlate2d inputs must both be 2-D arraysrNr) rtrurrOrlrrSrWr r}r) rrrPrVr~rrrrs rRr r sd **S/C **S/C 88sxx $1 $EFF(yy#))DNS t C X &D   XXZCy IC$B$"*o Jrmc[R"U5nURR[R[R [R 4;a [X!5$UcS/S-n[R"U5nURS:Xa%[R"UR5S5nUHnUS-S:wdM[S5e [R"X!5$)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). The array is zero-padded automatically. 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. See Also -------- scipy.ndimage.median_filter Notes ----- This is faster than `medfilt` when the input dtype is ``uint8``, ``float32``, or ``float64``; for other types, this falls back to `medfilt`. In some situations, `scipy.ndimage.median_filter` may be faster than this function. Examples -------- >>> import numpy as np >>> from scipy import signal >>> x = np.arange(25).reshape(5, 5) >>> 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]]) # Replaces i,j with the median out of 5*5 window >>> signal.medfilt2d(x, kernel_size=5) array([[ 0, 0, 2, 0, 0], [ 0, 3, 7, 4, 0], [ 2, 8, 12, 9, 4], [ 0, 8, 12, 9, 0], [ 0, 0, 12, 0, 0]]) # Replaces i,j with the median out of default 3*3 window >>> signal.medfilt2d(x) array([[ 0, 1, 2, 3, 0], [ 1, 6, 7, 8, 4], [ 6, 11, 12, 13, 9], [11, 16, 17, 18, 14], [ 0, 16, 17, 18, 0]]) # Replaces i,j with the median out of default 5*3 window >>> signal.medfilt2d(x, kernel_size=[5,3]) array([[ 0, 1, 2, 3, 0], [ 0, 6, 7, 8, 3], [ 5, 11, 12, 13, 8], [ 5, 11, 12, 13, 8], [ 0, 11, 12, 13, 0]]) # Replaces i,j with the median out of default 3*5 window >>> signal.medfilt2d(x, kernel_size=[3,5]) array([[ 0, 0, 2, 1, 0], [ 1, 5, 7, 6, 3], [ 6, 10, 12, 11, 8], [11, 15, 17, 16, 13], [ 0, 15, 17, 16, 0]]) # As seen in the examples, # kernel numbers must be odd and not exceed original array dim rpr?r[rrh)rtrurvtypeubyter{r|r&rr=rmrOr _medfilt2d)inputrnimagers rRr'r'Psp JJu E {{"**bjjAAu**cAg **[)KBii 0 0 2A6  1H?IJ J    33rmrc^[R"T5m[R"U5n[US5 [US5 [TS5 [U5S:XGaK[R"T5m[R"U5nTR S:waUR S:wa [ S5e[U5nTX/nUGb[R"U5nUR UR :wa [ S5e[UR5nTRSS- Xc'[U5nURU:waUR S/-nUS:aX4R - n[UR 5HnX:Xa(URUXh:XaURUXx'M0X:wa(URUXh:XaURUXx'M]X:waURUS:XaSXx'M{[ SUSURS35e [RRRXFU5nUR!U5 [R""U6n U R$S ;a['S U S 35e[R("TU S 9m[R"XS 9nTUS-m[R"X)S 9n[R*"U4S jX25n U R [-S5/-n Ub0[-URU5X'U [U 5==U- ss'[-U RU[T5- S-5X'U [U 5n UcU $[-U RU[T5- S-S5X'U [U 5n X4$Uc[.R0"TXU5$[.R0"TXX45$)a 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). The function `sosfilt` (and filter design using ``output='sos'``) should be preferred over `lfilter` for most filtering tasks, as second-order sections have fewer numerical problems. 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 zero 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: >>> import numpy as np >>> from scipy import signal >>> import matplotlib.pyplot as plt >>> rng = np.random.default_rng() >>> 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 + rng.standard_normal(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)rz+object of too small depth for desired arrayNrz"Unexpected shape for zi: expected z, found .fdgFDGO input type '' not supportedrvc2>[R"TU5$rZ)rtr!)yrMs rRrIlfilter..nsQ1Brm)rtrlrrgrurrO _validate_xrrrrfstrideslib stride_tricks as_stridedappendrYcharNotImplementedErrorrapply_along_axisrr _linear_filter)rMrr,rqziinputsexpected_shaperrrvout_fullindrzfs` rRr)r)sRx aA aAAy!Ay!Ay! 1v{ JJqM JJqM 66Q;166Q;JK K NQ >BBww!&&  !NOO!!'']N#$771:>N ">2Nxx>)''TF*!8GGODrwwAyRXXa[N4E%E%'ZZ] rxx{n6G'G%'ZZ] rxx{a'7%& ()M,:+;8BHH:Q*PQQ(VV))44R5<> MM" ' ::Y &% UG?&KL L HHQe $ JJq & QqT  JJq &&&'BDLmmuT{m+ >bhhtn-CI U3Z B & (...Q7!;< uSz" :JhnnT2SV;a?FCI%*%B7N :++AqT: :++AqT> >rmc [R"U5S- n[R"U5S- n[XT5n[R"U5nUcu[R"[R"U5[R"U5U5nUR S;a[R n[R"XWS9nO[R"U5n[R"[R"U5[R"U5X#5nUR S;a[R nURU5n[R"U5nX:a+[RU[R"XX- 54nURU5n[R"Xg5n [R"U5nX:a+[RU[R"XH- 54n[U5H'n [R"X S-SUSXZ- -SS9X'M) [U5H/n X==[R"XS-SUSXJ- -SS9-ss'M1 U $)a Construct initial conditions for lfilter given input and output vectors. 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 rNbuirrrp) rtrrrurYrr|rr_r_rfsum) rMrrr,r(MKrYLrms rRr*r*sP  QA  QA A A 1 AynnRZZ]BJJqM1E   u $**K HHQ * JJqMnnRZZ]BJJqM1H   u $**K HH[ ! GGAJ 5a!%()A A ! !B  Au EE!RXXae_$ % 1XqQy1Vae9,151X a%& AfquI-A66 Irmc[R"U5n[R"U5nURS:a [S5eURS:a [S5e[ U5n[ U5nXT:a/nUnXg4$[R "XE- S-[ 5nSUS'[X#U5nU[X6SS9- nXg4$)aDeconvolves ``divisor`` out of ``signal`` using inverse filtering. Returns the quotient and remainder such that ``signal = convolve(divisor, quotient) + remainder`` Parameters ---------- signal : (N,) array_like Signal data, typically a recorded signal divisor : (N,) 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 See Also -------- numpy.polydiv : performs polynomial division (same operation, but also accepts poly1d objects) 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.]) rzsignal must be 1-D.zdivisor must be 1-D.rrBrW) rtrlrrOrgrrLr)r!) signaldivisornumdenr(Dquotremrs rRr,r,sR -- C -- C xx!|.// xx!|/00 CA CAu 9 E*as'HSV44 9rmcF[R"U5n[R"U5(a [S5eUcURUnUS::a [S5e[ R "XUS9n[R"XRS9nUS-S:XaS=US'XAS-'SUSUS-&OSUS'SUSUS-S-&URS:a9[R/UR-n[S5XR'U[U5n[ R"X4-US9nU$) a FFT-based computation of the analytic signal. The analytic signal is calculated by filtering out the negative frequencies and doubling the amplitudes of the positive frequencies in the FFT domain. The imaginary part of the result is the hilbert transform of the real-valued input signal. 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 a real-valued signal ``x(t)`` can be expressed as [1]_ .. 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`. [2]_ In other words, the negative half of the frequency spectrum is zeroed out, turning the real-valued signal into a complex-valued signal. The Hilbert transformed signal can be obtained from ``np.imag(hilbert(x))``, and the original signal from ``np.real(hilbert(x))``. References ---------- .. [1] Wikipedia, "Analytic signal". https://en.wikipedia.org/wiki/Analytic_signal .. [2] Wikipedia, "Hilbert Transform". https://en.wikipedia.org/wiki/Hilbert_transform .. [3] Leon Cohen, "Time-Frequency Analysis", 1995. Chapter 2. .. [4] Alan V. Oppenheim, Ronald W. Schafer. Discrete-Time Signal Processing, Third Edition, 2009. Chapter 12. ISBN 13: 978-1292-02572-8 See Also -------- envelope: Compute envelope of a real- or complex-valued signal. Examples -------- In this example we use the Hilbert transform to determine the amplitude envelope and instantaneous frequency of an amplitude-modulated signal. Let's create a chirp of which the frequency increases from 20 Hz to 100 Hz and apply an amplitude modulation: >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.signal import hilbert, chirp ... >>> duration, fs = 1, 400 # 1 s signal with sampling frequency of 400 Hz >>> t = np.arange(int(fs*duration)) / fs # timestamps of samples >>> 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 the 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, (ax0, ax1) = plt.subplots(nrows=2, sharex='all', tight_layout=True) >>> ax0.set_title("Amplitude-modulated Chirp Signal") >>> ax0.set_ylabel("Amplitude") >>> ax0.plot(t, signal, label='Signal') >>> ax0.plot(t, amplitude_envelope, label='Envelope') >>> ax0.legend() >>> ax1.set(xlabel="Time in seconds", ylabel="Phase in rad", ylim=(0, 120)) >>> ax1.plot(t[1:], instantaneous_frequency, 'C2-', label='Instantaneous Phase') >>> ax1.legend() >>> plt.show() x must be real.NrN must be positive.rprr?r)rtru iscomplexobjrOrrrrrvrnewaxisrrr)r,r(rqXfr-rs rRr-r- s z 1 A q*++y GGDMAv.// At $B ((#A1uz!qay!AF !!QUqLvvzzzlQVV#$K eCjM BF&A Hrmc[R"U5nURS:a [S5e[R"U5(a [S5eUc UR nOv[ U[5(aUS::a [S5eX4nOL[U5S:wd2[R"[R"U5S:*5(a [S5e[R"XSS 9n[R"USURS 9n[R"US URS 9nX44HAnUR SnUS-S:XaS =US'XVS-'SUS US-&M1S US'SUS US -S-&MC USS2[R4U[RSS24-nURnUS:a$USS2[R4nUS -nUS:aM$[R "X%-SS 9nU$) 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", https://en.wikipedia.org/wiki/Analytic_signal r?zx must be 2-D.rNrrz@When given as a tuple, N must hold exactly two positive integers)rrrrr)rt atleast_2drrOrrrrOrgrNrurfft2rrvrifft2)r,r(rh1h2r-N1rs rRr.r. s, aAvvz)** q*++y GG As   623 3 F Q1rzz!}12212 2 Q 'B !A$bhh 'B !A$bhh 'BX WWQZ 6Q; ! !AaD11W:AaaLAaD!"AaaA  1bjj=Brzz1}--A A a% am  Q a%  RV&)A Hrmlowpass)n_outsquaredresidualrqc" UR*Us=::aUR:d O [SU<SUR<S35eURUS:d[SUR<SU<S35e[U5S:wd[ SU55(d[S U<S 35e[ U[ 5(aSU:dUb[S U<S 35eUS;a[SU<S35eURUnUcUOUnX&- n[USbUSOUS-*USbUSOUS-S-5nU*S-URs=::aURs=:a US-S-::d&O [SSURU<SU<S3-5e[R"XS5n[R"U5(a[R"U5n O[R"U[R "UR"S S5R$S9n [R "U5U SS US-S-24'URS:aU SU4==S-ss'O+URS:aU SSUR24==S-ss'URSs=::aUR:d O [R&"U SU4US9U-n O\[URUS--URUS--5n [R&"[R("U SS9SU 4US9U-n U(d[R*"U 5OU R,S-U R.S--n [R"U SU5n UcU $URSs=::aUR:d O SU SU4'O'SuU SS UR24'U SURS 24'US:XaMURS:aSU SURUS-S-24'O#SuU SURS 24'U SSUS-S-24'U[R"U5(a[R&"XS9O[R0"XS9-n [R2"U [R"U SU54SS9$)a,Compute the envelope of a real- or complex-valued signal. Parameters ---------- z : ndarray Real- or complex-valued input signal, which is assumed to be made up of ``n`` samples and having sampling interval ``T``. `z` may also be a multidimensional array with the time axis being defined by `axis`. bp_in : tuple[int | None, int | None], optional 2-tuple defining the frequency band ``bp_in[0]:bp_in[1]`` of the input filter. The corner frequencies are specified as integer multiples of ``1/(n*T)`` with ``-n//2 <= bp_in[0] < bp_in[1] <= (n+1)//2`` being the allowed frequency range. ``None`` entries are replaced with ``-n//2`` or ``(n+1)//2`` respectively. The default of ``(1, None)`` removes the mean value as well as the negative frequency components. n_out : int | None, optional If not ``None`` the output will be resampled to `n_out` samples. The default of ``None`` sets the output to the same length as the input `z`. squared : bool, optional If set, the square of the envelope is returned. The bandwidth of the squared envelope is often smaller than the non-squared envelope bandwidth due to the nonlinear nature of the utilized absolute value function. I.e., the embedded square root function typically produces addiational harmonics. The default is ``False``. residual : Literal['lowpass', 'all', None], optional This option determines what kind of residual, i.e., the signal part which the input bandpass filter removes, is returned. ``'all'`` returns everything except the contents of the frequency band ``bp_in[0]:bp_in[1]``, ``'lowpass'`` returns the contents of the frequency band ``< bp_in[0]``. If ``None`` then only the envelope is returned. Default: ``'lowpass'``. axis : int, optional Axis of `z` over which to compute the envelope. Default is last the axis. Returns ------- ndarray If parameter `residual` is ``None`` then an array ``z_env`` with the same shape as the input `z` is returned, containing its envelope. Otherwise, an array with shape ``(2, *z.shape)``, containing the arrays ``z_env`` and ``z_res``, stacked along the first axis, is returned. It allows unpacking, i.e., ``z_env, z_res = envelope(z, residual='all')``. The residual ``z_res`` contains the signal part which the input bandpass filter removed, depending on the parameter `residual`. Note that for real-valued signals, a real-valued residual is returned. Hence, the negative frequency components of `bp_in` are ignored. Notes ----- Any complex-valued signal :math:`z(t)` can be described by a real-valued instantaneous amplitude :math:`a(t)` and a real-valued instantaneous phase :math:`\phi(t)`, i.e., :math:`z(t) = a(t) \exp\!\big(j \phi(t)\big)`. The envelope is defined as the absolute value of the amplitude :math:`|a(t)| = |z(t)|`, which is at the same time the absolute value of the signal. Hence, :math:`|a(t)|` "envelopes" the class of all signals with amplitude :math:`a(t)` and arbitrary phase :math:`\phi(t)`. For real-valued signals, :math:`x(t) = a(t) \cos\!\big(\phi(t)\big)` is the analogous formulation. Hence, :math:`|a(t)|` can be determined by converting :math:`x(t)` into an analytic signal :math:`z_a(t)` by means of a Hilbert transform, i.e., :math:`z_a(t) = a(t) \cos\!\big(\phi(t)\big) + j a(t) \sin\!\big(\phi(t) \big)`, which produces a complex-valued signal with the same envelope :math:`|a(t)|`. The implementation is based on computing the FFT of the input signal and then performing the necessary operations in Fourier space. Hence, the typical FFT caveats need to be taken into account: * The signal is assumed to be periodic. Discontinuities between signal start and end can lead to unwanted results due to Gibbs phenomenon. * The FFT is slow if the signal length is prime or very long. Also, the memory demands are typically higher than a comparable FIR/IIR filter based implementation. * The frequency spacing ``1 / (n*T)`` for corner frequencies of the bandpass filter corresponds to the frequencies produced by ``scipy.fft.fftfreq(len(z), T)``. If the envelope of a complex-valued signal `z` with no bandpass filtering is desired, i.e., ``bp_in=(None, None)``, then the envelope corresponds to the absolute value. Hence, it is more efficient to use ``np.abs(z)`` instead of this function. Although computing the envelope based on the analytic signal [1]_ is the natural method for real-valued signals, other methods are also frequently used. The most popular alternative is probably the so-called "square-law" envelope detector and its relatives [2]_. They do not always compute the correct result for all kinds of signals, but are usually correct and typically computationally more efficient for most kinds of narrowband signals. The definition for an envelope presented here is common where instantaneous amplitude and phase are of interest (e.g., as described in [3]_). There exist also other concepts, which rely on the general mathematical idea of an envelope [4]_: A pragmatic approach is to determine all upper and lower signal peaks and use a spline interpolation to determine the curves [5]_. References ---------- .. [1] "Analytic Signal", Wikipedia, https://en.wikipedia.org/wiki/Analytic_signal .. [2] Lyons, Richard, "Digital envelope detection: The good, the bad, and the ugly", IEEE Signal Processing Magazine 34.4 (2017): 183-187. `PDF `__ .. [3] T.G. Kincaid, "The complex representation of signals.", TIS R67# MH5, General Electric Co. (1966). `PDF `__ .. [4] "Envelope (mathematics)", Wikipedia, https://en.wikipedia.org/wiki/Envelope_(mathematics) .. [5] Yang, Yanli. "A signal theoretic approach for envelope analysis of real-valued signals." IEEE Access 5 (2017): 5623-5630. `PDF `__ See Also -------- hilbert: Compute analytic signal by means of Hilbert transform. Examples -------- The following plot illustrates the envelope of a signal with variable frequency and a low-frequency drift. To separate the drift from the envelope, a 4 Hz highpass filter is used. The low-pass residuum of the input bandpass filter is utilized to determine an asymmetric upper and lower bound to enclose the signal. Due to the smoothness of the resulting envelope, it is down-sampled from 500 to 40 samples. Note that the instantaneous amplitude ``a_x`` and the computed envelope ``x_env`` are not perfectly identical. This is due to the signal not being perfectly periodic as well as the existence of some spectral overlapping of ``x_carrier`` and ``x_drift``. Hence, they cannot be completely separated by a bandpass filter. >>> import matplotlib.pyplot as plt >>> import numpy as np >>> from scipy.signal.windows import gaussian >>> from scipy.signal import envelope ... >>> n, n_out = 500, 40 # number of signal samples and envelope samples >>> T = 2 / n # sampling interval for 2 s duration >>> t = np.arange(n) * T # time stamps >>> a_x = gaussian(len(t), 0.4/T) # instantaneous amplitude >>> phi_x = 30*np.pi*t + 35*np.cos(2*np.pi*0.25*t) # instantaneous phase >>> x_carrier = a_x * np.cos(phi_x) >>> x_drift = 0.3 * gaussian(len(t), 0.4/T) # drift >>> x = x_carrier + x_drift ... >>> bp_in = (int(4 * (n*T)), None) # 4 Hz highpass input filter >>> x_env, x_res = envelope(x, bp_in, n_out=n_out) >>> t_out = np.arange(n_out) * (n / n_out) * T ... >>> fg0, ax0 = plt.subplots(1, 1, tight_layout=True) >>> ax0.set_title(r"$4\,$Hz Highpass Envelope of Drifting Signal") >>> ax0.set(xlabel="Time in seconds", xlim=(0, n*T), ylabel="Amplitude") >>> ax0.plot(t, x, 'C0-', alpha=0.5, label="Signal") >>> ax0.plot(t, x_drift, 'C2--', alpha=0.25, label="Drift") >>> ax0.plot(t_out, x_res+x_env, 'C1.-', alpha=0.5, label="Envelope") >>> ax0.plot(t_out, x_res-x_env, 'C1.-', alpha=0.5, label=None) >>> ax0.grid(True) >>> ax0.legend() >>> plt.show() The second example provides a geometric envelope interpretation of complex-valued signals: The following two plots show the complex-valued signal as a blue 3d-trajectory and the envelope as an orange round tube with varying diameter, i.e., as :math:`|a(t)| \exp(j\rho(t))`, with :math:`\rho(t)\in[-\pi,\pi]`. Also, the projection into the 2d real and imaginary coordinate planes of trajectory and tube is depicted. Every point of the complex-valued signal touches the tube's surface. The left plot shows an analytic signal, i.e, the phase difference between imaginary and real part is always 90 degrees, resulting in a spiraling trajectory. It can be seen that in this case the real part has also the expected envelope, i.e., representing the absolute value of the instantaneous amplitude. The right plot shows the real part of that analytic signal being interpreted as a complex-vauled signal, i.e., having zero imaginary part. There the resulting envelope is not as smooth as in the analytic case and the instantaneous amplitude in the real plane is not recovered. If ``z_re`` had been passed as a real-valued signal, i.e., as ``z_re = z.real`` instead of ``z_re = z.real + 0j``, the result would have been identical to the left plot. The reason for this is that real-valued signals are interpreted as being the real part of a complex-valued analytic signal. >>> import matplotlib.pyplot as plt >>> import numpy as np >>> from scipy.signal.windows import gaussian >>> from scipy.signal import envelope ... >>> n, T = 1000, 1/1000 # number of samples and sampling interval >>> t = np.arange(n) * T # time stamps for 1 s duration >>> f_c = 3 # Carrier frequency for signal >>> z = gaussian(len(t), 0.3/T) * np.exp(2j*np.pi*f_c*t) # analytic signal >>> z_re = z.real + 0j # complex signal with zero imaginary part ... >>> e_a, e_r = (envelope(z_, (None, None), residual=None) for z_ in (z, z_re)) ... >>> # Generate grids to visualize envelopes as 2d and 3d surfaces: >>> E2d_t, E2_amp = np.meshgrid(t, [-1, 1]) >>> E2d_1 = np.ones_like(E2_amp) >>> E3d_t, E3d_phi = np.meshgrid(t, np.linspace(-np.pi, np.pi, 300)) >>> ma = 1.8 # maximum axis values in real and imaginary direction ... >>> fg0 = plt.figure(figsize=(6.2, 4.)) >>> ax00 = fg0.add_subplot(1, 2, 1, projection='3d') >>> ax01 = fg0.add_subplot(1, 2, 2, projection='3d', sharex=ax00, ... sharey=ax00, sharez=ax00) >>> ax00.set_title("Analytic Signal") >>> ax00.set(xlim=(0, 1), ylim=(-ma, ma), zlim=(-ma, ma)) >>> ax01.set_title("Real-valued Signal") >>> for z_, e_, ax_ in zip((z, z.real), (e_a, e_r), (ax00, ax01)): ... ax_.set(xlabel="Time $t$", ylabel="Real Amp. $x(t)$", ... zlabel="Imag. Amp. $y(t)$") ... ax_.plot(t, z_.real, 'C0-', zs=-ma, zdir='z', alpha=0.5, label="Real") ... ax_.plot_surface(E2d_t, e_*E2_amp, -ma*E2d_1, color='C1', alpha=0.25) ... ax_.plot(t, z_.imag, 'C0-', zs=+ma, zdir='y', alpha=0.5, label="Imag.") ... ax_.plot_surface(E2d_t, ma*E2d_1, e_*E2_amp, color='C1', alpha=0.25) ... ax_.plot(t, z_.real, z_.imag, 'C0-', label="Signal") ... ax_.plot_surface(E3d_t, e_*np.cos(E3d_phi), e_*np.sin(E3d_phi), ... color='C1', alpha=0.5, shade=True, label="Envelope") ... ax_.view_init(elev=22.7, azim=-114.3) >>> fg0.subplots_adjust(left=0.08, right=0.97, wspace=0.15) >>> plt.show() zInvalid parameter axis=z for z.shape=!rz"z.shape[axis] not > 0 for z.shape=z, axis=r?c3X# UH n[U[5=(d USLv M" g7frZ)rrO)r]b_s rRraenvelope.. s%!VPU":b##6#D"*#DPUs(*zbp_in=z2 isn't a 2-tuple of type (int | None, int | None)!Nzn_out=z# is not a positive integer or None!)rrhNz residual=z! not in ['lowpass', 'all', None]!rz9`-n//2 <= bp_in[0] < bp_in[1] <= (n+1)//2` does not hold zfor n=z.shape[axis]=z and bp_in=rr.)r$rrrrp)rrOrrgrhrrOrstartstoprtmoveaxisrrr zeros_likerfftr\rvrfftshiftrrimagirfftstack)rbp_inrrrrqr$fakbpZz_bbbp_shiftz_envz_ress rRr/r/ stVVGt $aff $3dWN!''1EFF GGDMA >aggZx$JKK 5zQc!VPU!VVVFE8#UVWW s # #E emFE8#FGHH//IH;&GHII  AAEE )C 58/uQxq!tW 8/uQxacAX ?B BERXX 3 3AaC!8 3T0!''$-!1uha@AB B AR A q JJqM MM!6;;qvvbqz#:#@#@ A"KKN#y1qy. 88a< c2gJ!OJ WWq[ c1RWW9n  "  HH #BGG #{{1S"W:/#5AqD"''AqD.9{{6??126sH}EORUU 'BFF4LTYY!^dii1n-LE KKr4 (E HH #BGG ##r' .2+#xx-!CN+9 77Q;)*Ac277AaCA:%% &8< 5Ac2889n qaQ1 n!45 booa.@.@6;;q*<<+ -E 88UBKKr489 BBrmc[R"U5n[R"[U55n[R"XS5U4$)aSort 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`. Examples -------- >>> from scipy import signal >>> vals = [1, 4, 1+1.j, 3] >>> p_sorted, indx = signal.cmplx_sort(vals) >>> p_sorted array([1.+0.j, 1.+1.j, 3.+0.j, 4.+0.j]) >>> indx array([0, 2, 3, 1]) r)rtruargsortrtake)rAindxs rR _cmplx_sortr s92 1 A ::c!f D 771A  $$rmcdUS;a[RnO9US;a[RnO"US;a[RnO [ S5e[R "U5n[R "[U5S45n[R"U5USS2S4'[R"U5USS2S4'[U5n/n/n[R"[U5[S 9n[[U55Hvn X(aMURXIU5n U V s/sHoU (aMU PM n n URU"X 55 UR[U 55 S X'Mx [R "U5[R "U54$s sn f) aDetermine 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 in terms of the distance between them. Default is 1e-3. Refer to Notes about the details on roots grouping. rtype : {'max', 'maximum', 'min', 'minimum', 'avg', 'mean'}, optional How to determine the returned root if multiple roots are within `tol` of each other. - 'max', 'maximum': pick the maximum of those roots - 'min', 'minimum': pick the minimum of those roots - 'avg', 'mean': take the average of those roots When finding minimum or maximum among complex roots they are compared first by the real part and then by the imaginary part. Returns ------- unique : ndarray The list of unique roots. multiplicity : ndarray The multiplicity of each root. Notes ----- If we have 3 roots ``a``, ``b`` and ``c``, such that ``a`` is close to ``b`` and ``b`` is close to ``c`` (distance is less than `tol`), then it doesn't necessarily mean that ``a`` is close to ``c``. It means that roots grouping is not unique. In this function we use "greedy" grouping going through the roots in the order they are given in the input `p`. 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]) rmaximumrminimumavgrsJ`rtype` must be one of {'max', 'maximum', 'min', 'minimum', 'avg', 'mean'}r?NrrrT)rtrrrsrOrurrgrrrrboolrfquery_ball_pointr) rAtolrtypereducepointstreep_uniquep_multiplicityusedr^groupr,s rRr0r0 s[h "" $ $ / !OP P 1 A XXs1vqk "F771:F1a4L771:F1a4L 6?DHN 88CF$ 'D 3q6] 7 %%fi5!1EqaE1qx()c%j)  ::h N!; ;;2s - F->F-c[R"U5n[R"U5n[R"[R"U5S5n[XU5upV[ XVSS9upx[ U5S:XaSn O[R "X(5n [X5Hup[R"XU -5n M X4$)aCompute 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 corresponding to the poles. For repeated poles, the residues must be ordered to correspond to ascending by power fractions. p : array_like Poles. Equal poles must be adjacent. k : array_like Coefficients of the direct polynomial term. tol : float, optional The tolerance for two roots to be considered equal in terms of the distance between them. Default is 1e-3. See `unique_roots` for further details. rtype : {'avg', 'min', 'max'}, optional Method for computing a root to represent a group of identical roots. Default is 'avg'. See `unique_roots` for further details. Returns ------- b : ndarray Numerator polynomial coefficients. a : ndarray Denominator polynomial coefficients. See Also -------- residue, invresz, unique_roots fTinclude_powersr rtrl trim_zeros _group_poles_compute_factorsrgpolymulrpolyadd rDrArrr unique_poles multiplicityfactors denominator numeratorr3factors rRr1r1H sp aA aA bmmA&,A!-ae!<L+L;?AG 1v{ JJq. q?JJyF*:; +  !!rmc[R"S/5nU/n[USSS2USSS25HWupV[R"SU*/5n[U5Hn[R"X75nM UR U5 MY USSS2n/n [R"S/5n[XU5HupVn [R"SU*/5n/n [U5HKn U S:XdU(a%U R [R"X:55 [R"X75nMM U R [U 55 M X4$)z>Compute the total polynomial divided by factors for each root.rrrN)rtrrrfrrextendreversed) rootsrrcurrentsuffixespolemultmonomialrrsuffixblockr^s rRrr s'hhsmGyH%1R.,r!Bw*?@ 88QJ'tAjj3G A "~HGhhsmG!%x@F88QJ'tAAv RZZ89jj3G x'A  rmc[X5up4URUR5n/n[XU5GHupgnUS:Xa>UR [ R "X&5[ R "X5- 5 MKUR5n [ R"SU*/5n [ R"X5up/n [U5HPn[ R"X5upU SU S- n[ R"XU-5n U R U5 MR UR[U 55 GM [ R"U5$)Nrr)rr_rvrrrtpolyvalrrpolydivrfpolysubrrru)polesrrdenominator_factorsrresiduesrrrnumerrdr r$rDs rR_compute_residuesr s-eB  -IH!%"57F 19 OOBJJy7JJv45 6NN$ExxTE +H 64IFE4[::e6aD1Q4K 5f*5 Q ! OOHUO ,#7& ::h rmc[R"U5n[R"U5n[R"UR[R5(d4[R"UR[R5(a+UR [ 5nUR [ 5nO*UR [5nUR [5n[R"[R"U5S5n[R"[R"U5S5nURS:Xa [S5e[R"U5nURS:XaC[R"UR5[U5S[R "/54$[#U5[#U5:a[R$"S5nO[R&"X5upP[)XBUS9upg[U5uphXxn[+XgU5n Sn [-Xg5HupXXU -&X- n M XS- XE4$)aj 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`. See Notes for details about the algorithm. Parameters ---------- b : array_like Numerator polynomial coefficients. a : array_like Denominator polynomial coefficients. tol : float, optional The tolerance for two roots to be considered equal in terms of the distance between them. Default is 1e-3. See `unique_roots` for further details. rtype : {'avg', 'min', 'max'}, optional Method for computing a root to represent a group of identical roots. Default is 'avg'. See `unique_roots` for further details. Returns ------- r : ndarray Residues corresponding to the poles. For repeated poles, the residues are ordered to correspond to ascending by power fractions. p : ndarray Poles ordered by magnitude in ascending order. k : ndarray Coefficients of the direct polynomial term. See Also -------- invres, residuez, numpy.poly, unique_roots Notes ----- The "deflation through subtraction" algorithm is used for computations --- method 6 in [1]_. The form of partial fraction expansion depends on poles multiplicity in the exact mathematical sense. However there is no way to exactly determine multiplicity of roots of a polynomial in numerical computing. Thus you should think of the result of `residue` with given `tol` as partial fraction expansion computed for the denominator composed of the computed poles with empirically determined multiplicity. The choice of `tol` can drastically change the result if there are close poles. References ---------- .. [1] J. F. Mahoney, B. D. Sivazlian, "Partial fractions expansion: a review of computational methodology and efficiency", Journal of Computational and Applied Mathematics, Vol. 9, 1983. rrDenominator `a` is zero.rr)rtrurwrvcomplexfloatingr_complexrLrrlrrOrrrrrrgrr r0rr) rMrrrrrrrorderrindexrrs rRr3r3 sX 1 A 1 A aggr1122}}QWWb&8&899 HHW  HHW  HHUO HHUO bmmA&,A bmmA&,Avv{344 HHQKEvv{xx $k%&8&;RXXb\II 1vA HHQKzz!!-eE!JL%l3L&L Q?H E,5 $(eDL! 6 d?E $$rmc[R"U5n[R"U5n[R"UR[R5(d4[R"UR[R5(a+UR [ 5nUR [ 5nO*UR [5nUR [5n[R"[R"U5S5n[R"[R"U5S5nURS:Xa [S5eUSS:Xa [S5e[R"U5nURS:XaC[R"UR5[U5S[R "/54$USSS2nUSSS2n[#U5[#U5:a[R$"S5nO[R&"XV5upu[)XBUS9up[U5upXn [+SU- X5n Sn [R$"[#U 5[,S 9n [/X5H,upXXU-&S[R0"U5-XX-&X- n M. X*U -US- -n XUSSS24$) aFCompute 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`. See Notes of `residue` for details about the algorithm. Parameters ---------- b : array_like Numerator polynomial coefficients. a : array_like Denominator polynomial coefficients. tol : float, optional The tolerance for two roots to be considered equal in terms of the distance between them. Default is 1e-3. See `unique_roots` for further details. rtype : {'avg', 'min', 'max'}, optional Method for computing a root to represent a group of identical roots. Default is 'avg'. See `unique_roots` for further details. Returns ------- r : ndarray Residues corresponding to the poles. For repeated poles, the residues are ordered to correspond to ascending by power fractions. p : ndarray Poles ordered by magnitude in ascending order. k : ndarray Coefficients of the direct polynomial term. See Also -------- invresz, residue, unique_roots rMrrz6First coefficient of determinant `a` must be non-zero.Nrrrr)rtrurwrvrr_rrLrrlrrOrrrrrrgrr r0rrOrr)rMrrrrb_reva_revk_revrrrrrpowersrrs rRr4r4: s6p 1 A 1 A aggr1122}}QWWb&8&899 HHW  HHW  HHUO HHUO bmmA&,A bmmA&,Avv{344 1%& & HHQKEvv{xx $k%&8&;RXXb\II ddGE ddGE 5zCJ zz%/ !-eE!JL%l3L&L \!1<GH E XXc(m3 /F,5 $(eDL!%&4%8U\" 6  F"U1X--H E$B$K ''rmcjUS;a[RnO9US;a[RnO"US;a[RnO [ S5e/n/nUSnU/n[ S[ U55Hbn[XU- 5U::aURU5 M*URU"U55 UR[ U55 XnU/nMd URU"U55 UR[ U55 [R"U5[R"U54$)Nrrrrrr) rtrrrsrOrfrgrrru) rrrruniquerrr r^s rRrr s  "" $ $ / !OP PFL 8D FE 1c%j ! ux$ 3 & LL  MM&- (   E +8DFE" MM&- E # ::f rzz,7 77rmc [R"U5n[R"U5n[R"[R"U5S5n[XU5upV[ XVSS9upx[ U5S:XaSn O#[R "USSS2USSS25n [X5H$up[R"XU SSS2-5n M& U SSS2U4$)aCompute 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 corresponding to the poles. For repeated poles, the residues must be ordered to correspond to ascending by power fractions. p : array_like Poles. Equal poles must be adjacent. k : array_like Coefficients of the direct polynomial term. tol : float, optional The tolerance for two roots to be considered equal in terms of the distance between them. Default is 1e-3. See `unique_roots` for further details. rtype : {'avg', 'min', 'max'}, optional Method for computing a root to represent a group of identical roots. Default is 'avg'. See `unique_roots` for further details. Returns ------- b : ndarray Numerator polynomial coefficients. a : ndarray Denominator polynomial coefficients. See Also -------- residuez, unique_roots, invres rMTrrNrrrs rRr2r2 sn aA aA bmmA&,A!-ae!<L+L;?AG 1v{ JJq2w DbD(9: q?JJyF4R4L*@A + TrT?K ''rmcUS;a[SU35e[R"U5nURUn[R"U5nUS:Xa1U(a[ R "XS9nO[ R"XS9nOUnUGb[U5(aU"[ R"U55n O][U[R5(aURU4:wa [S5eUn O[ R"[XF55n S/UR-n URUX'U(aKU R5n U SS===U SS S2- sss&U SS===S -sss&XSXR!U 5-nOXR!U 5-n[#UR5n U(a US -S-X'OXU'[R$"XR&5n [)X5nUS -S-n[+S5/UR-n[+S U5UU'U[-U5U [-U5'U(d1US :a+[+X- S5UU'U[-U5U [-U5'US -S :XaX:asU(a/[+US -US -S-5UU'U [-U5==S -ss'O[+U*S -U*S -S-5UU'U [-U5==U[-U5- ss'OrXa:am[+US -US -S-5UU'U [-U5==S -ss'U(d8U [-U5n[+XS -- XS -- S-5UU'UU [-U5'U(a[ R."XUS9nO[ R0"XS S9nU[3U5[3U5- -nUcU$[R4"S U5USUS - -U-[3U5- US -nUU4$)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 equally spaced 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. domain : string, optional A string indicating the domain of the input `x`: ``time`` Consider the input `x` as time-domain (Default), ``freq`` Consider the input `x` as frequency-domain. 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 is used solely to calculate the resampled positions `resampled_t` As noted, `resample` uses FFT transformations, which can be very slow if the number of input or output samples is large and prime; see :func:`~scipy.fft.fft`. In such cases, it can be faster to first downsample a signal of length ``n`` with :func:`~scipy.signal.resample_poly` by a factor of ``n//num`` before using `resample`. Note that this approach changes the characteristics of the antialiasing filter. Examples -------- Note that the end of the resampled data rises to meet the first sample of the next cycle: >>> import numpy as np >>> 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() Consider the following signal ``y`` where ``len(y)`` is a large prime number: >>> N = 55949 >>> freq = 100 >>> x = np.linspace(0, 1, N) >>> y = np.cos(2 * np.pi * freq * x) Due to ``N`` being prime, >>> num = 5000 >>> f = signal.resample(signal.resample_poly(y, 1, N // num), num) runs significantly faster than >>> f = signal.resample(y, num) )timefreqz9Acceptable domain flags are 'time' or 'freq', not domain=r%rpNz(window must have the same length as datarrrg?r?g@T)rq overwrite_x)rOrtrur isrealobjrrrcallablefftfreqrr ifftshiftrrrrrrrvrrrrrrLr)r,rtrqwindowrcNx real_inputXW newshape_WW_realrYr(nyqsltemprnew_ts rRr5r5 sR%%006x9: : 1 A BaJ   A)A 1(A  F  v~~b)*A  + +||u$ !KLLA  F!78AS166\ 774=  VVXF 12J&Ab/ )J 12J# J ))*22:> >A :& &AAGG}HA 77#A C A q&1*C + BQ}BtHU2Y>> import numpy as np >>> from scipy import signal >>> import matplotlib.pyplot as plt >>> 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) >>> 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() This default behaviour can be changed by using the padtype option: >>> N = 5 >>> x = np.linspace(0, 1, N, endpoint=False) >>> y = 2 + x**2 - 1.7*np.sin(x) + .2*np.cos(11*x) >>> y2 = 1 + x**3 + 0.1*np.sin(x) + .1*np.cos(11*x) >>> Y = np.stack([y, y2], axis=-1) >>> up = 4 >>> xr = np.linspace(0, 1, N*up, endpoint=False) >>> y2 = signal.resample_poly(Y, up, 1, padtype='constant') >>> y3 = signal.resample_poly(Y, up, 1, padtype='mean') >>> y4 = signal.resample_poly(Y, up, 1, padtype='line') >>> for i in [0,1]: ... plt.figure() ... plt.plot(xr, y4[:,i], 'g.', label='line') ... plt.plot(xr, y3[:,i], 'y.', label='mean') ... plt.plot(xr, y2[:,i], 'r.', label='constant') ... plt.plot(x, Y[:,i], 'k-') ... plt.legend() >>> plt.show() zup must be an integerzdown must be an integerrzup and down must be >= 1Nrz#cval has no effect when padtype is zwindow must be 1-Dr??r:r-rr)rsmedianrr)rPcvalT)rqkeepdimsrPr=z8padtype must be one of: maximum, mean, median, minimum, z, rq)#rtrurOrOrgcdrrrrrrrrrrrwrvrrr_floatingr rg concatenaterrsr<aminamaxr joinr rr)r,updownrqr-padtyper=g_n_inrhalf_lenr-max_ratef_c n_pre_pad n_post_pad n_pre_removen_pre_remove_endfuncsupfirdn_kwargsbackground_valuesrkeepy_keeps rRr6r6 sx 1 A SW}011 s4y233 RB t9D Av344 Gz1>HH " BIBKD Qvvx 774=D IE MD. .E&4"**,..&! ;;?12 2KK!O) r=8m= ==""4"4 5 5q8|a'$&&,fQWWo  ]]177BKK 0 0q8|a'$&&,fQWWo q8|a'$&AGA4'IJ(T1L c!fy(:5t "',"6 7a  c!fy(:5t "',"6 7 '':A77;= >A#e+WW BGG 5E(!4N%!'N1$G N " '* j |%)N6 " F IIn % &' '% ! ! br>s ^ZZ F ZZ F {{QDEE {{QDEE{{?L ]]6 "F ]]6 "F! 344ffRVVBruuHVXX-v67Gq)J:H HHZ EA;a ?rmc US;a [S5e[R"U5nURRnUS;aSnUS;aU[R "XSS9- nU$UR nXqn[R"[R"[R"[R"SX85555n[R"X8:5(a [S 5e[U5n US:aX-n[R"XS5n U R n U RUS 5n U(dU R5n U RRS;aU R!U5n [#[U5S - 5Hn X>> import matplotlib.pyplot as plt >>> import numpy as np >>> from scipy.signal import detrend ... >>> t = np.linspace(-0.5, 0.5, 21) >>> x = np.sin(np.pi*t) + 1/4 ... >>> x_d_const = detrend(x, type='constant') >>> x_d_linear = detrend(x, type='linear') ... >>> fig1, ax1 = plt.subplots() >>> ax1.set_title(r"Detrending $x(t)=\sin(\pi t) + 1/4$") >>> ax1.set(xlabel="t", ylabel="$x(t)$", xlim=(t[0], t[-1])) >>> ax1.axhline(y=0, color='black', linewidth=.5) >>> ax1.axvline(x=0, color='black', linewidth=.5) >>> ax1.plot(t, x, 'C0.-', label="No detrending") >>> ax1.plot(t, x_d_const, 'C1x-', label="type='constant'") >>> ax1.plot(t, x_d_linear, 'C2+-', label="type='linear'") >>> ax1.legend() >>> plt.show() Alternatively, NumPy's `~numpy.polynomial.polynomial.Polynomial` can be used for detrending as well: >>> pp0 = np.polynomial.Polynomial.fit(t, x, deg=0) # fit degree 0 polynomial >>> np.allclose(x_d_const, x - pp0(t)) # compare with constant detrend True >>> pp1 = np.polynomial.Polynomial.fit(t, x, deg=1) # fit degree 1 polynomial >>> np.allclose(x_d_linear, x - pp1(t)) # compare with linear detrend True Note that `~numpy.polynomial.polynomial.Polynomial` also allows fitting higher degree polynomials. Consult its documentation on how to extract the polynomial coefficients. )linearlrrz*Trend type must be 'linear' or 'constant'.dfDFr)rrT)r>rz>Breakpoints must be less than length of data along given axis.rrr?rN)rOrtrurvrrsrrr"rArlrNrgrrrr_rfrrrrrlstsq)datarqrroverwrite_datarvrdshaper(rnknewdata newdata_shaperNptsAr6coefresidsrdrjs rRr7r7s` 33EFF ::d D JJOOE F   RWWT$77  L WWRYYr~~bmmAr.EFG H 66"&>>9: : &k !8:D++d!, //!R(llnG ==  V +nnU+Gs2w{#A!e9ru$Dq 5)Aii4!859D@AadGrubQi(B$*LLBK$@ !D&$!+D0GK $//-0kk'1d+ rmc[R"U5nURS:wa [S5e[R"U5nURS:wa [S5e[ U5S:a(USS:XaUSSn[ U5S:a USS:XaMUR S:a [S5eUSS:waXS- nXS- n[ [ U5[ U55n[ U5U:a?[RU[R"U[ U5- URS 94nOM[ U5U:a>[RU[R"U[ U5- URS 94n[R"US- [R"X5S 9[R"U5R- nUSSUSSUS-- n[RRX45nU$) an Construct initial conditions for lfilter for step response steady-state. 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. rzNumerator b must be 1-D.zDenominator a must be 1-D.rgNz3There must be at least one nonzero `a` coefficient.r:r)rtrlrrOrgrrrrrveyerYr companionrZsolve)rMrr$IminusABrs rRr8r8sv aAvv{344 aAvv{566 a&1*1 abE a&1*1vvzNOOts{ !H !H CFCFA 1vz EE!RXXa#a&j88 9 Q! EE!RXXa#a&j88 9ffQU".."67&:J:J1:M:O:OOG !"!"! A  $B Irmc[R"U5nURS:wdURSS:wa [ S5eUR R S;aUR[R5nURSn[R"US4UR S9nSn[U5HFnXS S 24nXS S 24nU[XV5-X$'X5R5UR5- -nMH U$) ai Construct initial conditions for sosfilt for step response steady-state. 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`. >>> import numpy as np >>> 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() r?rz!sos must be shape (n_sections, 6)rrrr:Nrp) rtrurrrOrvrr_r|rrfr8r)sos n_sectionsrscalesectionrMrs rRr9r9sl **S/C xx1} ! )<== yy~~jj$1J :q/ 3B E$ !   j..  1557""% Irmc [R"U5n[R"U5n[[U5[U55S- nUS:Xa?USUS- S-nXb-nU[R"/5[R"/54$US:wdX2R S- :wa$[R "X#UR S- 5nURSnUb USU-::aUn OUn [R"X45n [R"U5n SU S'[X[R"U 5U S9SU SS2S4'[SU5Hn U SU *2S4XS2U 4'M U SSS2n [XU SSS2SS9nUSSS2nX:Xa[R"X- X- 45nO8[R"SU -SU-45nX- USU 2SU24'X- UU S2US24'[XU5n[XUSSSS245SSSS24n[XUSSSS245SSSS24n[XU5nUU- nX:XaUnO*USSU 24nUSU *S24n[R"UU4SS9nUR S:Xa[R"UU5SnO|URSURS5R n[R"UU5SR nURURSSURS4-5nX:Xa[R"X45nO4[R"SU -SU-45nUUSU 2SU24'U UU S2US24'UR#UR 5nUnX:XaUU- nO2USSU 24==USSU 24- ss'USU *S24==USU *S24- ss'USSU24nUSU*S24n US:wdX2R S- :wal[R "UX2R S- 5n[R "U X2R S- 5n [R "UX2R S- 5nUUU 4$) aForward-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. rrr?rN)rrp.)rtrlrrgrrswapaxesrrr)rfhstackrArrgrrZrX)!rMrr,rqirlenrr|rr$rObsrrObsrSSrry_fy_fby_by_bf delta_y_bf_fbdeltastart_mend_mic_optdelta2dic_opt0r1wicy_optx0x1s! rR_filtfilt_gustrSscb aA aA AA ! #E z1!q  I"((2, ,, rzTVVaZ' KK! ,  A }QuW   ((A: C %B BqEbhhqkb1!4C1I 1e_1"a[BE  tt9D c$B$ia(A 4R4B v IIrx* + HHac1U7^ $"1"fuf* !"ef* ! C 1S$B$Y (dd 3D !#tt) %c4R4i 0C 1 D4KMvRaR(cA23h'/b9  zzQa'*--EKKO466,,q'*1-//Sb!1QWWR[N!BC v IIrj ! HHac1U7^ $"1"fuf* !"ef*  **QSS/C Ev   c2A2g#c2A2g,& cA23h3sQBCx=( VeV B eVW B rzTVVaZ' [[T66A: . [[T66A: . E4!4 "b=rmc Z[R"U5n[R"U5n[R"U5nUS;a [S5eUS:Xa[ XX#US9upn U$[ XEX#[ [U5[U55S9up[X5n S/UR-nU RX'[R"X5n [U SUS9n[XXX-S9unn[US US 9n[X[XS 9X=U-S9unn[XS 9nU S :a [XU *US 9nU$)a7 Apply a digital filter forward and backward to a signal. This function applies a linear digital filter twice, once forward and once backwards. The combined filter has zero phase and a filter order twice that of the original. The function provides options for handling the edges of the signal. The function `sosfiltfilt` (and filter design using ``output='sos'``) should be preferred over `filtfilt` for most filtering tasks, as second-order sections have fewer numerical problems. 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 ----- 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. 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`. >>> import numpy as np >>> 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 frequency, 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. `sig` is a random input signal to be filtered. >>> rng = np.random.default_rng() >>> n = 60 >>> sig = rng.standard_normal(n)**3 + 3*rng.standard_normal(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 = rng.standard_normal(4000) >>> 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))) 2.875334415008979e-10 )rEgustzmethod must be 'pad' or 'gust'.r)rqrntapsrrrqrqrrrrqrprrrrq)rtrlrurOr _validate_padrrgr8rrrrr)r)rMrr,rqrGpadlenrrrz1z2edgeextrzi_shaperry0s rRr<r<s2| aA aA 1 A _$:;; "1UC rgq$'AA$79ID A B sQVV|HWWHN B !B Cad +BaCrw7GQ ARd +BaL6T2gNGQ Q"A ax qD5t < HrmcUS;a[SUS35eUcSnUcUS-nOUnURUU::a[SU-5eUb:US:a4US:Xa [X%US9nXV4$US :Xa [X%US9nXV4$[ X%US9nXV4$UnXV4$) z'Helper to validate padding for filtfilt)evenoddrNzUnknown value 'zG' given to padtype. padtype must be 'even', 'odd', 'constant', or None.rrpzJThe length of the input vector x must be greater than padlen, which is %d.rrpr)rOrrrr)rGrr,rqrrrs rRrrs77?7)4OOP P ~qy wwt}57;<= =tax f 1.C 9  !-C 9A$/C 9 9rmch[R"U5nURS:Xa [S5eU$)Nrzx must be at least 1-D)rtrurrO)r,s rRrrs+ 1 Avv{122 Hrmc[US5 [US5 Ub [US5 [U5n[U5up[UR5nSXR'[ U/U-5nX/nUb%UR [R"U55 [R"U6nURS;a[SUS35eUbN[R"X75nURU:wa%[SX!RXEUR4-5eSnO[R"XWS9nS nX!R-n[R "XS 5n[R "US US -/S S /5nURURp[R""US URS 45n[R"XSS9n[R$"[R""US US455nUR'US S9n[)XU5 Xl[R "US U5nU(a*Xl[R "US S /S US -/5nX4n U $Un U $)a Filter data along one dimension using cascaded second-order sections. Filter a data sequence, `x`, using a digital IIR filter defined by `sos`. 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, freqz_sos 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 = 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() r+r?rrrzyInvalid zi shape. With axis=%r, an input with shape %r, and an sos array with %d sections, zi must have shape %r, got %r.TrFrrrC)r)r)rrrrrrrrtrurYrrrrOrrrrascontiguousarrayr_r) rzr,rqrr{ x_zi_shaperrv return_zir"rrs rRr+r+s"LC#Ay! ~I&AA#C(OCaggJJ |j01JXF ~ bjjn% NNF #E zz"!L"GHH ~ XXb  88z !;#GGZRXXNOP P XXj . &&=D AR A R!TAXR 1BX 1r1772;'(A %A  bjjb*a-@A BB **U* 'C SRG Ar4 A [[b"X4!8} 5g J Jrmc[U5up[U5nSU-S-nU[USS2S4S:HR5USS2S4S:HR55-n[ X4XUS9upx[ U5n S/UR -n SX'U/U -U l[USUS9n [XX)U -S9up[U S US 9n[U[XS 9X)U-S9up[XS 9n US:a [XU*US 9n U $) a A forward-backward digital 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, freqz_sos Notes ----- .. versionadded:: 0.18.0 Examples -------- >>> import numpy as np >>> from scipy.signal import sosfiltfilt, butter >>> import matplotlib.pyplot as plt >>> rng = np.random.default_rng() Create an interesting signal to filter. >>> n = 201 >>> t = np.linspace(0, 1, n) >>> x = 1 + (t < 0.5) - 0.25*t**2 + 0.05*rng.standard_normal(n) Create a lowpass Butterworth filter, and use it to filter `x`. >>> sos = butter(4, 0.125, output='sos') >>> y = sosfiltfilt(sos, x) For comparison, apply an 8th order filter using `sosfilt`. The filter is initialized using the mean of the first four values of `x`. >>> from scipy.signal import sosfilt, sosfilt_zi >>> sos8 = butter(8, 0.125, output='sos') >>> zi = x[:4].mean() * sosfilt_zi(sos8) >>> y2, zo = sosfilt(sos8, x, zi=zi) Plot the results. Note that the phase of `y` matches the input, while `y2` has a significant phase delay. >>> plt.plot(t, x, alpha=0.5, label='x(t)') >>> plt.plot(t, y, label='y(t)') >>> plt.plot(t, y2, label='y2(t)') >>> plt.legend(framealpha=1, shadow=True) >>> plt.grid(alpha=0.25) >>> plt.xlabel('t') >>> plt.show() r?rNrrrrrrrpr) rrrrrr9rrrr+r)rzr,rqrGrr{rrrrrx_0rry_0s rRr:r:nsr$C(OCAA  NQ E S#ad)q.%%'#ad)q.)=)=)? @@Egq$)+ID CBsQVV|HHN|h&BH Sqt ,CcT3h7GQ Qbt ,Cc<5D#XNGQQ"A ax qD5t < Hrmc[R"U5n[R"U5nUb[R"U5nURn[R "U[R 5(aUR[R:Xa[RnUS:XaIUc SU-nSU-n[US-SU- SS9Sp[R"XS 9n[R"XS 9n GOUS :Xa,S n UcS n[US SU- SS9n [R"XS 9n GOe[U[5(GaDUR5n U RR SS:Xa*UR#5n U R$U R&pSnO[)[R*"U R55(dS[)[R*"U R55(d%[R*"U R,5(a*Sn UR#5n U R$U R&pOMS n [/U R0U RU R,5n [R"XS 9n O [3S5e[5S5/UR6-n US:XabWW - nU(a [9USXUS9nOUR UU-[;UR UU-5-n[=XSXS9n[5SUS5X'OQU(aW (a [?W XS9nO)[AWW XS9nOW (a [CW XS9nO [EWW XS9n[5SSU5X'U[GU 5$)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 : array_like The signal to be downsampled, as an N-dimensional array. q : int The downsampling factor. When using IIR downsampling, it is recommended to call `decimate` multiple times for downsampling factors higher than 13. n : int, optional The order of the filter (1 less than the length for 'fir'). Defaults to 8 for 'iir' and 20 times the downsampling factor 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. The default value of ``True`` is recommended, since a phase shift is generally not desired. .. 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. Examples -------- >>> import numpy as np >>> from scipy import signal >>> import matplotlib.pyplot as plt Define wave parameters. >>> wave_duration = 3 >>> sample_rate = 100 >>> freq = 2 >>> q = 5 Calculate number of samples. >>> samples = wave_duration*sample_rate >>> samples_decimated = int(samples/q) Create cosine wave. >>> x = np.linspace(0, wave_duration, samples, endpoint=False) >>> y = np.cos(x*np.pi*freq*2) Decimate cosine wave. >>> ydem = signal.decimate(y, q) >>> xnew = np.linspace(0, wave_duration, samples_decimated, endpoint=False) Plot original and decimated waves. >>> plt.plot(x, y, '.-', xnew, ydem, 'o-') >>> plt.xlabel('Time, Seconds') >>> plt.legend(['data', 'decimated'], loc='best') >>> plt.show() Nfirr:r?rr:hammingr;riirTg?g?rz)outputrFz invalid ftype)rqr-)rErFrqrp)$rtruoperatorrrvrwinexactrrzr|rrrr _as_zpkrr_as_tfrrrN iscomplexgainrrrOrrr6rr r:r<r+r)r)r,qr$ftyperq zero_phaserYrJrMr iir_use_sosrzsystemr6rrs rRr=r=sj 1 AqA} NN1 ''K ==bjj 1 1   bjj (jj  ~ 9AvHH Aac26)4b1 JJq , JJq , % 9AQcAge4jj0 E4  <<  a A %\\^F::vzzqE",,v||,--R\\&,,/00fkk**K\\^F::vzzqK&,, fkkBC**S4C)) + B ~ E aA;AGGDMQ&aggdma.?)@@E6AT5$/BH Q2Q10C.Aq!/tQ' U2Y<rmrZ)rBr)rB)F)rBN)buifc)passrrp)rBF)NN)rBrDr)rpr)Nr)r)r np.ndarrayrztuple[int | None, int | None]rz int | NonerrrzLiteral['lowpass', 'all', None]rqrOreturnr)MbP?r)rr)NrNr%)r)kaiserg@rN)rrdrF) rhrrqrOrzLiteral['linear', 'constant']rzArrayLike | intrirrr)rrNrEN)rrN)NrrT)j __future__rrrrr r;rtypingr numpy._typingr scipy.spatialrr _ltisysr _upfirdnr r r scipyrrrrscipy.fft._helperrnumpyrt scipy.specialrwindowsr _arraytoolsrrrrr_filter_designrrr_fir_filter_designrr__all__rMrUrSrWrlrrrrrrrr#rr$rr*r3rrrFr;r!r%r&r(r"r r'r)r*r,r-r.r/rr0r1rrr3r4rr2r5r6r>r7r8r9rr<rrr+r:r=r[rmrRrsh#  #!::'5"OO::& 5A . 1aQA/ 7MD F G1T`F:z9x#/Ls5ll3^M5`*(V'>T" FK\J1ZBJAHHVWtcLi4XE?PK\9xs l7 tSC!%u9BSCSC04SC6SCSC!+SCj%G(TL^/>+/TnK\+-2: