`i6?ddlZddlZddlmZddlmZddlmZddlm Z ddl Z ej dddd d d d Z d Z dZdkdZdZdZdldZejxZZejddddZejddddZejZejddddZd Zd!Zejd"d#d$efd%d&efd'd(efd)d*efd+d,efd-d.d/d0efd1effd2d3Zejd4d5d6d7Zd8Zd9Zejd:d;dd?d@dAdBdCdDdEdFefdGefdHefdIefdJeffdKedLdMdNOZ dPZ!ejdQd;dd?d@dAdBdCdDdEdFe!fdGe!fdHe!fdIe!fdJe!ffdRedSdTdUOZ"ejdVdWdKdXZ#ejdYdZdRd[Z$d\Z%ejd]d^d_e%d`aZ&dldbZ'dmdeZ(dndgZ)ej*+dchdiZ,dodjZ-dS)pN)_core)_routines_math)fusion) stride_tricksz T x1, T x2zT yzx1 * x2za + bzy = a0 dot_productc|jdks |jdkrtd|jjdvs|jjdvrdSt |||rdSdS)Nz&Only 1d inputs are supported currentlybuidirectfft)ndimNotImplementedErrordtypekind_fftconv_faster)in1in2modes c/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupy/_math/misc.py_choose_conv_methodrsf x1}}A !"JKKK y~#).E"9"9xsC&&u 8cdS)zJ .. seealso:: :func: `scipy.signal._signaltools._fftconv_faster` T)xhrs rrr$s 4rfullc|jdkrtd|jdkrtd|jdkrtd|j|jkr||}}|}|}t |||}|dkrt |||}n'|dkrt |||}ntd|S) arReturns the discrete, linear convolution of two one-dimensional sequences. Args: a (cupy.ndarray): first 1-dimensional input. v (cupy.ndarray): second 1-dimensional input. mode (str, optional): `valid`, `same`, `full` Returns: cupy.ndarray: Discrete, linear convolution of a and v. .. seealso:: :func:`numpy.convolve` rza cannot be emptyzv cannot be emptyr z"v cannot be multidimensional arrayr r zUnsupported method)size ValueErrorrravelr _dot_convolve _fft_convolve)avrmethodouts rconvolver(-s v{{,---v{{,---vzz=>>>v!1  A  A At , ,F Aq$'' 5Aq$''-... Jrc@d}|jd|jdkr||}}d|jddzz }|jjdks|jjdkr#tjjtjj}}n"tjjtjj}}tj||}|jd|jd}}tj j ||zdz } ||| } ||| } || | z| } |dkr d||zdz }} n4|dkr|dz dz|z} | |z}n|dkr|dz |}} ntd | d | |f} |jd vrtj | } | |d S)Nrr crsamevalidz5acceptable mode flags are `valid`, `same`, or `full`..iuFcopy)shaperrcupyr ifftrfftirfft result_typecupyxscipy next_fast_lenr aroundastype)a1a2roffsetr r4rn1n2out_sizefa1fa2r'startends rr#r#Ps F x|bhrl""RBRXb\A%% x}rx}33HL$(-THM48>T  R $ $E Xb\28B<B{,,R"Wq[99H #b(  C #b(  C $sSy( # #C v~~R! s aA &bj !VRs CEE E c59n C zTk# ::e%: ( ((rc>d}|j|jkr||}}d|jdzz }tj||}|j|j}}||d}||d}|dkr!||zdz }tj||dz }n?|dkr+|}|dz dz|z}tj||dz |z |f}n|dkr||z dz}|jd} t j|||f| | f}t||ddd d } | S) Nrr r+Fr0rr-r.r*)axis) rr3r7r<padstridesr as_strided _dot_kernel) r=r>rr?rr@rArBpad_sizestrideoutputs rr"r"wsF F wRBRWq[  R $ $E WbgB 5u % %B 5u % %B v~~7Q; Xb"q& ! ! Fq=6) Xb26H,h7 8 8 7Q; Z]F  !"xnvv6F G GB R"XA . . .F Mrctjr#tjtj||||S||||S)aClips the values of an array to a given interval. This is equivalent to ``maximum(minimum(a, a_max), a_min)``, while this function is more efficient. Args: a (cupy.ndarray): The source array. a_min (scalar, cupy.ndarray or None): The left side of the interval. When it is ``None``, it is ignored. a_max (scalar, cupy.ndarray or None): The right side of the interval. When it is ``None``, it is ignored. out (cupy.ndarray): Output array. Returns: cupy.ndarray: Clipped array. .. seealso:: :func:`numpy.clip` Notes ----- When `a_min` is greater than `a_max`, `clip` returns an array in which all values are equal to `a_max`. r')r _is_fusing _call_ufunc_mathclip)r$a_mina_maxr's rrUrUsV0<!%*"#UEs<<< < 66%C6 ( ((r cupy_cbrt)e->ef->fd->dzout0 = cbrt(in0)zJElementwise cube root function. .. seealso:: :data:`numpy.cbrt` )doc cupy_square)b->bB->Bh->hH->Hi->iI->Il->lL->Lq->qQ->QrYrZr[F->FD->Dzout0 = in0 * in0zIElementwise square function. .. seealso:: :data:`numpy.square` cupy_fabszout0 = abs(in0)zuCalculates absolute values element-wise. Only real values are handled. .. seealso:: :data:`numpy.fabs` zout0 = in0 > 0z if (in0.real() == 0) { out0 = (in0.imag() > 0) - (in0.imag() < 0); } else { out0 = (in0.real() > 0) - (in0.real() < 0); } cupy_signr^r_r`rarbrcrdrerfrgrYrZr[rhrizout0 = (in0 > 0) - (in0 < 0)zElementwise sign function. It returns -1, 0, or 1 depending on the sign of the input. .. seealso:: :data:`numpy.sign` cupy_heaviside)ee->eff->fdd->dz if (isnan(in0)) { out0 = in0; } else if (in0 == 0) { out0 = in1; } else { out0 = (in0 > 0); } zTCompute the Heaviside step function. .. seealso:: :data:`numpy.heaviside` z; #ifndef NAN #define NAN __int_as_float(0x7fffffff) #endif zLout0 = (isnan(in0) | isnan(in1)) ? out0_type(NAN) : out0_type(max(in0, in1)) cupy_maximum??->?bb->bBB->Bhh->hHH->Hii->iII->Ill->lLL->Lqq->qQQ->QrmrnroFF->FDD->Dzout0 = max(in0, in1)zTakes the maximum of two arrays elementwise. If NaN appears, it returns the NaN. .. seealso:: :data:`numpy.maximum` )OP_MAXr r max)preambler\ cutensor_op scatter_opzLout0 = (isnan(in0) | isnan(in1)) ? out0_type(NAN) : out0_type(min(in0, in1)) cupy_minimumzout0 = min(in0, in1)zTakes the minimum of two arrays elementwise. If NaN appears, it returns the NaN. .. seealso:: :data:`numpy.minimum` )OP_MINr r min cupy_fmax)rqrrrsrtrurvrwrxryrzr{)rmout0 = fmax(in0, in1))rnr)rorr|r}zTakes the maximum of two arrays elementwise. If NaN appears, it returns the other operand. .. seealso:: :data:`numpy.fmax` cupy_fmin)rqrrrsrtrurvrwrxryrzr{)rmout0 = fmin(in0, in1))rnr)rorr|r}zTakes the minimum of two arrays elementwise. If NaN appears, it returns the other operand. .. seealso:: :data:`numpy.fmin` a template __device__ T nan_to_num(T x, T nan, T posinf, T neginf) { if (isnan(x)) return nan; if (isinf(x)) return x > 0 ? posinf : neginf; return x; } template __device__ complex nan_to_num(complex x, T nan, T posinf, T neginf) { T re = nan_to_num(x.real(), nan, posinf, neginf); T im = nan_to_num(x.imag(), nan, posinf, neginf); return complex(re, im); } cupy_nan_to_num_)z????->?zbbbb->bzBBBB->Bzhhhh->hzHHHH->Hziiii->izIIII->Izllll->lzLLLL->Lzqqqq->qzQQQQ->Q)zeeee->e%out0 = nan_to_num(in0, in1, in2, in3))zffff->fr)zdddd->dr)zFfff->Fr)zDddd->Drz out0 = in0zQElementwise nan_to_num function. .. seealso:: :func:`numpy.nan_to_num` )rr\c|jdvr+tj|j}|jdvrd}n|7|5|rtj|jntj|j}nKtj|r tj}n*tj |rtj d|dkzz}tj ||S)NFDefdrr*) charr3rlowerfinforrisnannanisinfinf asanyarray)rrnegs r_check_nan_infrs zT 5:++--.. z  s%( CDJu   ! !dj.?.?.C A% H A% Ha!e} $ ?1e $ $$rTc,t|tjstjd|}n|rtj|n|}|j}t ||}t ||d}t ||d}t|||||S)zReplace NaN with zero and infinity with large finite numbers (default behaviour) or with the numbers defined by the user using the `nan`, `posinf` and/or `neginf` keywords. .. seealso:: :func:`numpy.nan_to_num` rFTrQ) isinstancer3ndarrayr empty_likerr _nan_to_num)rr1rposinfneginfr'rs r nan_to_numrs a & &0iA$(/doa   a IE e $ $C FE5 1 1F FE4 0 0F q#vv3 7 7 77rdct|jjtjs|S|dkr(t j|jj}|j|z}tjtj |j |kr|j }|S)a#If input is complex with all imaginary parts close to zero, return real parts. "Close to zero" is defined as `tol` * (machine epsilon of the type for `a`). .. warning:: This function may synchronize the device. .. seealso:: :func:`numpy.real_if_close` r ) issubclassrtyper3complexfloatingnumpyrepsallabsoluteimagreal)r$tolfs r real_if_closersx aglD$8 9 9 Qww K % %eck x af%%+,, F Hr)for_each_devicecd}|dz }d}|rd}nd}|dz }|tjjjz }d}tj|||d| S) Nzraw V x, raw U idx, z2raw W fx, raw Y fy, U len, raw Y left, raw Y rightzZ yztypedef double real_t; ztypedef Z real_t; ztypedef Z value_t; a U x_idx = idx[i] - 1; if ( _isnan(x[i]) ) { y = x[i]; } else if (x_idx < 0) { y = left[0]; } else if (x[i] == fx[len - 1]) { // searchsorted cannot handle both of the boundary points, // so we must detect and correct ourselves... y = fy[len - 1]; } else if (x_idx >= len - 1) { y = right[0]; } else { const Z slope = (value_t)(fy[x_idx+1] - fy[x_idx]) / \ ((real_t)fx[x_idx+1] - (real_t)fx[x_idx]); Z out = slope * ((real_t)x[i] - (real_t)fx[x_idx]) \ + (value_t)fy[x_idx]; if (_isnan(out)) { out = slope * ((real_t)x[i] - (real_t)fx[x_idx+1]) \ + (value_t)fy[x_idx+1]; if (_isnan(out) && (fy[x_idx] == fy[x_idx+1])) { out = fy[x_idx]; } } y = out; } cupy_interp)r)r3_sortingsearch _preambleElementwiseKernel) is_complex in_params out_paramsrcodes r_get_interp_kernelrsz&I EEIJ)-( &&H  $..H D4  !:t]X G G GGrc 8|jdks |jdkrtd|j|jkrtd|jdkrtd|jjst dt j||}t j|t j s-td |t j ||dkrtd t|}d}d}| t j }| t j }||z}||z}t j|}||}||}t j|d d|z ||dd|zf}t j|d d||ddf}|jjsJ|jjsJ|jjd krd nd }t j|j|} t j||d} ||dnt j||j}||d nt j||j}t-|d k} | || |||j||| | S)a One-dimensional linear interpolation. Args: x (cupy.ndarray): a 1D array of points on which the interpolation is performed. xp (cupy.ndarray): a 1D array of points on which the function values (``fp``) are known. fp (cupy.ndarray): a 1D array containing the function values at the the points ``xp``. left (float or complex): value to return if ``x < xp[0]``. Default is ``fp[0]``. right (float or complex): value to return if ``x > xp[-1]``. Default is ``fp[-1]``. period (None or float): a period for the x-coordinates. Parameters ``left`` and ``right`` are ignored if ``period`` is specified. Default is ``None``. Returns: cupy.ndarray: The interpolated values, same shape as ``x``. .. note:: This function may synchronize if ``left`` or ``right`` is not already on the device. .. seealso:: :func:`numpy.interp` r zxp and fp must be 1D arraysz$fp and xp are not of the same lengthrzarray of sample points is emptyz-Non-C-contiguous x is currently not supportedzACannot cast array data from {} to {} according to the rule 'safe'Nzperiod must be a non-zero valuer*r,Dd)rright)side)rr rflags c_contiguousrr3 common_typecan_castfloat64 TypeErrorformatabsr<argsort concatenaterremptyr2 searchsortedarrayr) rxpfpleftrperiodx_dtypeasort_xp out_dtyperOidxkerns rinterprs: w!||rw!||6777 w"'?@@@ w!||:;;; 7 /!#.// /q"%%G =$, / /8C6688 8 Q;;>?? ?V HHT\ " " YYt| $ $ V  f <## \ \  r"##wv~r2ac76>B C C  r"##wBqsG4 5 5x$$$$x$$$$x}++I Zy 1 1 1F  B 0 0 0CL2a55djrx&@&@DmBrFFE28)D)DE i3. / /DDCR$v666 Mr)r)N)TrNN)r)NNN).r3cupyx.scipy.fftr8r cupy._corerrTrcupy.librrReductionKernelrLrrr(r#r"rUsqrt sqrt_fixed create_ufunccbrtsquarerfabs_unsigned_sign _complex_signsign heaviside_float_preamble_float_maximummaximum_float_minimumminimumfmaxfmin_nan_to_num_preamblerrrr_utilmemoizerrrrrrs` ......"""""" $e#            F$)$)$)N8))))DJzu       5   >u     " u fn %v/G fn %v/G fn %vvv mv}57#      E      ( - %  gw'7G gw ~ ~ ~ ~ ~    !U% 4 4 4*- %  gw'7G gw ~ ~ ~ ~ ~    !U% 4 4 4*u     $u     $&!e  0 ! !   . % % % %8888&    ,D))'G'G*)'GTLLLLLLr