o װi>@sddlZddlmZddlmZddlmZddlmZm Z m Z ddl m Z m Z dZejedd d d Dd d d Dd ZddZd ddZd!ddZd"ddZddZddZd!ddZd"ddZdS)#N) get_typename)_normalize_axis_index)lfilter) axis_slice axis_assign axis_reverse) collapse_2d apply_iir_sosaj #include #include template __device__ T _compute_symiirorder2_fwd_hc( const int k, const T cs, const T r, const T omega) { T base; if(k < 0) { return 0; } if(omega == 0.0) { base = cs * pow(r, ((T) k)) * (k + 1); } else if(omega == M_PI) { base = cs * pow(r, ((T) k)) * (k + 1) * (1 - 2 * (k % 2)); } else { base = (cs * pow(r, ((T) k)) * sin(omega * (k + 1)) / sin(omega)); } return base; } template __global__ void compute_symiirorder2_fwd_sc( const int n, const int off, const T* cs_ptr, const T* r_ptr, const T* omega_ptr, const double precision, bool* valid, T* out) { int idx = blockDim.x * blockIdx.x + threadIdx.x; if(idx + off >= n) { return; } const T cs = cs_ptr[0]; const T r = r_ptr[0]; const T omega = omega_ptr[0]; T val = _compute_symiirorder2_fwd_hc(idx + off + 1, cs, r, omega); T err = val * val; out[idx] = val; valid[idx] = err <= precision; } template __device__ T _compute_symiirorder2_bwd_hs( const int ki, const T cs, const T rsq, const T omega) { T c0; T gamma; T cssq = cs * cs; int k = abs(ki); T rsupk = pow(rsq, ((T) k) / ((T) 2.0)); if(omega == 0.0) { c0 = (1 + rsq) / ((1 - rsq) * (1 - rsq) * (1 - rsq)) * cssq; gamma = (1 - rsq) / (1 + rsq); return c0 * rsupk * (1 + gamma * k); } if(omega == M_PI) { c0 = (1 + rsq) / ((1 - rsq) * (1 - rsq) * (1 - rsq)) * cssq; gamma = (1 - rsq) / (1 + rsq) * (1 - 2 * (k % 2)); return c0 * rsupk * (1 + gamma * k); } c0 = (cssq * (1.0 + rsq) / (1.0 - rsq) / (1 - 2 * rsq * cos(2 * omega) + rsq * rsq)); gamma = (1.0 - rsq) / (1.0 + rsq) / tan(omega); return c0 * rsupk * (cos(omega * k) + gamma * sin(omega * k)); } template __global__ void compute_symiirorder2_bwd_sc( const int n, const int off, const int l_off, const int r_off, const T* cs_ptr, const T* rsq_ptr, const T* omega_ptr, const double precision, bool* valid, T* out) { int idx = blockDim.x * blockIdx.x + threadIdx.x; if(idx + off >= n) { return; } const T cs = cs_ptr[0]; const T rsq = rsq_ptr[0]; const T omega = omega_ptr[0]; T v1 = _compute_symiirorder2_bwd_hs(idx + l_off + off, cs, rsq, omega); T v2 = _compute_symiirorder2_bwd_hs(idx + r_off + off, cs, rsq, omega); T diff = v1 + v2; T err = diff * diff; out[idx] = diff; valid[idx] = err <= precision; } )z -std=c++11cCg|]}d|dqS)zcompute_symiirorder2_bwd_sc<>.0tr r O/home/ubuntu/.local/lib/python3.10/site-packages/cupyx/scipy/signal/_splines.py qr)floatdoublecCr )zcompute_symiirorder2_fwd_scdd|D}d|}|r|d|dn|}||}|S)NcSsg|]}t|jqSr )rdtype)rargr r rrxsz$_get_module_func..z, gMbP? r%rr'r;Sum to find symmetric boundary conditions did not converge.r&r=F)r2r apply_firstepr2r)rndimshaperr)abs ValueErrorrfloat64float32finfoiexparange conjugatecumsumrr3anyisnanzerosrr_ atleast_2dr c_rreshapemoveaxisflags c_contiguouscopy)inputc0z1 precisionr( input_shape input_ndimpospow_z1diffr.r-r2zi_shapeall_zicoefy1_outr r r_symiirorder1_ndsn         ricCst|g|j}t|g|j}t|dkrtd|dks#|dkr*t|jj}||9}tjd|jd|jd}||}|t |}t |||d}||k}t |||j} t | rdtdtj d| f} | |j} ttjd|jd| |dd| d \} } tj | | f} | |d| d } tj d| f} | |j} t|| | dd ddd | d \} } tj | ddd | fS) aR Implement a smoothing IIR filter with mirror-symmetric boundary conditions using a cascade of first-order sections. The second section uses a reversed sequence. This implements a system with the following transfer function and mirror-symmetric boundary conditions:: c0 H(z) = --------------------- (1-z1/z) (1 - z1 z) The resulting signal will have mirror symmetric boundary conditions as well. Parameters ---------- input : ndarray The input signal. c0, z1 : scalar Parameters in the transfer function. precision : Specifies the precision for calculating initial conditions of the recursive filter based on mirror-symmetric input. Returns ------- output : ndarray The filtered signal. r&r5r6r7r:rr;Nr2r%)r)asarrayrrFrGrJ resolutionrLr,rMrNr3rPrRastyperones)rZr[r\r]r`rarbr.r-r2arfrgrhr r r symiirorder1s8    &rpcCsd}|dkr|t|||d}n0|tjkr-|t|||ddd|d}n|t||t||dt|}t|dkd|S)Nr6r&r)r)powerpisinr*)kcsromegabaser r r_compute_symiirorder2_fwd_hcs * rzcCsL||}t|}t||d}|dkr9d|d|d|d||}d|d|}||d||S|tjkrjd|d|d|d||}d|d|dd|d}||d||S|d|d|dd|td|||}d|d|t|}||t|||t||S)Ng@r6r&rqr7)r)rFrrrscostanrt)rurvrsqrxcssqrsupkr[gammar r r_compute_symiirorder2_bwd_hs&s  $ $  (rc Csb|dkrtd|dks|dkr2|jttjurd}n|jttjur(d}n dt|jj }t||j}|j }|j}|jdkrJt ||\}}d}||}d |t |} | } t dd |t ||} t || j}t || j}t || j}||9}ttd | } tj|df| jd } tj|dftjd }tjd |jd }t|| ||}tj}tj}td |j d d |D]}| d|df|j d d || ||||| ft||||}| dd d|j d }| ddd|j d }t|r)tj||d d|d t|d d}t|dd d|j d ||j d |}t|ratj||d d|d t|dd |dt|d d}t|ddd|j d ||j d |}tttj||fsqnqtttj||frtdd}|dkrd|j d df}ttj| d d d| | f}||j}tj||jd }t||d d}t||dd}t t|d |||jd\}}|dkrtj!|||f}ntj|||f}ttd| }tj|f| jd } tj|ftjd }t"|}tj}td |j d d|D]W}|d|f|j d d|d d| t || jt || j||| f t||||}tj| d|j d |d d}t|d|j d ||j d |}tt|scnq tt|rrtdtj}td |j d d|D]Q}|d|f|j#d|d d | t || jt || j||| f t||||}tj| d|j d |d d}t|d|j#||j#|}tt|snqtt|rtdt||d d}t||dd}t t|dd d||d\}}|dkr tj!t"|||f}n tjt"|||f}|dkr/|$|}t%|d |}|j&j's/|(}|S)Nr7zr must be less than 1.0r6gdy=r8r9r&rqcompute_symiirorder2_fwd_scr:rr%)r&r'r;r<r=r>rCcompute_symiirorder2_bwd_scrArj))rGrr)rHrIrJrKrrDrErr{ atleast_1drkr$SYMIIR2_MODULEemptybool_rLrzr+rangerrPrNr3rOrRrSrmrQrr rTrr,rUrVrWrXrY) rZrwrxr]r(r^r_block_szr}a2a3rvrrbr- starting_diffy0rfi input_slicediff_y0diff_y1 cum_poly_y0 cum_poly_y1rcsosrdy_fwdrgr rev_inputrhr r r_symiirorder2_nd;s                 rcCst||||S)ak Implement a smoothing IIR filter with mirror-symmetric boundary conditions using a cascade of second-order sections. The second section uses a reversed sequence. This implements the following transfer function:: cs^2 H(z) = --------------------------------------- (1 - a2/z - a3/z^2) (1 - a2 z - a3 z^2 ) where:: a2 = 2 * r * cos(omega) a3 = - r ** 2 cs = 1 - 2 * r * cos(omega) + r ** 2 Parameters ---------- input : ndarray The input signal. r, omega : float Parameters in the transfer function. precision : float Specifies the precision for calculating initial conditions of the recursive filter based on mirror-symmetric input. Returns ------- output : ndarray The filtered signal. )r)rZrwrxr]r r r symiirorder2sr)rr%)r4r%)r4)r)cupy._core._scalarrcupy._core.internalrcupyx.scipy.signal._signaltoolsrcupyx.scipy.signal._arraytoolsrrrcupyx.scipy.signal._iir_utilsrr SYMIIR2_KERNEL RawModulerr$r3rirprzrrrr r r rs4   c  JF