o X۷i@s ddlmZddlZddlmZddlZejdkr ddlmZnddl mZddl Z ddl m Z ddl mZddlmZmZmZmZmZmZd d Zd d Zd dZddZddZ d*ddZddZddZdZdgZe j edddeDd gd!Z!d"d#Z"d$d%Z#d+d&d'd(d)Z$dS),) annotationsN)prod2)normalize_axis_index)sparse)spsolve) _get_dtype_as_float_array_get_module_funcINTERVAL_MODULE D_BOOR_MODULEBSplinecCstt|}|ddkrtd||dd}||d| d}tj|df|d||df|df}|S)zSGiven data x, construct the knot vector w/ not-a-knot BC. cf de Boor, XIII(12).z Odd degree for now only. Got %s.r)cupyasarray ValueErrorr_)xkmtrW/home/ubuntu/vllm_env/lib/python3.10/site-packages/cupyx/scipy/interpolate/_bspline2.py _not_a_knots    ,rcCs$tj|df|||df|fS)zBConstruct a knot vector appropriate for the order-k interpolation.rr)rr)rrrrr_augknt%s$rcCst|}t|}|ddkr$t|}|dd|ddd8<t|}t|d|}|||| <td|D]/}||||||d d|||d<|| |d|||d|| |<q>|S)z$Returns vector of nodes on a circle.rrrrN)rcopylendiffzerosrange)rrxcndxrirrr_periodic_knots*s     ..r&cCsRt|tr'|dkrdt|fg}|S|dkr!dt|fg}|Std||S)NclampedrnaturalrzUnknown boundary condition : %s) isinstancestrrr r)deriv target_shaperrr_convert_string_aliases<s  r-c CsV|dur zt|\}}Wnty}zd}t||d}~wwgg}}t||S)Nz^Derivatives, `bc_type`, should be specified as a pair of iterables of pairs of (order, value).)zip TypeErrorrr atleast_1d)r+ordsvalsemsgrrr_process_deriv_specGs   r5Tc#Cs~|dus |dks |dkrd\}}n%t|tr||}}nz|\}}Wnty5} ztd|| d} ~ wwt|}t||j}t||}t||}t ||d}|dkrftj |d|ddd sftd |j |j dkrxtd |j |j |d d|ddkrtd |jd ks|d d|ddkrtd|dkrtdd|||fDrtdtj||df}t|} tj| t| jd} tj|| ||dS|d kr|dur|dur|dustdtj|d||df}t|} tj| t| jd} tj|| ||dSt|}|dkr#|dur#td|durv|durq|durq|dkr=t||}n9|dkrk|d d|ddd}tj|df|d |d d|df|d f}n t||}nt||}t||}|dkrtd|jd ks|d d|ddkrtd|j |j |d krtd|j |j |d f|d||ks|d|| krtd||dkrt|||||St||j d d}t|\} } | j d} t||j d d}t|\}}|j d}|j }|j |d }||| |kr$td||| |f|j dkrBtj|f|j d dtd} tj|| ||dSt |||}| dksS|dkrtjd|d ftd}d }tj!||ftd}tj!d|jd}t"t#d|}tj!dtj$d}t"t%d}|d d!|tj|d|df|||d"df| dkrtj&|dg|jd}tj| |ftd}t'| D].\}}|d d |||t(||||||dd f |d}|d|d |||||d f<qt)*t)+||g}|dkrM|d|d<tj&|dg|jd}tj||ftd}t'|D].\}}|d d |||t(||||||dd f |d}|d|d |||||d f<qt)*|t)+|g}t,|j d d} tj!|| f|jd}!| dkro| -d| |!d| <|-d| |!| ||<|dkr|-d| |!||d<t.|!jtj/rt0||!j1t0||!j2d#}"nt0||!}"t|"-|f|j d d}"t||"|S)$aiCompute the (coefficients of) interpolating B-spline. Parameters ---------- x : array_like, shape (n,) Abscissas. y : array_like, shape (n, ...) Ordinates. k : int, optional B-spline degree. Default is cubic, ``k = 3``. t : array_like, shape (nt + k + 1,), optional. Knots. The number of knots needs to agree with the number of data points and the number of derivatives at the edges. Specifically, ``nt - n`` must equal ``len(deriv_l) + len(deriv_r)``. bc_type : 2-tuple or None Boundary conditions. Default is None, which means choosing the boundary conditions automatically. Otherwise, it must be a length-two tuple where the first element (``deriv_l``) sets the boundary conditions at ``x[0]`` and the second element (``deriv_r``) sets the boundary conditions at ``x[-1]``. Each of these must be an iterable of pairs ``(order, value)`` which gives the values of derivatives of specified orders at the given edge of the interpolation interval. Alternatively, the following string aliases are recognized: * ``"clamped"``: The first derivatives at the ends are zero. This is equivalent to ``bc_type=([(1, 0.0)], [(1, 0.0)])``. * ``"natural"``: The second derivatives at ends are zero. This is equivalent to ``bc_type=([(2, 0.0)], [(2, 0.0)])``. * ``"not-a-knot"`` (default): The first and second segments are the same polynomial. This is equivalent to having ``bc_type=None``. * ``"periodic"``: The values and the first ``k-1`` derivatives at the ends are equivalent. axis : int, optional Interpolation axis. Default is 0. check_finite : bool, optional Whether to check that the input arrays contain only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Default is True. Returns ------- b : a BSpline object of the degree ``k`` and with knots ``t``. N not-a-knotperiodicNNUnknown boundary condition: %srrgV瞯<)atolzAFirst and last points does not match while periodic case expectedz(Shapes of x {} and y {} are incompatiblerzExpect x to not have duplicatesz1Expect x to be a 1D strictly increasing sequence.css|]}|duVqdS)Nr).0_rrr sz%make_interp_spline..z6Too much info for k=0: t and bc_type can only be None.dtypeaxisz0Too much info for k=1: bc_type can only be None.zOFor periodic case t is constructed automatically and can not be passed manuallyrg@Expect non-negative k.'Expect t to be a 1-D sorted array_like.zGot %d knots, need at least %d.Out of bounds w/ x = %s.zPThe number of derivatives at boundaries does not match: expected %s, got %s + %s)rrd_boor find_intervalrrFy?)3r)r*r/rrrrndimr moveaxisallclosesizeshapeformatanyrascontiguousarrayrr@r construct_fastoperatorindexNotImplementedErrorr&rr_make_periodic_spliner-r5r float design_matrixemptyr r int64r array enumerateintrvstack csr_matrixrreshape issubdtypecomplexfloatingrrealimag)#ryrrbc_typerB check_finitederiv_lderiv_rr3c deriv_l_ords deriv_l_valsnleft deriv_r_ords deriv_r_valsnrightr#ntmatrtempnum_cdummy_cout d_boor_kernel intervals_bcinterval_kernelx0rowsjrleftextradimrhscoefrrrmake_interp_splineTs*3          &            *&            (   (      rc#Cs|dus|dkr d\}}n%t|tr||}}nz|\}}Wnty1}ztd||d}~wwt||jdd}t|\}} |jd} t||jdd}t|\} } | jd} |j}|j|d}t||jdd}t|\}} |jd} t||jdd}t|\} } | jd} |j}|j|d}||| | ksJtj |tj d}t t d}||jdd dd fd |||||d |jdftj |dftd}tj t|t|jddf|jd}t|jdd}t |jdd |d}t td |}||jdd dd fd |||d|||||d|jdf tj||ftd}| }tt|D])}||}||d |d|d |d|d||||||df<q3tj dtj d}| dkr|d|d<tj|dg|jd}t|D].\}}|dd|||t||||||ddf |d}|d|d|||||df<q| dkr|d|d<tj|dg|jd}t| D]6\}}|dd|||t||||||ddf |d}| t||}|d|d|||||df<qt|jdd}tj ||f|jd} | dkr!| d|| d| <|d|| | || <| dkr>| d|| || d<ddlm}!|!|| }"t|"|f|jdd}"t||"|S)z Construct the interpolating spline spl(x) = y with *full* linalg. Only useful for testing, do not call directly! This version is O(N**2) in memory and O(N**3) in flop count. Nr7r9r:rrr?rG)rFrrFrHr)solve)r)r*r/rr-rNr5rMr empty_likerZr r rYrWrrr@r r r!r[r\r]r` cupy.linalgrrQr )#rrerrrfrhrir3rkrlrmrnrorpr#rq intervalsryrurvrtrsrwAoffsetr|r}rxrzrrowr~rrrrrr_make_interp_spline_full_matrix]s               H  (  (      rcCs*|j}t|||}tjdd|dtd}d}tj|j|d|ftd} tjd| jd} tt d| } tj |d|df} tj |||dgtj d} tj|d||dftd}t |dD]F}| dd || ||d| | | ||ddf |d|d||d|df<||| df|d|dd|d|ddd8<qctt||g}t|jdd}tj||d|ftd}d|d|dddf<|jdkr||dn|d|f||ddddf<t||}t|||df|jdd}tj|||d |d S) Nrrr?)rrrFrrrHrIr8) extrapolaterB)rMr rXrr rWrYr@r r rr[rZr!rr^r_rrNr`rrQrR)rrerrrBr#rrrsrtrurvrwrzrxr{rmatr_csrr~rrrrrrVsH   D   ( rVa typedef long long ssize_t ; /* * Compute the parameters of the Givens transformation: LAPACK's dlartg * replacement. * * Naive computation, following * https://www.netlib.org/lapack/explore-3.1.1-html/dlartg.f.html * */ template __global__ void dlartg(T *f, T *g, T *cs, T *sn, T *r) { if (*g == 0) { *cs = 1.0; *sn = 0.0; *r = *f; } else if (*f == 0){ *cs = 0.0; *sn = 1.0; *r = *g; } else { T piv = fabs(*f); if (piv >= *g) { T sq = *g / *f; *r = piv * sqrt(1.0 + sq*sq); } else { T sq = *f / *g; *r = *g * sqrt(1.0 + sq*sq); } *cs = *f / *r; *sn = *g / *r; } } /* * Givens-rotate a pair [f, g] -> [f_out, g_out] */ template __global__ void fprota(T c, T s, T f, T g, T *f_out, T *g_out) { *f_out = c*f + s*g; *g_out = -s*f + c*g; } // 2D array indexing: R(i, j) #define IDX(i, j, ncols) ( (ncols)*(i) + (j) ) /* * Solve the LSQ problem ||y - A@c||^2 via QR factorization. * * QR factorization follows FITPACK: we reduce A row-by-row by Givens * rotations. To zero out the lower triangle, we use in the row `i` * and column `j < i`, the diagonal element in that column. That way, the * sequence is (here `[x]` are the pair of elements to Givens-rotate) * * [x] x x x x x x x x x x x x x x x x x x x * [x] x x x -> 0 [x] x x -> 0 [x] x x -> 0 x x x -> 0 x x x * 0 x x x 0 [x] x x 0 0 x x 0 0 [x] x 0 0 x x * 0 x x x 0 x x x 0 [x] x x 0 0 [x] x 0 0 0 x * * The matrix A has a special structure: each row has at most (k+1) * consecutive non-zeros, so we only store them. * * On exit, the return matrix, also of shape (m, k+1), contains * elements of the upper triangular matrix `R[i, i: i + k + 1]`. * * When we process the element (i, j), we store the rotated row in R[i, :], * and *shift it to the left*, so that the the diagonal element is always in * the zero-th place. This way, the process above becomes * * [x] x x x x x x x x x x x x x x x x x x x * [x] x x x -> [x] x x - -> [x] x x - -> x x x - -> x x x - * x x x - [x] x x - x x - - [x] x - - x x - - * x x x - x x x - [x] x x - [x] x - - x - - - * * The most confusing part is that when rotating the row `i` with a row `j` * above it, the offsets differ: for the upper row `j`, `R[j, 0]` is the * diagonal element, while for the row `i`, `R[i, 0]` is the element being * annihilated. * * NB. This row-by-row Givens reduction process follows FITPACK: * https://github.com/scipy/scipy/blob/maintenance/1.11.x/scipy/interpolate/fitpack/fpcurf.f#L112-L161 * * A possibly more efficient way could be to note that all data points which * lie between two knots all have the same offset: if * `t[i] < x_1 .... x_s < t[i+1]`, the `s-1` corresponding rows form an * `(s-1, k+1)`-sized "block". * Then a blocked QR implementation could look like * https://people.sc.fsu.edu/~jburkardt/f77_src/band_qr/band_qr.f * * We implement the FITPACK procedure here, even though it is inherently * sequential. * * The `startrow` optional argument accounts for the scenatio with a two-step * factorization. Namely, the preceding rows are assumed to be already * processed and are skipped. * This is to account for the scenario where we append new rows to an already * triangularized matrix. * * Note that this routine MODIFIES `a` & `y` in-place. * */ __global__ void qr_reduce(double *a, int m, int nz, // a(m, nz), packed ssize_t *offset, // offset(m) int nc, // dense would be a(m, nc) double *y, int ydim1, // y(m, ydim1) int startrow=1 ) { for (ssize_t i=startrow; i < m; i++) { ssize_t oi = offset[i]; ssize_t i_nc = i < nc ? i : nc; // the diagonal in row i for (ssize_t j=oi; j < nc; j++) { // rotate only the lower diagonal if (j >= i_nc) { break; } // in dense format: diag a1[j, j] vs a1[i, j] double c, s, r; dlartg(&a[IDX(j, 0, nz)], // R(j, 0) &a[IDX(i, 0, nz)], // R(i, 0) &c, &s, &r); // rotate l.h.s. a[IDX(j, 0, nz)] = r; //R(j, 0) = r; for (ssize_t l=1; l < nz; ++l) { double r0, r1; fprota(c, s, a[IDX(j, l, nz)], a[IDX(i, l, nz)], &r0, &r1); a[IDX(j, l, nz)] = r0; a[IDX(i, l-1, nz)] = r1; } a[IDX(i, nz-1, nz)] = 0.0; // rotate r.h.s. for (ssize_t l=0; l < ydim1; ++l) { double r0, r1; fprota(c, s, y[IDX(j, l, ydim1)], y[IDX(i, l, ydim1)], &r0, &r1); y[IDX(j, l, ydim1)] = r0; // y(j, l) = r0; y[IDX(i, l, ydim1)] = r1; // y(i, l) = r1; } } if (i < nc) { offset[i] = i; } } // for(i = ... } double)z -std=c++17cCsg|]}d|dqS)zdlartg<>r)r< type_namerrr s r qr_reduce)codeoptionsname_expressionsc Csddlm}|jd}tj||dtjd}||||d|\}}|||d} |dd|d} |jd|d} |jdksDJ||dddf} t t d} | d d | ||d| | | | jddft | | | }| | |fS) zSolve for the LSQ spline coeffs given x, y and knots. `y` is always 2D: for 1D data, the shape is ``(m, 1)``. `w` is always 1D: one weight value per `x` value. r)_make_design_matrixrr?TNrrrH) _bsplinerrNrrYrZr`rrJr QR_MODULEfpback)rrerrwrrindicesrRrncy_wrccrrr _lsq_solve_qrs&       rc Cs|j\}}|jd|jdksJt|d|}||ddf||ddf||ddf<t|dddD]2}t|||}||d|df||d||dfjdd}|||||df||df<q8|S)zBacksubsitution solve upper triangular banded `R @ c = y.` `R` is in the "packed" format: `R[i, :]` is `a[i, i:i+k+1]` rNr.rrrA)rNr zeros_liker!minsum) rrrer=nzrjr%nelsummrrrrs ,2"rqr)methodc Cs:t||}t||}t||}|durt||}nt|}t|}t||j}t||d}|jdksEt|dd|dddkrIt d|jdkrRt d|j d|dkr_t d|dkrgt d|jdks|t|dd|dddkrt d |j |j dkrt d |j d |j d |dkrt|||k||| kBrt d||j |j krt d |j d|j d |dkrt d|dt|dd|dddkrt d|j |d}t |j dd} | d| } t|| |||\} } } | |f|j dd} t| } tj|| ||dS)aConstruct a BSpline via an LSQ (Least SQuared) fit. The result is a linear combination .. math:: S(x) = \sum_j c_j B_j(x; t) of the B-spline basis elements, :math:`B_j(x; t)`, which minimizes .. math:: \sum_{j} \left( w_j \times (S(x_j) - y_j) \right)^2 Parameters ---------- x : array_like, shape (m,) Abscissas. y : array_like, shape (m, ...) Ordinates. t : array_like, shape (n + k + 1,). Knots. Knots and data points must satisfy Schoenberg-Whitney conditions. k : int, optional B-spline degree. Default is cubic, ``k = 3``. w : array_like, shape (m,), optional Weights for spline fitting. Must be positive. If ``None``, then weights are all equal. Default is ``None``. axis : int, optional Interpolation axis. Default is zero. check_finite : bool, optional Whether to check that the input arrays contain only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Default is True. Returns ------- b : a BSpline object of the degree ``k`` with knots ``t``. See Also -------- scipy.interpolate.make_lsq_spline BSpline : base class representing the B-spline objects make_interp_spline : a similar factory function for interpolating splines Notes ----- The number of data points must be larger than the spline degree ``k``. Knots ``t`` must satisfy the Schoenberg-Whitney conditions, i.e., there must be a subset of data points ``x[j]`` such that ``t[j] < x[j] < t[j+k+1]``, for ``j=0, 1,...,n-k-2``. Nrrrz'Expect x to be a 1-D sorted array_like.zExpect x to be a 1-D sequence.zNeed more x points.rCrDz1Expect t to be a 1D strictly increasing sequence.z Shapes of x z and y z are incompatiblerEz and w rzmethod=z is not supported.z,Expect x to be a 1D non-decreasing sequence.rA)r r ones_likerSrTrrJrKrPrrNrMrr`rrQr rR) rrerrrrBrgrrr~yyr=rjrrrmake_lsq_splinesP 8      * *&     r)r6NNrT)r6NrT)% __future__rrSmathrnumpy __version__numpy.core.multiarrayrnumpy.lib.array_utilsr cupyx.scipyrcupyx.scipy.sparse.linalgr cupyx.scipy.interpolate._bsplinerr r r r r rrr&r-r5rrrV QR_KERNELTYPES RawModulerrrrrrrrsP             <,"