`iddlZddlZddlmZddlmZddlmcmZ ddl m Z ddl m Z ddl mZddlmZmZmZmZmZmZddlmZmZmZmZd0d Zd0d Zd1dZd2dZd3dZ d2dZ!d4dZ"d4dZ#d5dZ$d3dZ%d6dZ&dZ'd7dZ(d8dZ)d9dZ*d7dZ+dZ,d:d!Z-d9d"Z.d#Z/ d;d&Z0d'Z1d(Z2d)Z3d*Z4d9d+Z5d,Z6dN)internal)lstsq)_util)_filters)_signaltools_core) const_exteven_extodd_ext axis_reverse axis_slice axis_assign) apply_iir apply_iir_soscompute_correction_factorscompute_correction_factors_sosfullautoc(t||||dS)aConvolve two N-dimensional arrays. Convolve ``in1`` and ``in2``, with the output size determined by the ``mode`` argument. Args: in1 (cupy.ndarray): First input. in2 (cupy.ndarray): Second input. Should have the same number of dimensions as `in1`. mode (str): Indicates the size of the output: - ``'full'``: output is the full discrete linear convolution (default) - ``'valid'``: output consists only of those elements that do not rely on the zero-padding. Either ``in1`` or ``in2`` must be at least as large as the other in every dimension. - ``'same'``: - output is the same size as ``in1``, centered with respect to the ``'full'`` output method (str): Indicates which method to use for the computations: - ``'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 choose direct of FFT based on an estimate of which is faster for the arguments (default). Returns: cupy.ndarray: the result of convolution. .. seealso:: :func:`cupyx.scipy.signal.choose_conv_method` .. seealso:: :func:`cupyx.scipy.signal.correlation` .. seealso:: :func:`cupyx.scipy.signal.fftconvolve` .. seealso:: :func:`cupyx.scipy.signal.oaconvolve` .. seealso:: :func:`cupyx.scipy.ndimage.convolve` .. seealso:: :func:`scipy.signal.convolve` .. note:: By default, ``convolve`` and ``correlate`` use ``method='auto'``, which calls ``choose_conv_method`` to choose the fastest method using pre-computed values. CuPy may not choose the same method to compute the convolution as SciPy does given the same inputs. T _correlatein1in2modemethods s/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/scipy/signal/_signaltools.pyconvolversX c3fd 3 33c(t||||dS)aCross-correlate two N-dimensional arrays. Cross-correlate ``in1`` and ``in2``, with the output size determined by the ``mode`` argument. Args: in1 (cupy.ndarray): First input. in2 (cupy.ndarray): Second input. Should have the same number of dimensions as ``in1``. mode (str): Indicates the size of the output: - ``'full'``: output is the full discrete linear convolution (default) - ``'valid'``: output consists only of those elements that do not rely on the zero-padding. Either ``in1`` or ``in2`` must be at least as large as the other in every dimension. - ``'same'``: - output is the same size as ``in1``, centered with respect to the ``'full'`` output method (str): Indicates which method to use for the computations: - ``'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 choose direct of FFT based on an estimate of which is faster for the arguments (default). Returns: cupy.ndarray: the result of correlation. .. seealso:: :func:`cupyx.scipy.signal.choose_conv_method` .. seealso:: :func:`cupyx.scipy.signal.convolve` .. seealso:: :func:`cupyx.scipy.signal.fftconvolve` .. seealso:: :func:`cupyx.scipy.signal.oaconvolve` .. seealso:: :func:`cupyx.scipy.ndimage.correlation` .. seealso:: :func:`scipy.signal.correlation` .. note:: By default, ``convolve`` and ``correlate`` use ``method='auto'``, which calls ``choose_conv_method`` to choose the fastest method using pre-computed values. CuPy may not choose the same method to compute the convolution as SciPy does given the same inputs. Frrs r correlater AsX c3fe 4 44rFc(tj||||}||S|dvrtd|dkrt|||}|dkrtj||||j|S|s&tj|}tj||j |j }|r||}}t|||}tj ||}|j dvr|}||d}|S) N)rdirectfftz1acceptable methods are "auto", "direct", or "fft"rrr"uiFcopy)_st_core_check_conv_inputs ValueErrorchoose_conv_method_direct_correlatedtype_reverseconj_inputs_swap_neededshape fftconvolvecupy result_typekindroundastype) rrrr convolution quick_outinputs_swappedoutr4s rrrps2+CdKHHI ...LMMM #C4888 )#sD#)*577 7 ,$$))++1$ 39MMNS c3 % %C"3,,K4iikk **[u* - -C JrcLtj|||}||Stj|||d\}}fdtt |j|jD}tj|||d}tj||j|j|S)aConvolve 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 the ``'direct'`` method of ``convolve`` for large arrays, 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). Args: in1 (cupy.ndarray): First input. in2 (cupy.ndarray): Second input. Should have the same number of dimensions as ``in1``. mode (str): Indicates the size of the output: - ``'full'``: output is the full discrete linear cross-correlation (default) - ``'valid'``: output consists only of those elements that do not rely on the zero-padding. Either ``in1`` or ``in2`` must be at least as large as the other in every dimension. - ``'same'``: output is the same size as ``in1``, centered with respect to the 'full' output axes (scalar or tuple of scalar or None): Axes over which to compute the convolution. The default is over all axes. Returns: cupy.ndarray: the result of convolution .. seealso:: :func:`cupyx.scipy.signal.choose_conv_method` .. seealso:: :func:`cupyx.scipy.signal.correlation` .. seealso:: :func:`cupyx.scipy.signal.convolve` .. seealso:: :func:`cupyx.scipy.signal.oaconvolve` .. seealso:: :func:`cupyx.scipy.ndimage.convolve` .. seealso:: :func:`scipy.signal.correlation` NFcTg|]$\}\}}|vrt||n||zdz %S)max).0ax1x2axess r zfftconvolve..sS F F FHRTMMSR[[[rBw{ F F FrT calc_fast_len)r(r)_init_freq_conv_axes enumeratezipr1_freq_domain_conv_apply_conv_mode)rrrrEr;r1s ` rr2r2sN  %c3 5 5C  23T4OONCd F F F F )#ci*C*C D D F F FE  $S#tU$ O O OC  $S#)SYd K KKrcNtjj|||S)aZFind the fastest convolution/correlation method. Args: in1 (cupy.ndarray): first input. in2 (cupy.ndarray): second input. mode (str, optional): ``'valid'``, ``'same'``, ``'full'``. Returns: str: A string indicating which convolution method is fastest, either ``'direct'`` or ``'fft'``. .. warning:: This function currently doesn't support measure option, nor multidimensional inputs. It does not guarantee the compatibility of the return value to SciPy's one. .. seealso:: :func:`scipy.signal.choose_conv_method` )r3_mathmisc_choose_conv_method)rrrs rr+r+s ( :? . .sC > >>rc tj|||}||S|j|jkrt|||Stj|||d\}}|j|jcstj||z|Sfdt |jD}t|\}}}|kr|krt|||Sfdt |jD} tj ||| |||\}}dtDdDfd D} tj ||| d tD]\} } } || }|tj | g| \}tj |d g| d }tj |g| d }tj |dg| d}||z }fdt jD}j|td| Dtj|S)aConvolve 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 faster than ``convolve`` for large arrays, and generally 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). Args: in1 (cupy.ndarray): First input. in2 (cupy.ndarray): Second input. Should have the same number of dimensions as ``in1``. mode (str): Indicates the size of the output: - ``'full'``: output is the full discrete linear cross-correlation (default) - ``'valid'``: output consists only of those elements that do not rely on the zero-padding. Either ``in1`` or ``in2`` must be at least as large as the other in every dimension. - ``'same'``: output is the same size as ``in1``, centered with respect to the ``'full'`` output axes (scalar or tuple of scalar or None): Axes over which to compute the convolution. The default is over all axes. Returns: cupy.ndarray: the result of convolution .. seealso:: :func:`cupyx.scipy.signal.convolve` .. seealso:: :func:`cupyx.scipy.signal.fftconvolve` .. seealso:: :func:`cupyx.scipy.ndimage.convolve` .. seealso:: :func:`scipy.signal.oaconvolve` N)rrET) sorted_axesc3K|];}|vr!tj||ndd||fVzoaconvolve..ssFF01>?$YYX+BqE2a5999"beRU+FFFFFFrcDg|]}|vr||zdz ndS)r?NrXs rrFzoaconvolve..sE---%&II2a5A;q==4---rcg|] \}}||z Sr^r^)rArYiaxs rrFzoaconvolve..s 666FAs#a%666rcg|]}|dzSr>r^)rAr`s rrFzoaconvolve..s,,,#A,,,rc g|] }| Sr^r^)rArY block_sizes rrFzoaconvolve..s---1A---rFrGrVrr?cvg|]5}|v|vr j|nj|j|dz z6Sr>)r1)rArYfft_axesret split_axess rrFzoaconvolve...sZBBBQj-@-@"#(!2!211ci!n,-@-@-@rc,g|]}t|Sr^)slice)rAislices rrFzoaconvolve..4s===vU6]]===r)r(r)r1r2rIrMrangendimrK_oa_reshape_inputsrJrLr3splitreshapetuple)rrrrEr; optimal_sizesoverlapsin1_stepin2_step shape_final fft_shapeaxax_fftax_splitoverlapoverpart ret_overpart shape_retrcrerfrZr[rgs ` @@@@@@r oaconvolver~s6J  %c3 5 5C   yCI3$T::::23T4?CEEENCd Y FB F(S"b$EEE FFFFFF5:38__FFFM/2M/B,J(H2~~(b..3$T::::------!#(OO---K*3T;+5x+3X??HC 76ioo666J,,,,,H.------I  $S#x38 : : :C!$D(J ? ? ! !FH2, ?  3' F;; X:hh77:z#y&99!< z,X>>qA  BBBBBB//BBBI #+y !C e=====>> ?C  $S"b$ = ==rfillc*t|||||dS)aeConvolve two 2-dimensional arrays. Convolve ``in1`` and ``in2`` with output size determined by ``mode``, and boundary conditions determined by ``boundary`` and ``fillvalue``. Args: in1 (cupy.ndarray): First input. in2 (cupy.ndarray): Second input. Should have the same number of dimensions as ``in1``. mode (str): Indicates the size of the output: - ``'full'``: output is the full discrete linear convolution (default) - ``'valid'``: output consists only of those elements that do not rely on the zero-padding. Either ``in1`` or ``in2`` must be at least as large as the other in every dimension. - ``'same'``: - output is the same size as ``in1``, centered with respect to the ``'full'`` output boundary (str): Indicates how to handle boundaries: - ``fill``: pad input arrays with fillvalue (default) - ``wrap``: circular boundary conditions - ``symm``: symmetrical boundary conditions fillvalue (scalar): Value to fill pad input arrays with. Default is 0. Returns: cupy.ndarray: A 2-dimensional array containing a subset of the discrete linear convolution of ``in1`` with ``in2``. .. seealso:: :func:`cupyx.scipy.signal.convolve` .. seealso:: :func:`cupyx.scipy.signal.fftconvolve` .. seealso:: :func:`cupyx.scipy.signal.oaconvolve` .. seealso:: :func:`cupyx.scipy.signal.correlate2d` .. seealso:: :func:`cupyx.scipy.ndimage.convolve` .. seealso:: :func:`scipy.signal.convolve2d` T _correlate2drrrboundary fillvalues r convolve2dr9sN S$)T B BBrc*t|||||dS)aCross-correlate two 2-dimensional arrays. Cross correlate ``in1`` and ``in2`` with output size determined by ``mode``, and boundary conditions determined by ``boundary`` and ``fillvalue``. Args: in1 (cupy.ndarray): First input. in2 (cupy.ndarray): Second input. Should have the same number of dimensions as ``in1``. mode (str): Indicates the size of the output: - ``'full'``: output is the full discrete linear convolution (default) - ``'valid'``: output consists only of those elements that do not rely on the zero-padding. Either ``in1`` or ``in2`` must be at least as large as the other in every dimension. - ``'same'``: - output is the same size as ``in1``, centered with respect to the ``'full'`` output boundary (str): Indicates how to handle boundaries: - ``fill``: pad input arrays with fillvalue (default) - ``wrap``: circular boundary conditions - ``symm``: symmetrical boundary conditions fillvalue (scalar): Value to fill pad input arrays with. Default is 0. Returns: cupy.ndarray: A 2-dimensional array containing a subset of the discrete linear cross-correlation of ``in1`` with ``in2``. Note: When using ``"same"`` mode with even-length inputs, the outputs of ``correlate`` and ``correlate2d`` differ: There is a 1-index offset between them. .. seealso:: :func:`cupyx.scipy.signal.correlate` .. seealso:: :func:`cupyx.scipy.signal.convolve2d` .. seealso:: :func:`cupyx.scipy.ndimage.correlate` .. seealso:: :func:`scipy.signal.correlate2d` Frrs r correlate2drcsV S$)U C CCrc V|j|jcxkrdks(ntd|rdndddddddd}||}|td t j||||}||St j||||j|||| S) Nz!{} inputs must both be 2-D arraysrrconstantwrapreflect)rpadrcircularsymm symmetriczeAcceptable boundary flags are "fill" (or "pad"), "circular" (or "wrap"), and "symmetric" (or "symm").)rlr*formatgetr(r)r,r-)rrrrrr8 _boundariesr9s rrrs H % % % %A % % % %<CC' :LL]<<== =:F K x((H455 5+CdKHHI  %c3ci&. {? L LLrcz|dkrtj| dz|}n|dkrVtj| dz|}|jdz}|dz}|dzdkr|||z ||z}nR|||z ||zdz}n>|dkr8||z }|dkrtj|dz}ntj|d}|S)a 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. scipy.signal.correlation_lags rr?samerrvalid)r3arangesize)in1_lenin2_lenrlagsmid lag_bounds rcorrelation_lagsrs6 v~~{G8a<11 {G8a<11i1nqL Q;!  y3?;>;y1}--DD;y!,,D Krc|d}tj||jdt}||jjdkr tjn tj d}tj ||d}tj ||z|d}|||zz}|| }||z }|d ||z z z}||z }tj ||k||S) aPerform a Wiener filter on an N-dimensional array. Apply a Wiener filter to the N-dimensional array `im`. Args: im (cupy.ndarray): An N-dimensional array. mysize (int or cupy.ndarray, optional): A scalar or an N-length list giving the size of the Wiener filter window in each dimension. Elements of mysize should be odd. If mysize is a scalar, then this scalar is used as the size in each dimension. noise (float, optional): The noise-power to use. If None, then noise is estimated as the average of the local variance of the input. Returns: cupy.ndarray: Wiener filtered result with the same shape as `im`. .. seealso:: :func:`scipy.signal.wiener` NmysizecFr&rr$r?)r_fix_sequence_argrlintr7r-r5r3 complex128float64runiform_filtermeanwhere)imrnoise local_mean local_varress rwienerrs&~  $VRWh D DF bhms&:&:4??    B(V*EEEJ'2vJGGGI J&&I }   z/C1uy  C:C :i%'S 9 99rc|jjdvs|jtjkrt dt d|jDrt dtj|||dS)aPerform 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. Args: a (cupy.ndarray): The N-dimensional input array. domain (cupy.ndarray): 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). Returns: cupy.ndarray: The results of the order filter in an array with the same shape as `a`. .. seealso:: :func:`cupyx.scipy.ndimage.rank_filter` .. seealso:: :func:`scipy.signal.order_filter` bczdata type not supportedc3(K|] }|dzdkVdSrr?Nr^)rAxs rr\zorder_filter..(s* , ,!1q5A: , , , , , ,rzIEach dimension of domain argument should have an odd number of elements.r) footprintr) r-r5r3float16r*anyr1r rank_filter)rBdomainranks r order_filterrs. w|tqw$,662333 , ,v| , , ,,,DCDD D  46 K K KKrc|jjdkrtd|jjdkrtdt ||j}|jdkrt d|jjdkrtdtdt||j Drtj d tj |}tj||d z|d S) aPerform 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. Args: volume (cupy.ndarray): An N-dimensional input array. kernel_size (int or list of ints): Gives 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: cupy.ndarray: An array the same size as input containing the median filtered result. .. seealso:: :func:`cupyx.scipy.ndimage.median_filter` .. seealso:: :func:`scipy.signal.medfilt` efloat16 type not supportedbbool type not supportedFcomplex types not supportedrc3(K|] \}}||kVdSNr^)rAkss rr\zmedfilt..Ns* < 1, r(p_i, zi) otherwise y = [o_0, o_1, ..., o_nc] where `c` denotes a function that takes a chunk, slices the last `N` values and adjust them using a correction factor table computed using the (1, 2, ..., N)-fibonacci sequence. For more information see [1]_. 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 References ---------- .. [1] Sepideh Maleki and Martin Burtscher. 2018. Automatic Hierarchical Parallelization of Linear Recurrences. SIGPLAN Not. 53, 2 (February 2018), 128-138. `10.1145/3173162.3173168 `_ rr?Nr-axisrr)rroriginoutputu)rzir-)rrlr_normalize_axis_indexr1r3r4listzeros atleast_1dr r empty_liker convolve1dr-r5rlowerr7rempty)rrBrrra0a_rnum_bnum_ax_ndimn fir_dtypeprev_inprev_out pad_shapex_fullrr; iir_dtype const_dtypes rlfilterrs;^ 1B abbE'B,C BA FQJE HE VF  )$ 7 7D  A A&&IGHQW I dOOOuOOO Z  3 3 3F ~ _R  199 QD999G 199!BHTNU*BHTNGGGHVWaTBBB E 5 5 5FVq[F /& 2 2 2C  :fS J J JC qyycio139T?NNN x!||$Y22 j))  s " "*[%5%;%;%=%=>>K%%ASt JJJ ~ Z 2 2 2 199 174=5(!'$-dDDDGR!U>>>B 199!SYt_u,cioDJJJHHbhtnu4bhtnBBw rc 0d}|jdz }|jdz }||dS||jn|j}tj||}t jd}||dkrt j|t jt||j |z df|} t j | tt||}t j ||}||dkrt j|t jt||j |z df|} t j | tt||} t j | |} t j| |f|}|S)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. axis: int, optional The axis to take the initial conditions from, if `x` and `y` are n-dimensional Returns ------- zi : ndarray The state vector ``zi = {z_0[-1], z_1[-1], ..., z_K-1[-1]}``, where ``K = M + N``. See Also -------- lfilter, lfilter_zi rVr?Nrr)rrlrrr3r concatenaterr@r1takerrkflip) rrByrrfir_leniir_lenref_ndimrpad_ypad_xfir_zis rlfilticr0sP DfqjGfqjGyQYtqvvAFH  )$ 9 9D AB}1  3w6::;; <4III Yud5>>22 > > > Yr4 }1  3w6::;; <4III5$uW~~"6"6TBBB64((  vrl 6 6 6 Irc|d}|dd |z }|jdz }|j}tj|}|dkrtj|tj|f}t ||tj|dz|\}} |d|} || d} tj|dkd} t||jdz|j} | dd|jdf} | ddd|jfj }| dd|j dfj }t| s'tj ||z | | z }n-tj ||z | | z d\}} } } tj|dtjtj }tj||dddf}|S)a 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 rr?NrrcondnanposinfneginfrV)rr3onesr_rrrrr-Tlenlinalgsolver nan_to_numinf)rrBrrrrrzi_tr_y1y2 zero_coefCC1C2y_zis r lfilter_zirrs4 1B abbE'B,C FQJE HE 5  B qyywr4:e,,,-q!TYuqy11d;;;1 vvY vwwZJsax((+ &sCHqL#) D D aaalO qqq)38)|_  qqq38)**}  9~~ L;$$R"Wb2g66DD!K--b2grBwd-KKMD!Qt48TXINNN WRddd^ $ Irlinearc|dvrtdtj|}|jj}|dvrd}|dvr|tj||dz }|S|j}||}tjtjtj d||f}tj ||krtd | }t|} |dkr|| z}tj ||d} | j} | |d } |s| } | jjdvr| |} t#t|d z D]} || d z|| z } tj| d f|}tjd | d z| | z |dddf<t)|| || d z}t+|| |d\}}}}| |||zz | |<| | } tj | d|}|S)a< Remove linear trend along axis from data. Parameters ---------- data : array_like The input data. axis : int, optional The axis along which to detrend the data. By default this is the last axis (-1). type : {'linear', 'constant'}, optional The type of detrending. If ``type == 'linear'`` (default), the result of a linear least-squares fit to `data` is subtracted from `data`. If ``type == 'constant'``, only the mean of `data` is subtracted. bp : array_like of ints, optional A sequence of break points. If given, an individual linear fit is performed for each part of `data` between two break points. Break points are specified as indices into `data`. This parameter only has an effect when ``type == 'linear'``. overwrite_data : bool, optional If True, perform in place detrending and avoid a copy. Default is False Returns ------- ret : ndarray The detrended input data. See Also -------- scipy.signal.detrend )rlrrz*Trend type must be 'linear' or 'constant'.dfDFd)rrT)keepdimsrz>Breakpoints must be less than length of data along given axis.rVr?rrNr)r*r3asarrayr-rrr1sortuniquer rtolistr moveaxisror'r7rkrrrir)datartypebpoverwrite_datar-rfdshapeNrnknewdata newdata_shapemNptsAslcoefresidsrrs rdetrendr4s^F 333EFFF <  D JOE F    TYtTD9999  4L Yt{471b!8#455 6 6 8BF   :9:: : YY[[&kk !88#:D-dA.. //!R(( %llnnG = V + +nnU++Gs2ww{## 1 1Aa!e9r!u$D 4)U++Ak!TAXU;;;dBAaaadGr!ubQi((B$)!WR[$E$E$E !D&$!"+D0GBKK//-00mGQ-- rc D tj|}tj|}tt|t|dz }|dkrB|d|dz dz}||z}|tjgtjgfS|dks||jdz krtj|||jdz }|jd}| |d|zkr|} n|} tj| |f} tj| } d| d<ttj d|| | dddf<td|D]} | d| df| | d| f<| ddd} t||| dddd}|ddd}| |krtj || z | |z f}n8tjd| zd|zf}|| z |d| d|f<| |z || d|df<t|||}t|||ddddfddddf}t|||ddddfddddf}t|||}||z }| |kr|}n1|dd| f}|d| df}tj ||fd}|jdkr)tj||dd}n|d|jdj}tj||ddj}||jdd|jdfz}| |krtj || f}n2tjd| zd|zf}||d| d|f<| || d|df<||j}|}| |kr||z }n>|dd| fxx|dd| fz cc<|d| dfxx|d| dfz cc<|dd|f}|d| df} |dks||jdz krZtj|||jdz }tj| ||jdz } tj|||jdz }||| fS) a6Forward-backward IIR filter that uses Gustafsson's method. Apply the IIR filter defined by `(b,a)` to `x` twice, first forward then backward, using Gustafsson's initial conditions [1]_. Let ``y_fb`` be the result of filtering first forward and then backward, and let ``y_bf`` be the result of filtering first backward then forward. Gustafsson's method is to compute initial conditions for the forward pass and the backward pass such that ``y_fb == y_bf``. Parameters ---------- b : scalar or 1-D ndarray Numerator coefficients of the filter. a : scalar or 1-D ndarray Denominator coefficients of the filter. x : ndarray Data to be filtered. axis : int, optional Axis of `x` to be filtered. Default is -1. irlen : int or None, optional The length of the nonnegligible part of the impulse response. If `irlen` is None, or if the length of the signal is less than ``2 * irlen``, then no part of the impulse response is ignored. Returns ------- y : ndarray The filtered data. x0 : ndarray Initial condition for the forward filter. x1 : ndarray Initial condition for the backward filter. Notes ----- Typically the return values `x0` and `x1` are not needed by the caller. The intended use of these return values is in unit tests. References ---------- .. [1] F. Gustaffson. Determining the initial states in forward-backward filtering. Transactions on Signal Processing, 46(4):988-992, 1996. r?rrrVNr.r)r3rr@r arrayrlswapaxesr1rrrrkhstackrr rror dot)!rrBrrirlenrscalerrr.Obsx_inrObsrSSrMy_fy_fby_by_bf delta_y_bf_fbdeltastart_mend_mic_optdelta2dic_opt0Wwicy_optx0rCs! r_filtfilt_gustrQs` A A AA  ! #E zz1!" AI$*R..$*R..00 rzzTQVaZ'' M!T16A: . .  A }QY   *aZ C :a==DDG ! a..C1I 1e__!!1"a[ABBE  ttt9D 1c$$B$ia(((A 44R4B Avv Kc4!8, - - J!QuW~ & &S"1"fuf* q!""eff* !Q  C 1aS$$B$Y ( (ddd 3D !Q#ttt) % %c44R4i 0C 1a  D4KMAvvRaR(cA233h' '5!1;;;  zQ""1e4"88;--EKO446+##Awd#;;A>@SbS!1QWR[N!BCC Avv KT # # J!QuW~ & &"1"fuf* !""eff*  **QS//C EAvv   c2A2g#c2A2g,& cA233h3sQBCCx=( VeV B eVWW B rzzTQVaZ'' ]2tQVaZ 0 0 ]2tQVaZ 0 0 eT16A:66 "b=rc6|dvrtd|z|d}||dz}n|}|j||krtd|z|K|dkrE|dkrt|||}n.|d krt|||}nt |||}n|}||fS) z'Helper to validate padding for filtfilt)evenoddrNzYUnknown value '%s' given to padtype. padtype must be 'even', 'odd', 'constant', or None.NrrzJThe length of the input vector x must be greater than padlen, which is %d.rSrrT)r*r1r r r)padtypepadlenrrntapsedgeexts r _validate_padrZs777H !"" " ~qy wt}57;<== =taxx f  1d...CC   !T---CCAt$///CC 9rrTrc tj|}tj|}tj|}|dvrtdtj|j}|jdkr@tj|j}||}|dkrt|||||\} } } | St||||tt|t|\} } t||}dg|jz}|j||<tj||}t#| d|}t%||| |||z \} }t#| d | }t%||t'| | |||z \} }t'| | } | d krt#| | | |} | S)a) 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. References ---------- .. [1] F. Gustaffson, "Determining the initial states in forward-backward filtering", Transactions on Signal Processing, Vol. 46, pp. 988-992, 1996. >rgustzmethod must be 'pad' or 'gust'.rr\)rr:rWr?stoprrrrVstartrrrrbr_r)r3rr r*r-r5rrr7rQrZr@r rrlrror rr )rrBrrrUrVrr:rrz1z2rXrYrzi_shaperPzfy0s rfiltfiltris^ A A QA _$$:;;;*QW%%K3j!1!7!7!9!9:: HH[ ! ! "1aUCCC 2rgvq$$'AA$7$7999ID# Aq  B sQV|HWHTN b( # #B Cad + + +BaCdrBw777GQ ARd + + +BaL666Tb2gNNNGQ QT"""A axx qD5t < < < Hrctj|}tj|}|jdkrtd|jdkrtdt |}t |}||krg}|}nKtj||z dzt }d|d<t|||}|t||dz }||fS)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 -------- cupy.polydiv : performs polynomial division (same operation, but also accepts poly1d objects) Examples -------- Deconvolve a signal that's been filtered: >>> from cupyx.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.]) r?zsignal must be 1-D.zdivisor must be 1-D.rrr$) r3rrlr*r rfloatrr) signaldivisornumdenr*Dquotremrs r deconvolversTsR /& ! !C /' " "C x!||./// x!||/000 CA CA1uu 1q519e,,asC''HS$V4444 9rc|d|z}tj||dt}td|Drt d|S)Nrrc3(K|] }|dzdkVdSrr^)rArs rr\z#_get_kernel_size..s* - -AAEa< - - - - - -rz)Each element of kernel_size should be odd)rrrrr*)rrls rrrsaTk )+t*7>>K - - - - ---FDEEE rc0tj|}|jdkrtd|j\}}|dkrtdtj|dddfdz dkstd ||fS) zHelper to validate a SOS inputrzsos array must be 2Dz'sos array must be shape (n_sections, 6)Nrg?gV瞯rs  %%%%%%((((((<<<<<<IIIIIIIIIIIIIIII$$$$$$$$$$$$ ,4,4,4,4^,5,5,5,5^8.L.L.L.Lb????.b>b>b>b>J'C'C'C'CT+D+D+D+D\LLLL*::::z(:(:(:(:VLLL@&1&1&1&1R(9(9(9(9Vkkkk\????D999xNNNNbooood   FCH} } } } @999x      ////dCCCLD D D D NA A A A H7 7 7 7 7 7 r