o 0 i6?@s`ddlZddlZddlmZddlmZddlmZddlm Z ddl Z e dddd d d d Z d dZ ddZdvddZddZddZdwddZejZZejdddddZejdd d!d"dZejZejd#dd$d%dZd&Zd'Zejd(d)d*efd+d,efd-d.efd/d0efd1d2efd3d4d5d6efd7effd8d9dZejd:d;dZd?Zejd@dAdBdCdDdEdFdGdHdIdJdKdLefdMefdNefdOefdPeffdQedRdSdTdUZ dVZ!ejdWdAdBdCdDdEdFdGdHdIdJdKdLe!fdMe!fdNe!fdOe!fdPe!ffdXedYdZd[dUZ"ejd\d]dQd^dZ#ejd_d`dXdadZ$dbZ%ejdcdddee%dfdgZ&dwdhdiZ'dxdldmZ(dydodpZ)ej*j+djdqdrdsZ,dzdtduZ-dS){N)_core)_routines_math)fusion) stride_tricksz T x1, T x2zT yzx1 * x2za + bzy = a0Z dot_productcCsL|jdks |jdkrtd|jjdvs|jjdvrdSt|||r$dSdS)Nz&Only 1d inputs are supported currentlyZbuidirectfft)ndimNotImplementedErrordtypekind_fftconv_faster)Zin1Zin2moder[/home/app/PaddleOCR-VL-test/.venv_paddleocr/lib/python3.10/site-packages/cupy/_math/misc.py_choose_conv_methods rcCsdS)zJ .. seealso:: :func: `scipy.signal._signaltools._fftconv_faster` Tr)xhrrrrr$srfullcCs|jdkr td|jdkrtd|jdkrtd|j|jkr&||}}|}|}t|||}|dkr@t|||}|S|dkrLt|||}|Std) 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 emptyrz"v cannot be multidimensional arrayrr zUnsupported method)size ValueErrorr Zravelr _dot_convolve _fft_convolve)avrmethodoutrrrconvolve-s$        rcCs\d}|jd|jdkr||}}d|jdd}|jjdks&|jjdkr0tjjtjj}}n tjjtjj}}t||}|jd|jd}}t j j ||d} ||| } ||| } || | | } |dkrtd||d} }n!|dkr|dd|} | |}n|dkr|d|} }nt d | d | |f} |jd vrt | } | j|d d S)Nrrcrsamevalidz5acceptable mode flags are `valid`, `same`, or `full`..iuFcopy)shaper r cupyr ifftZrfftZirfft result_typecupyxZscipyZ next_fast_lenrZaroundastype)a1a2roffsetr r)r n1n2out_sizeZfa1Zfa2rstartendrrrrPs6       rc Cs d}|j|jkr||}}d|jd}t||}|j|j}}|j|dd}|j|dd}|dkrB||d}t||d}n%|dkr]|}|dd|}t||d||f}n |dkrg||d}|jd} t|||f| | f}t||ddd dd } | S) Nrrr Fr%rr"r#r)Zaxis) rr(r*r,padstridesrZ as_strided _dot_kernel) r-r.rr/r r0r1r2Zpad_sizeZstrideoutputrrrrws*      rcCs.trtjtj||||dS|j|||dS)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)rZ _is_fusingZ _call_ufunc_mathclip)rZa_minZa_maxrrrrr;s r;Z cupy_cbrt)e->ef->fd->dzout0 = cbrt(in0)zJElementwise cube root function. .. seealso:: :data:`numpy.cbrt` )docZ cupy_square)b->bB->Bh->hH->Hi->iI->Il->lL->Lq->qQ->Qr<r=r>F->FD->Dzout0 = in0 * in0zIElementwise square function. .. seealso:: :data:`numpy.square` Z 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); } Z cupy_signr@rArBrCrDrErFrGrHrIr<r=r>rJrKzout0 = (in0 > 0) - (in0 < 0)zElementwise sign function. It returns -1, 0, or 1 depending on the sign of the input. .. seealso:: :data:`numpy.sign` Zcupy_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))Z cupy_maximum??->?bb->bBB->Bhh->hHH->Hii->iII->Ill->lLL->Lqq->qQQ->QrLrMrNFF->FDD->Dzout0 = max(in0, in1)zTakes the maximum of two arrays elementwise. If NaN appears, it returns the NaN. .. seealso:: :data:`numpy.maximum` )ZOP_MAXrrmax)preambler?Z cutensor_opZ scatter_opzLout0 = (isnan(in0) | isnan(in1)) ? out0_type(NAN) : out0_type(min(in0, in1))Z cupy_minimumzout0 = min(in0, in1)zTakes the minimum of two arrays elementwise. If NaN appears, it returns the NaN. .. seealso:: :data:`numpy.minimum` )ZOP_MINrrminZ cupy_fmax)rOrPrQrRrSrTrUrVrWrXrY)rLout0 = fmax(in0, in1))rMr_)rNr_rZr[zTakes the maximum of two arrays elementwise. If NaN appears, it returns the other operand. .. seealso:: :data:`numpy.fmax` Z cupy_fmin)rOrPrQrRrSrTrUrVrWrXrY)rLout0 = fmin(in0, in1))rMr`)rNr`rZr[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); } Zcupy_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->fra)zdddd->dra)zFfff->Fra)zDddd->Draz out0 = in0zQElementwise nan_to_num function. .. seealso:: :func:`numpy.nan_to_num` )r]r?cCs|jdvr t|j}|jdvrd}n.|dur,|dur,|r%t|jnt|j}nt|r5tj}nt |rCtj d|dk}t ||S)NZFDZefdrr) charr(r lowerfinfor^r\isnannanisinfinfZ asanyarray)rr negrrr_check_nan_infs     rjTcCsft|tjs td|}n |rt|n|}|j}t||}t||d}t||d}t|||||dS)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` rFTr9) isinstancer(ZndarrayrZ empty_liker rj _nan_to_num)rr&rfZposinfZneginfrr rrr nan_to_nums    rndcCsTt|jjtjs |S|dkrt|jj}|j|}tt |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) issubclassr typer(ZcomplexfloatingnumpyrdZepsallabsoluteimagreal)rZtolfrrr real_if_closes  rx)Zfor_each_devicecCsLd}|d7}d}|r d}nd}|d7}|tjjj7}d}tj|||d|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; } Z cupy_interp)r])r(Z_sortingsearchZ _preambleZElementwiseKernel)Z is_complexZ in_paramsZ out_paramsr]coderrr_get_interp_kernels r{c Cs|jdks |jdkrtd|j|jkrtd|jdkr!td|jjs)tdt||}t|tj s?t d |tj |dur|dkrKtd t |}d}d}| tj }| tj }||;}||;}t|}||}||}t|d d|||dd|f}t|d d||ddf}|jjsJ|jjsJ|jjd krd nd }tj|j|d} tj||dd} |dur|dnt||j}|dur|d nt||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` rzxp 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 valuerr!Dd)r right)Zside)r rrflags c_contiguousr r(Z common_typeZcan_castZfloat64 TypeErrorformatabsr,ZargsortZ concatenater r emptyr'Z searchsortedarrayr{) rZxpfpleftr~ZperiodZx_dtypeZasort_xpZ out_dtyper8idxkernrrrinterpsL       (    r)r)N)TrkNN)ro)NNN).r(Zcupyx.scipy.fftr+rZ cupy._corerr:rZcupy.librrrZReductionKernelr7rrrrrr;sqrtZ sqrt_fixedZ create_ufuncZcbrtZsquarertfabsZ_unsigned_signZ _complex_signsignZ heavisideZ_float_preambleZ_float_maximummaximumZ_float_minimumminimumZfmaxZfminZ_nan_to_num_preamblermrjrnrxZ_utilmemoizer{rrrrrs      #'  "           *