`iit@ddlZddlZddlmZddlmZddlmZddlZ ddgZ ddgZ d Z ej e d Zd Zej ed d e DZdZej ed de DZdZdZddZdZdZddZddZGddZdS)N)internal) get_typename) csr_matrixdoublezthrust::complexintz long longa$ #include extern "C" { __global__ void find_interval( const double* t, const double* x, long long* out, int k, int n, bool extrapolate, int total_x) { int idx = blockDim.x * blockIdx.x + threadIdx.x; if(idx >= total_x) { return; } double xp = *&x[idx]; double tb = *&t[k]; double te = *&t[n]; if(isnan(xp)) { out[idx] = -1; return; } if((xp < tb || xp > te) && !extrapolate) { out[idx] = -1; return; } int left = k; int right = n; int mid; bool found = false; while(left < right && !found) { mid = ((right + left) / 2); if(xp > *&t[mid]) { left = mid + 1; } else if (xp < *&t[mid]) { right = mid - 1; } else { found = true; } } int default_value = left - 1 < k ? k : left - 1; int result = found ? mid + 1 : default_value + 1; while(result != n && xp >= *&t[result]) { result++; } out[idx] = result - 1; } } )z -std=c++11)codeoptionsaK #include #include #define COMPUTE_LINEAR 0x1 template __global__ void d_boor( const double* t, const T* c, const int k, const int mu, const double* x, const long long* intervals, T* out, double* temp, int num_c, int mode, int num_x) { int idx = blockDim.x * blockIdx.x + threadIdx.x; if(idx >= num_x) { return; } double xp = *&x[idx]; long long interval = *&intervals[idx]; double* h = temp + idx * (2 * k + 1); double* hh = h + k + 1; int ind, j, n; double xa, xb, w; if(mode == COMPUTE_LINEAR && interval < 0) { for(j = 0; j < num_c; j++) { out[num_c * idx + j] = CUDART_NAN; } return; } /* * Perform k-m "standard" deBoor iterations * so that h contains the k+1 non-zero values of beta_{ell,k-m}(x) * needed to calculate the remaining derivatives. */ h[0] = 1.0; for (j = 1; j <= k - mu; j++) { for(int p = 0; p < j; p++) { hh[p] = h[p]; } h[0] = 0.0; for (n = 1; n <= j; n++) { ind = interval + n; xb = t[ind]; xa = t[ind - j]; if (xb == xa) { h[n] = 0.0; continue; } w = hh[n - 1]/(xb - xa); h[n - 1] += w*(xb - xp); h[n] = w*(xp - xa); } } /* * Now do m "derivative" recursions * to convert the values of beta into the mth derivative */ for (j = k - mu + 1; j <= k; j++) { for(int p = 0; p < j; p++) { hh[p] = h[p]; } h[0] = 0.0; for (n = 1; n <= j; n++) { ind = interval + n; xb = t[ind]; xa = t[ind - j]; if (xb == xa) { h[mu] = 0.0; continue; } w = ((double) j) * hh[n - 1]/(xb - xa); h[n - 1] -= w; h[n] = w; } } if(mode != COMPUTE_LINEAR) { return; } // Compute linear combinations for(j = 0; j < num_c; j++) { out[num_c * idx + j] = 0; for(n = 0; n < k + 1; n++) { out[num_c * idx + j] = ( out[num_c * idx + j] + c[(interval + n - k) * num_c + j] * ((T) h[n])); } } } cg|]}d|d S)zd_boor<>).0 type_names t/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/scipy/interpolate/_bspline.py rs$DDD, ,,,DDD)rr name_expressionsa= #include template __global__ void compute_design_matrix( const int k, const long long* intervals, double* bspline_basis, double* data, U* indices, int num_intervals) { int idx = blockDim.x * blockIdx.x + threadIdx.x; if(idx >= num_intervals) { return; } long long interval = *&intervals[idx]; double* work = bspline_basis + idx * (2 * k + 1); for(int j = 0; j <= k; j++) { int m = (k + 1) * idx + j; data[m] = work[j]; indices[m] = (U) (interval - k + j); } } cg|]}d|d S)zcompute_design_matrix.s"DDDs< **DDDrz, Return np.complex128 for complex dtypes, np.float64 otherwise.)cupy issubdtypecomplexfloatingcomplex_float_rs r _get_dtyper+s) ud233}{rFctj|}t|j}||d}|r5tj|std|S)z~Convert the input into a C contiguous float array. NB: Upcasts half- and single-precision floats to double precision. F)copyz$Array must not contain infs or nans.)r%ascontiguousarrayr+rastypeisfiniteall ValueError)x check_finitedtyps r_as_float_arrayr6ss q!!A ag  D E""AADM!,,0022A?@@@ HrcF|jd|z dz }tj|tj}t t d} | |jddzdz dzfd|||||||jdft tj|jdd} tj |jdd|zdzz} t td |} | |jddzdz dzfd|||||||| | d|jdf dS) a1 Evaluate a spline in the B-spline basis. Parameters ---------- t : ndarray, shape (n+k+1) knots c : ndarray, shape (n, m) B-spline coefficients xp : ndarray, shape (s,) Points to evaluate the spline at. nu : int Order of derivative to evaluate. extrapolate : int, optional Whether to extrapolate to ouf-of-bounds points, or to return NaNs. out : ndarray, shape (s, m) Computed values of the spline at each of the input points. This argument is modified in-place. rr* find_intervalr:Nd_boor) shaper% empty_likeint64r#INTERVAL_MODULErnpprodempty D_BOOR_MODULE) tckxpnu extrapolateoutn intervalsinterval_kernelnum_ctemp d_boor_kernels r_evaluate_splinerSs=(  QA$*555I'HHOObhqkC'!+35vIq!["(1+FHHH  $$ % %E :bhqkQUQY/ 0 0D$]Ha@@MMBHQK#%)c13VaBIsD%8A; !!!!!rc|jd|z dz }tj|tj}t t d}||jddzdz dzfd|||||||jdftj|jdd|zdzz}t td|} | |jddzdz dzfd|d |d||d |dd|jdf tj|jd|dzztj } t td |} | |jddzdz dzfd|||| ||jdf| |fS) a Returns a design matrix in CSR format. Note that only indices is passed, but not indptr because indptr is already precomputed in the calling Python function design_matrix. Parameters ---------- x : array_like, shape (n,) Points to evaluate the spline at. t : array_like, shape (nt,) Sorted 1D array of knots. k : int B-spline degree. extrapolate : bool, optional Whether to extrapolate to ouf-of-bounds points. indices : ndarray, shape (n * (k + 1),) Preallocated indices of the final CSR array. Returns ------- data The data array of a CSR array of the b-spline design matrix. In each row all the basis elements are evaluated at the certain point (first row - x[0], ..., last row - x[-1]). indices The indices array of a CSR array of the b-spline design matrix. rr8r*r9r:r;r<r=Ncompute_design_matrix) r>r%r?r@r#rArDrEzerosfloat64DESIGN_MAT_MODULE) r3rFrHrKindicesrMrNrO bspline_basisrRdatadesign_mat_kernels r_make_design_matrixr]s8  QA444I'HHOOagaj3&*s24f9aKDFFFJqwqzQUQY788M$]Ha@@MMAGAJ$q(S02FdAq!YmQ71:    :agajAE*$, ? ? ?D(2G== S(1,46)]D'wqz#$$$ =rr8c r|dkrt|| S|\}}}||krtd|d|ddtdfdt|jddzz} t |D]}||dzd |d| dz z }||}|dd |z |dd |z z |z|z }t j|tj |f|jddzf}|dd }|dz}n%#t$r}td |z|d}~wwxYw|||fS) a Compute the spline representation of the derivative of a given spline Parameters ---------- tck : tuple of (t, c, k) Spline whose derivative to compute n : int, optional Order of derivative to evaluate. Default: 1 Returns ------- tck_der : tuple of (t2, c2, k2) Spline of order k2=k-n representing the derivative of the input spline. Notes ----- .. seealso:: :class:`scipy.interpolate.splder` See Also -------- splantider, splev, spalde rzOrder of derivative (n = z") must be <= order of spline (k = r<)NNr8zIThe spline has internal repeated knots and is not differentiable %d times) splantiderr2slicelenr>ranger%r_rBrVFloatingPointError) tckrMrFrGrHshjdtes rsplderrnFs2 1uu#r"""GAq!1uuj9:CFFFDEE E ++73qwqrr{#3#33 4BLq  A 1Q3r6Qq!AvY&BBB1RT6Qu1uX%*R/A28QD17122;$67778A!B$A FAA  LLL?BCDEEJK LL a7Ns1BD D1D,,D1c<|dkrt|| S|\}}}tdfdt|jddzz}t |D]}||dzd|d| dz z }||}t j|d| dz |zd|dzz }t jt jd|jddz||dg|dzzf}t j|d||df}|dz }|||fS) a Compute the spline for the antiderivative (integral) of a given spline. Parameters ---------- tck : tuple of (t, c, k) Spline whose antiderivative to compute n : int, optional Order of antiderivative to evaluate. Default: 1 Returns ------- tck_ader : tuple of (t2, c2, k2) Spline of order k2=k+n representing the antiderivative of the input spline. See Also -------- splder, splev, spalde Notes ----- The `splder` function is the inverse operation of this function. Namely, ``splder(splantider(tck))`` is identical to `tck`, modulo rounding error. .. seealso:: :class:`scipy.interpolate.splantider` rNr`r8)axisr8rar<) rnrdrer>rfr%cumsumrgrV)rirMrFrGrHrjrkrls rrcrcs7: 1uucA2GAq! ++'#agabbk"2"22 2B 1XX  qsttWq1"Q$x  V K%A2a4%2 A . . .!a% 8 GDJtagabbk122"w!A#' ( GAaD!QrUN # Q a7NrceZdZdZddZeddZedZeddZ edd Z dd Z d Z d Z ddZddZddZd S)BSplineaUnivariate spline in the B-spline basis. .. math:: S(x) = \sum_{j=0}^{n-1} c_j B_{j, k; t}(x) where :math:`B_{j, k; t}` are B-spline basis functions of degree `k` and knots `t`. Parameters ---------- t : ndarray, shape (n+k+1,) knots c : ndarray, shape (>=n, ...) spline coefficients k : int B-spline degree extrapolate : bool or 'periodic', optional whether to extrapolate beyond the base interval, ``t[k] .. t[n]``, or to return nans. If True, extrapolates the first and last polynomial pieces of b-spline functions active on the base interval. If 'periodic', periodic extrapolation is used. Default is True. axis : int, optional Interpolation axis. Default is zero. Attributes ---------- t : ndarray knot vector c : ndarray spline coefficients k : int spline degree extrapolate : bool If True, extrapolates the first and last polynomial pieces of b-spline functions active on the base interval. axis : int Interpolation axis. tck : tuple A read-only equivalent of ``(self.t, self.c, self.k)`` Notes ----- B-spline basis elements are defined via .. math:: B_{i, 0}(x) = 1, \textrm{if $t_i \le x < t_{i+1}$, otherwise $0$,} B_{i, k}(x) = \frac{x - t_i}{t_{i+k} - t_i} B_{i, k-1}(x) + \frac{t_{i+k+1} - x}{t_{i+k+1} - t_{i+1}} B_{i+1, k-1}(x) **Implementation details** - At least ``k+1`` coefficients are required for a spline of degree `k`, so that ``n >= k+1``. Additional coefficients, ``c[j]`` with ``j > n``, are ignored. - B-spline basis elements of degree `k` form a partition of unity on the *base interval*, ``t[k] <= x <= t[n]``. - Based on [1]_ and [2]_ .. seealso:: :class:`scipy.interpolate.BSpline` References ---------- .. [1] Tom Lyche and Knut Morken, Spline methods, http://www.uio.no/studier/emner/matnat/ifi/INF-MAT5340/v05/undervisningsmateriale/ .. [2] Carl de Boor, A practical guide to splines, Springer, 2001. Trctj||_tj||_tj|tj|_|dkr||_ nt||_ |jj d|jz dz }tj ||jj}||_|dkr tj|j|d|_|dkrt#d|jjdkrt#d||jdzkrt#dd|zdz|fztj|jdkrt#d t)tj|j||dzdkrt#d tj|jst#d |jjdkrt#d |jj d|krt#d t1|jj}tj|j||_dS)Nr*periodicrr8 Spline order cannot be negative.z$Knot vector must be one-dimensional.z$Need at least %d knots for degree %dr<z(Knots must be in a non-decreasing order.z!Need at least two internal knots.z#Knots should not have nans or infs.z,Coefficients must be at least 1-dimensional.z0Knots, coefficients and degree are inconsistent.)operatorindexrHr%asarrayrGr.rWrFrKboolr>r_normalize_axis_indexndimrpmoveaxisr2diffanyreuniquer0r1r+r)selfrFrGrHrKrprMrls r__init__zBSpline.__init__s?""a'>>> * $ $*D  #K00D  FLOdf $q (-dDFK@@ 199 ]46433DF q55?@@ @ 6;!  CDD D tvz>>CcAgq\*++ + Idf   ! & & ( ( IGHH H t{46!AaC%=)) * *Q . .@AA A}TV$$((** DBCC C 6;??KLL L 6<?Q  BDD D % %'b999rct|}|||c|_|_|_||_||_|S)zConstruct a spline without making checks. Accepts same parameters as the regular constructor. Input arrays `t` and `c` must of correct shape and dtype. )object__new__rFrGrHrKrp)clsrFrGrHrKrprs rconstruct_fastzBSpline.construct_fast/s? ~~c""!"Aq&  rc*|j|j|jfS)z@Equivalent to ``(self.t, self.c, self.k)`` (read-only). )rFrGrHrs rriz BSpline.tck;svtvtv%%rct|dz }t|}tj|ddz f|z||ddzf|zf}tj|}d||<|||||S)aoReturn a B-spline basis element ``B(x | t[0], ..., t[k+1])``. Parameters ---------- t : ndarray, shape (k+2,) internal knots extrapolate : bool or 'periodic', optional whether to extrapolate beyond the base interval, ``t[0] .. t[k+1]``, or to return nans. If 'periodic', periodic extrapolation is used. Default is True. Returns ------- basis_element : callable A callable representing a B-spline basis element for the knot vector `t`. Notes ----- The degree of the B-spline, `k`, is inferred from the length of `t` as ``len(t)-2``. The knot vector is constructed by appending and prepending ``k+1`` elements to internal knots `t`. .. seealso:: :class:`scipy.interpolate.BSpline` r<rr8rag?)rer6r%rg zeros_liker)rrFrKrHrGs r basis_elementzBSpline.basis_elementAs8 FFQJ A   GQqT!VIM1quQwj1n4 5 OA  !!!!Q;777rFc\t|d}t|d}|dkrt|}|dkrtd|jdks(t j|dd|ddkrtd|d t |d |zd zkrtd |d |dkr6|j|z dz }|||||z ||||z zz}d }nX|sVt|||ks*t|||j d|z dz krtd |d |j d}||dzz}|tj tj j kr tj }n tj}tj||dzz|}tjd|dz|dzz|dz|} t#|||||\} }t%| || f|j d|j d|z dz fS)a Returns a design matrix as a CSR format sparse array. Parameters ---------- x : array_like, shape (n,) Points to evaluate the spline at. t : array_like, shape (nt,) Sorted 1D array of knots. k : int B-spline degree. extrapolate : bool or 'periodic', optional Whether to extrapolate based on the first and last intervals or raise an error. If 'periodic', periodic extrapolation is used. Default is False. Returns ------- design_matrix : `csr_matrix` object Sparse matrix in CSR format where each row contains all the basis elements of the input row (first row = basis elements of x[0], ..., last row = basis elements x[-1]). Notes ----- In each row of the design matrix all the basis elements are evaluated at the certain point (first row - x[0], ..., last row - x[-1]). `nt` is a length of the vector of knots: as far as there are `nt - k - 1` basis elements, `nt` should be not less than `2 * k + 2` to have at least `k + 1` basis element. Out of bounds `x` raises a ValueError. .. note:: This method returns a `csr_matrix` instance as CuPy still does not have `csr_array`. .. seealso:: :class:`scipy.interpolate.BSpline` Trvrrwr8Nraz2Expect t to be a 1-D sorted array_like, but got t=.r<zLength t is not enough for k=FzOut of bounds w/ x = r*)r>)r6r{r2r}rBrresizeminmaxr>r%iinfoint32r@rDaranger]r) rr3rFrHrKrMnnz int_dtyperYindptrr[s r design_matrixzBSpline.design_matrixdslR At $ $ At $ $ * $ ${++K q55?@@ @ 6Q;;"&1223B300;+&'+++,, , q66AEAI  AQAAABB B * $ $ QA!AaDQqTAaD[11AKK ; VVad]]A171:>A+=)> > >9Q999:: : GAJ1q5k DJ''+ + + II I*Q!a%[ :::QQ1q5 11q5 JJJ, q!['  g 7F #71:qwqzA~12    rNc ||j}tj|}|j|j}}tjtj|tj}|dkrb|jj |j z dz }|j|j ||j|j z |j||j|j z zz}d}tj t|ttj|jjddf|jj}||||||||jjddz}|jdkrft+t-|j}||||jz|d|z|||jzdz}||}|S)a Evaluate a spline function. Parameters ---------- x : array_like points to evaluate the spline at. nu : int, optional derivative to evaluate (default is 0). extrapolate : bool or 'periodic', optional whether to extrapolate based on the first and last intervals or return nans. If 'periodic', periodic extrapolation is used. Default is `self.extrapolate`. Returns ------- y : array_like Shape is determined by replacing the interpolation axis in the coefficient array with the shape of `x`. Nr*rvr8Fr)rKr%rzr>r}r.ravelrWrFrrHrDrerrBrCrGr _evaluatereshaperplistrf transpose) rr3rJrKx_shapex_ndimrMrL dim_orders r__call__zBSpline.__call__s*  *K LOO'16  "4:a== E E E * $ $ df$q(Atv!dfTVn"49=:H"IIAKj VVSabb!12233 4DFLJJJ q"k3///kk'DFL$4455 9>>U38__--I& !112'6'"#&*++,- -- **C rc|jjjs|j|_|jjjs |j|_dSdSr`)rFflags c_contiguousr-rGrs r_ensure_c_contiguouszBSpline._ensure_c_contiguoussPv|( #V[[]]DFv|( #V[[]]DFFF # #rc t|j|j|jjdd|j||||dS)Nrra)rSrFrGrr>rH)rrIrJrKrLs rrzBSpline._evaluatesI Q!D!DRc ; ; ; ; ;rr8c<|j}t|jt|z }|dkr7tj|tj|f|jddzf}t|j||jf|}|j ||j |j dS)al Return a B-spline representing the derivative. Parameters ---------- nu : int, optional Derivative order. Default is 1. Returns ------- b : BSpline object A new instance representing the derivative. See Also -------- splder, splantider rr8NrKrp) rGrerFr%rgrVr>rnrHrrKrp)rrJrGctris r derivativezBSpline.derivatives& F [[3q66 ! 664:reagabbk&9:::;Adfa("--"t"CT5E(, 333 3rc\|j}t|jt|z }|dkr7tj|tj|f|jddzf}t|j||jf|}|j dkrd}n|j }|j |||j dS)a Return a B-spline representing the antiderivative. Parameters ---------- nu : int, optional Antiderivative order. Default is 1. Returns ------- b : BSpline object A new instance representing the antiderivative. Notes ----- If antiderivative is computed and ``self.extrapolate='periodic'``, it will be set to False for the returned instance. This is done because the antiderivative is no longer periodic and its correct evaluation outside of the initially given x interval is difficult. See Also -------- splder, splantider rr8NrvFr) rGrerFr%rgrVr>rcrHrKrrp)rrJrGrrirKs rantiderivativezBSpline.antiderivatives2 F [[3q66 ! 664:reagabbk&9:::;A$&!TV,b11  z ) )KK*K"t"C[(, 333 3rc ||j}|d}||kr||}}d}|jj|jz dz }|dkra|s_t ||j|j}t||j|}tj dttj |j jddf|j j}|j }t!|jt!|z }|dkr7tj|tj|f|jddzf}t'|j||jfd\} } } |dkr_|j|j|j|} } | | z }||z }t)||\}}|dkrmtj| | gtj}t/| | | jdd| |dd||d|dz }||z}nStjdttj |j jddf|j j}| || z |zz}||z}|| krltj||gtj}t/| | | jdd| |dd|||d|dz z }nBtj|| gtj}t/| | | jdd| |dd|||d|dz z }tj| | |z| z gtj}t/| | | jdd| |dd|||d|dz z }ngtj||gtj}t/| | | jdd| |d|||d|dz }||z}|| jddS) a Compute a definite integral of the spline. Parameters ---------- a : float Lower limit of integration. b : float Upper limit of integration. extrapolate : bool or 'periodic', optional whether to extrapolate beyond the base interval, ``t[k] .. t[-k-1]``, or take the spline to be zero outside of the base interval. If 'periodic', periodic extrapolation is used. If None (default), use `self.extrapolate`. Returns ------- I : array_like Definite integral of the spline over the interval ``[a, b]``. Nr8rarvr<r*rF)rKrrFrrHritemrr%rDrrBrCrGr>rrergrVrcdivmodrzrWrSr)rabrKsignrMrLrGrtacakatsteperiodinterval n_periodsleftr3integrals r integratezBSpline.integrateBsY*  *K !!### q55aqAD FK$& 1 $ * $ $[ $Atvdf~**,,--AAtvay~~''((Aj BGDFL,--.. /tv|EEE F [[3q66 ! 664:reagabbk&9:::;ADF 3Q77 B * $ $VDF^TVAYB"WF1uH$Xv66OIt1}}L"b>>> RZZ R%@%@!#Q5#777q6CF?I%:q#bgdfl1226F.G.G*H*H&I,0FL:::a"f&&ADABwwL!Qt|<<< RZZ R%@%@!#Q5#777CFSVO+L!R === RZZ R%@%@!#Q5#777CFSVO+L"b1frk!2$,GGG RZZ R%@%@!#Q5#777CFSVO+ aV4<888A RBHQK!rs ++++++)))))) ,- K 4l!$. /444 ` D DDeDDDFFF 2#DN O..#,...///      "!"!"!J222j9999x3333lr.r.r.r.r.r.r.r.r.r.r