o `^h4:@sddlZddlZddlZddlZddlmZddlmZddl m m Z ddl mZddlmZdgZdd ZGd ddZd d Ze jfd dZde jdddZdS)N)prod)_bspl) csr_array) _not_a_knot NdBSplinecCst|tjr tjStjS)z>Return np.complex128 for complex dtypes, np.float64 otherwise.)np issubdtypecomplexfloating complex128float64dtyperZ/home/air/shanriGPT/back/venv/lib/python3.10/site-packages/scipy/interpolate/_ndbspline.py _get_dtypesrc@sTeZdZdZddddZeddZedd Zddd d d Ze dddZ dS)raTensor product spline object. The value at point ``xp = (x1, x2, ..., xN)`` is evaluated as a linear combination of products of one-dimensional b-splines in each of the ``N`` dimensions:: c[i1, i2, ..., iN] * B(x1; i1, t1) * B(x2; i2, t2) * ... * B(xN; iN, tN) Here ``B(x; i, t)`` is the ``i``-th b-spline defined by the knot vector ``t`` evaluated at ``x``. Parameters ---------- t : tuple of 1D ndarrays knot vectors in directions 1, 2, ... N, ``len(t[i]) == n[i] + k + 1`` c : ndarray, shape (n1, n2, ..., nN, ...) b-spline coefficients k : int or length-d tuple of integers spline degrees. A single integer is interpreted as having this degree for all dimensions. extrapolate : bool, optional Whether to extrapolate out-of-bounds inputs, or return `nan`. Default is to extrapolate. Attributes ---------- t : tuple of ndarrays Knots vectors. c : ndarray Coefficients of the tensor-product spline. k : tuple of integers Degrees for each dimension. extrapolate : bool, optional Whether to extrapolate or return nans for out-of-bounds inputs. Defaults to true. Methods ------- __call__ design_matrix See Also -------- BSpline : a one-dimensional B-spline object NdPPoly : an N-dimensional piecewise tensor product polynomial N) extrapolatec Cst||\|_|_\|_|_|durd}t||_t||_ |jj d}|j j |kr3t d|dt |D]7}|j|}|j|}|j d|d} |j j || krnt d|d|j j |dt|d | d |d q7t|j j} tj|j | d |_ dS) NTrzCoefficients must be at least z -dimensional.rz,Knots, coefficients and degree in dimension z are inconsistent: got z coefficients for z knots, need at least z for k=.r )_preprocess_inputs_k _indices_k1d_t_len_tboolrrasarraycshapendim ValueErrorrangetklenrrascontiguousarray) selfr rr!rrdtdkdndtrrr__init__Ms6          zNdBSpline.__init__cCs t|jSN)tuplerr$rrrr!is z NdBSpline.kcs"tfddtjjdDS)Nc3s(|]}j|dj|fVqdSr+)rr.0r%r-rr ps&zNdBSpline.t..r)r,rrrr-rr-rr ms"z NdBSpline.t)nurc s|jjd}|dur |j}t|}|durtj|ftjd}n/tj|tjd}|jdks3|jd|krAt d|dt |j dt |dkrNt d|tj|t d}|j}|d |d }t|}|d |krut d |d ||jjjd k}|j}|r|jj|kr|jd }|t }||jd|d}tjfddjDtjd} jd } tj|jdd | fjd} t||j|j|j|||| | |j| | |jj} | |dd |jj|dS)a@Evaluate the tensor product b-spline at ``xi``. Parameters ---------- xi : array_like, shape(..., ndim) The coordinates to evaluate the interpolator at. This can be a list or tuple of ndim-dimensional points or an array with the shape (num_points, ndim). nu : array_like, optional, shape (ndim,) Orders of derivatives to evaluate. Each must be non-negative. Defaults to the zeroth derivivative. extrapolate : bool, optional Whether to exrapolate based on first and last intervals in each dimension, or return `nan`. Default is to ``self.extrapolate``. Returns ------- values : ndarray, shape ``xi.shape[:-1] + self.c.shape[ndim:]`` Interpolated values at ``xi`` rNr rz)invalid number of derivative orders nu = z for ndim = rz'derivatives must be positive, got nu = zShapes: xi.shape=z and ndim=r).N)r2csg|]}|jjqSr)ritemsize)r/sc1rr sz&NdBSpline.__call__..)rrrrrzerosintcrrrr"r anyfloatreshaper#rrkindviewravelstridesintpemptyrevaluate_ndbsplinerrr) r$xir1rrxi_shape was_complexccc1r _strides_c1num_c_troutrr5r__call__rsb         "zNdBSpline.__call__Tcstj|td}|jd}t||krtdt|d|dt|\}\}tfddt|D}|dd d } tj | d d dtj dd d d } t |||| \} } } t| | | fS) a Construct the design matrix as a CSR format sparse array. Parameters ---------- xvals : ndarray, shape(npts, ndim) Data points. ``xvals[j, :]`` gives the ``j``-th data point as an ``ndim``-dimensional array. t : tuple of 1D ndarrays, length-ndim Knot vectors in directions 1, 2, ... ndim, k : int B-spline degree. extrapolate : bool, optional Whether to extrapolate out-of-bounds values of raise a `ValueError` Returns ------- design_matrix : a CSR array Each row of the design matrix corresponds to a value in `xvals` and contains values of b-spline basis elements which are non-zero at this value. r r2z*Data and knots are inconsistent: len(t) = z for ndim = rc3s$|] }||dVqdSrNrr.r!len_trrr0s"z*NdBSpline.design_matrix..rN)r)rrr;rr"rrr,rcumprodrAcopyr _colloc_ndr)clsxvalsr r!rrrrc_shapecscstridesdataindicesindptrrrNr design_matrixs(   ( zNdBSpline.design_matrix)T) __name__ __module__ __qualname____doc__r*propertyr!r rL classmethodr[rrrrrs2  Qc Cs^t|ts td|dt|}zt|Wnty%|f|}Ynwtjdd|Dtjd}t||krHtdt|dt|dt|}t|D]~}t||}||}|j d |d }|d krrtd |d |j d krtd |d||d krtdd|dd|d|dt |d k rtd|dtt |||d dkrtd|dt|std|dqPtdd|D}ttt||}tj|tjdj} t|}dd|D} tj|t| ftd} | tjt|D]}||| |dt||f<qtj| tjd} || | | ffS)zHelpers: validate and preprocess NdBSpline inputs. Parameters ---------- k : int or tuple Spline orders t_tpl : tuple or array-likes Knots. z-Expect `t` to be a tuple of array-likes. Got z instead.cSsg|]}t|qSr)operatorindex)r/kirrrr7sz&_preprocess_inputs..r z len(t) = z != len(k) = rrrzSpline degree in dimension z cannot be negative.zKnot vector in dimension z must be one-dimensional.zNeed at least z knots for degree z in dimension zKnots in dimension z# must be in a non-decreasing order.z.Need at least two internal knots in dimension z should not have nans or infs.css|]}|dVqdSrMr)r/r'rrrr02z%_preprocess_inputs..cSsg|]}t|qSrr")r/tirrrr7<sN) isinstancer,rr" TypeErrorrrint32rrrdiffr:uniqueisfiniteall unravel_indexarangerrATrQrBmaxr;fillnan) r!t_tplrr%r&r'r(rrYrrOrrrrrs`             rc Ks t|jtjr$t||j|fi|}t||j|fi|}|d|S|jdkrj|jddkrjt |}t |jdD]+}|||dd|ffi|\|dd|f<}|dkrgt d|d|d|dq<|S|||fi|\}}|dkrt d|d |d|S) Ny?rerrz solver = z returns info =z for column rz returns info = ) rr rr _iter_solverealimagrr empty_likerr) absolver solver_argsrxryresjinforrrrwFs   .rwr}c srt}tddD}ztWnty!f|YnwtD](\}}tt|} | |krNtd| d|d|d|dd q&tfd dt|D} tjd d t j Dt d } t | | } |j} t| d |t| |d f}||}|tjkrtjt|d}d|vrd|d<|| |fi|}||| |d }t | |S)aConstruct an interpolating NdBspline. Parameters ---------- points : tuple of ndarrays of float, with shapes (m1,), ... (mN,) The points defining the regular grid in N dimensions. The points in each dimension (i.e. every element of the `points` tuple) must be strictly ascending or descending. values : ndarray of float, shape (m1, ..., mN, ...) The data on the regular grid in n dimensions. k : int, optional The spline degree. Must be odd. Default is cubic, k=3 solver : a `scipy.sparse.linalg` solver (iterative or direct), optional. An iterative solver from `scipy.sparse.linalg` or a direct one, `sparse.sparse.linalg.spsolve`. Used to solve the sparse linear system ``design_matrix @ coefficients = rhs`` for the coefficients. Default is `scipy.sparse.linalg.gcrotmk` solver_args : dict, optional Additional arguments for the solver. The call signature is ``solver(csr_array, rhs_vector, **solver_args)`` Returns ------- spl : NdBSpline object Notes ----- Boundary conditions are not-a-knot in all dimensions. css|]}t|VqdSr+rg)r/xrrrr0~rfzmake_ndbspl..z There are z points in dimension z , but order z requires at least rz points per dimension.c3s,|]}ttj|td|VqdS)r N)rrrr;r.r!pointsrrr0s$cSsg|]}|qSrr)r/xvrrrr7szmake_ndbspl..r Nratolgư>)r"r,rj enumerater atleast_1drrr itertoolsproductr;rr[rrr<sslspsolve functoolspartialrw)rvaluesr!r}r~rrEr%pointnumptsr rTmatrv_shape vals_shapevalscoefrrr make_ndbspl^s>         r)r)rrrbnumpyrmathrrscipy.sparse.linalgsparselinalgr scipy.sparser _bsplinesr__all__rrrgcrotmkrwrrrrrs     aL