o ְ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 = a0 dot_productcCsL|jdks |jdkrtd|jjdvs|jjdvrdSt|||r$dSdS)Nz&Only 1d inputs are supported currentlybuidirectfft)ndimNotImplementedErrordtypekind_fftconv_faster)in1in2moderC/home/ubuntu/.local/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 arrayr r zUnsupported method)size ValueErrorr ravelr _dot_convolve _fft_convolve)avrmethodoutrrrconvolve-s$        r#cCs\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)shaperrcupyr ifftrfftirfft result_typecupyxscipy next_fast_lenraroundastype)a1a2roffsetr r.rn1n2out_sizefa1fa2r"startendrrrrPs6       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$)axis) rr-r1r6padstridesr as_strided _dot_kernel) r7r8rr9rr:r;r<pad_sizestrideoutputrrrrws*      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")r _is_fusing _call_ufunc_mathclip)ra_mina_maxr"rrrrMs rM 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->QrQrRrSF->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_signrVrWrXrYrZr[r\r]r^r_rQrRrSr`razout0 = (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->QrerfrgFF->FDD->Dzout0 = max(in0, in1)zTakes the maximum of two arrays elementwise. If NaN appears, it returns the NaN. .. seealso:: :data:`numpy.maximum` )OP_MAXrrmax)preamblerT 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_MINrrmin cupy_fmax)rirjrkrlrmrnrorprqrrrs)reout0 = fmax(in0, in1))rfr)rgrrtruzTakes the maximum of two arrays elementwise. If NaN appears, it returns the other operand. .. seealso:: :data:`numpy.fmax` cupy_fmin)rirjrkrlrmrnrorprqrrrs)reout0 = fmin(in0, in1))rfr)rgrrtruzTakes 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` )rxrTcCs|jdvr t|j}|jdvrd}n.|dur,|dur,|r%t|jnt|j}nt|r5tj}nt |rCtj d|dk}t ||S)NFDefdrr$) charr-rlowerfinfor}rwisnannanisinfinf asanyarray)rrnegrrr_check_nan_infs     rTcCsft|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` rFTrI) isinstancer-ndarrayr empty_likerr _nan_to_num)rr+rposinfneginfr"rrrr nan_to_nums    rdcCsTt|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) issubclassrtyper-complexfloatingnumpyrepsallabsoluteimagreal)rtolfrrr real_if_closes  r)for_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; } cupy_interp)rx)r-_sortingsearch _preambleElementwiseKernel) is_complex in_params out_paramsrxcoderrr_get_interp_kernels rc 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 valuer$r&Dd)rright)side)r rrflags c_contiguousr r- common_typecan_castfloat64 TypeErrorformatabsr6argsort concatenaterremptyr, searchsortedarrayr) rxpfpleftrperiodx_dtypeasort_xp out_dtyperHidxkernrrrinterpsL       (    r)r)N)TrNN)r)NNN).r-cupyx.scipy.fftr2r cupy._corerrLrcupy.librrReductionKernelrErrr#rrrMsqrt sqrt_fixed create_ufunccbrtsquarerfabs_unsigned_sign _complex_signsign heaviside_float_preamble_float_maximummaximum_float_minimumminimumfmaxfmin_nan_to_num_preamblerrrr_utilmemoizerrrrrrs      #'  "           *