o X۷i@sddlmZddlZddlmZmZddZGdddZGdd d eZGd d d eZ dd d Z GdddeZ dddZ ddZ ddZGdddeZdS)) annotationsN)_asarray_validatedfloat_factorialcCst|pt|do|jdkS)z-Check whether x is if a scalar type, or 0-dimshape)cupyisscalarhasattrr)xrrV/home/ubuntu/vllm_env/lib/python3.10/site-packages/cupyx/scipy/interpolate/_polyint.py _isscalarsr c@sXeZdZdZdddZddZddZd d Zd d ZdddZ dddZ dddZ dS)_Interpolator1DaCommon features in univariate interpolation. Deal with input data type and interpolation axis rolling. The actual interpolator can assume the y-data is of shape (n, r) where `n` is the number of x-points, and `r` the number of variables, and use self.dtype as the y-data type. Attributes ---------- _y_axis : Axis along which the interpolation goes in the original array _y_extra_shape : Additional shape of the input arrays, excluding the interpolation axis dtype : Dtype of the y-data arrays. It can be set via _set_dtype, which forces it to be float or complex Methods ------- __call__ _prepare_x _finish_y _reshape_y _reshape_yi _set_yi _set_dtype _evaluate NcCs2||_d|_d|_|dur|j|||ddSdS)Nxiaxis)_y_axis_y_extra_shapedtype_set_yi)selfryirrrr __init__*s z_Interpolator1D.__init__cCs$||\}}||}|||S)aEvaluate the interpolant Parameters ---------- x : cupy.ndarray The points to evaluate the interpolant Returns ------- y : cupy.ndarray Interpolated values. Shape is determined by replacing the interpolation axis in the original array with the shape of x Notes ----- Input values `x` must be convertible to `float` values like `int` or `float`. ) _prepare_x _evaluate _finish_y)rr x_shapeyrrr __call__1s  z_Interpolator1D.__call__cCst)zA Actually evaluate the value of the interpolator )NotImplementedErrorrr rrr rIz_Interpolator1D._evaluatecCs*t|}t|ddd}|j}||fS)z, Reshape input array to 1-D FT) check_finite as_inexact)rasarrayrrravel)rr rrrr rOs  z_Interpolator1D._prepare_xcCsz|||j}|jdkr;|dkr;t|}t|j}tt|||jtt|tt||j||}||}|S)zR Reshape interpolated y back to an N-D array similar to initial y rr)reshaperrlenlistrange transpose)rrrnxnysrrr rXs   z_Interpolator1D._finish_yFcCspt||jd}|r.|jdd|jkr.d|j|j d|jd|j f}td|||jddfS)z7 Reshape the updated yi to a 1-D array rNz%r + (N,) + %rzData must be of shape %s)rmoveaxisrrr ValueErrorr%)rrcheckok_shaperrr _reshape_yies z_Interpolator1D._reshape_yicCs|dur|j}|durtd|j}|dkrd}|dur(||t|kr(td||j|_|jd|j|j|jdd|_d|_||jdS)Nzno interpolation axis specifiedrr-z@x and y arrays must be equal in length along interpolation axis.r-)rr0rr&ndimrr _set_dtype)rrrrrrrr rps &z_Interpolator1D._set_yicCsJt|tjst|jtjrtj|_dS|r|jtjkr#tj|_dSdSN)r issubdtypecomplexfloatingr complex128float64)rrunionrrr r6s  z_Interpolator1D._set_dtype)NNN)F)NN) __name__ __module__ __qualname____doc__rrrrrr3rr6rrrr r s  r c@s eZdZdddZdddZdS) _Interpolator1DWithDerivativesNcCs||\}}|||}||jdf||j}|jdkr\|dkr\t|}t|j}dgtt|d||jdttd|dtt|d|j||d}| |}|S)a.Evaluate many derivatives of the polynomial at the point x. The function produce an array of all derivative values at the point x. Parameters ---------- x : cupy.ndarray Point or points at which to evaluate the derivatives der : int or None, optional How many derivatives to extract; None for all potentially nonzero derivatives (that is a number equal to the number of points). This number includes the function value as 0th derivative Returns ------- d : cupy.ndarray Array with derivatives; d[j] contains the jth derivative. Shape of d[j] is determined by replacing the interpolation axis in the original array with the shape of x rrr-) r_evaluate_derivativesr%rrrr&r'r(r))rr derrrr*r+r,rrr derivativess    z*_Interpolator1DWithDerivatives.derivativesr-cCs.||\}}|||d}||||S)aEvaluate one derivative of the polynomial at the point x Parameters ---------- x : cupy.ndarray Point or points at which to evaluate the derivatives der : integer, optional Which derivative to extract. This number includes the function value as 0th derivative Returns ------- d : cupy.ndarray Derivative interpolated at the x-points. Shape of d is determined by replacing the interpolation axis in the original array with the shape of x Notes ----- This is computed by evaluating all derivatives up to the desired one (using self.derivatives()) and then discarding the rest. r-)rrBr)rr rCrrrrr derivativesz)_Interpolator1DWithDerivatives.derivativer7r4)r=r>r?rDrErrrr rAs %rAcsFeZdZdZdddZdddZddd Zfd d Zd d ZZ S)BarycentricInterpolatoraThe interpolating polynomial for a set of points. Constructs a polynomial that passes through a given set of points. Allows evaluation of the polynomial, efficient changing of the y values to be interpolated, and updating by adding more x values. For reasons of numerical stability, this function does not compute the coefficients of the polynomial. The value `yi` need to be provided before the function is evaluated, but none of the preprocessing depends on them, so rapid updates are possible. Parameters ---------- xi : cupy.ndarray 1-D array of x-coordinates of the points the polynomial should pass through yi : cupy.ndarray, optional The y-coordinates of the points the polynomial should pass through. If None, the y values will be supplied later via the `set_y` method axis : int, optional Axis in the yi array corresponding to the x-coordinate values See Also -------- scipy.interpolate.BarycentricInterpolator NrcCst|||||tj|_||t|j|_dt |jt |j|_ tj |j}tj|jtjd}t|j||<t|j|_t|jD]}|j |j||j|}d|||<dt||j|<qMdS)Ng@rg?)r rastyperr;rset_yir&nmaxmin _inv_capacityrandom permutationzerosint32arangewir(prod)rrrrpermute inv_permuteidistrrr rs   z BarycentricInterpolator.__init__cCsD|dur d|_dS|j||j|d|||_|jj\|_|_dS)a Update the y values to be interpolated. The barycentric interpolation algorithm requires the calculation of weights, but these depend only on the xi. The yi can be changed at any time. Parameters ---------- yi : cupy.ndarray The y-coordinates of the points the polynomial should pass through. If None, the y values will be supplied later. axis : int, optional Axis in the yi array corresponding to the x-coordinate values Nr)rrrr3rrJr)rrrrrr rIs  zBarycentricInterpolator.set_yic Cs |dur|jdur td|j|dd}t|j|f|_n |jdur'td|j}t|j|f|_t|j|_|j dC_ |j }t |j|_ ||j d|<t ||jD]/}|j d||j |j||jd|9<t |j |jd||j||j |<qW|j dC_ dS)aAdd more x values to the set to be interpolated. The barycentric interpolation algorithm allows easy updating by adding more points for the polynomial to pass through. Parameters ---------- xi : cupy.ndarray The x-coordinates of the points that the polynomial should pass through yi : cupy.ndarray, optional The y-coordinates of the points the polynomial should pass through. Should have shape ``(xi.size, R)``; if R > 1 then the polynomial is vector-valued If `yi` is not given, the y values will be supplied later. `yi` should be given if and only if the interpolator has y values specified NzNo previous yi value to update!T)r1zNo update to yi provided!r.)rr0r3rvstackrJ concatenaterr&rSrPr(rMrT)rrrold_nold_wijrrr add_xis(   0 zBarycentricInterpolator.add_xics t|S)acEvaluate the interpolating polynomial at the points x. Parameters ---------- x : cupy.ndarray Points to evaluate the interpolant at Returns ------- y : cupy.ndarray Interpolated values. Shape is determined by replacing the interpolation axis in the original array with the shape of x Notes ----- Currently the code computes an outer product between x and the weights, that is, it constructs an intermediate array of size N by len(x), where N is the degree of the polynomial. )superrr __class__rr rAs z BarycentricInterpolator.__call__cCs|jdkrtjd|jf|jd}|S|dtjf|j}|dk}d||<|j|}t||j tj |dddtjf}t |}t |dkrZt |ddkrX|j |dd}|S|j |d||dd<|S)NrrG.r-r.r) sizerrPrYrnewaxisrrSdotrsumnonzeror&)rr pczrYrrr rYs   &  z!BarycentricInterpolator._evaluateNrr7) r=r>r?r@rrIr_rr __classcell__rrrar rFs    +rFcCst|||d|S)aConvenience function for polynomial interpolation. Constructs a polynomial that passes through a given set of points, then evaluates the polynomial. For reasons of numerical stability, this function does not compute the coefficients of the polynomial. Parameters ---------- xi : cupy.ndarray 1-D array of coordinates of the points the polynomial should pass through yi : cupy.ndarray y-coordinates of the points the polynomial should pass through x : scalar or cupy.ndarray Points to evaluate the interpolator at axis : int, optional Axis in the yi array corresponding to the x-coordinate values Returns ------- y : scalar or cupy.ndarray Interpolated values. Shape is determined by replacing the interpolation axis in the original array with the shape x See Also -------- scipy.interpolate.barycentric_interpolate rc)rF)rrr rrrr barycentric_interpolateks#rnc@s,eZdZdZd ddZddZd dd ZdS) KroghInterpolatoraInterpolating polynomial for a set of points. The polynomial passes through all the pairs (xi,yi). One may additionally specify a number of derivatives at each point xi; this is done by repeating the value xi and specifying the derivatives as successive yi values Allows evaluation of the polynomial and all its derivatives. For reasons of numerical stability, this function does not compute the coefficients of the polynomial, although they can be obtained by evaluating all the derivatives. Parameters ---------- xi : cupy.ndarray, length N x-coordinate, must be sorted in increasing order yi : cupy.ndarray y-coordinate, when a xi occurs two or more times in a row, the corresponding yi's represent derivative values axis : int, optional Axis in the yi array corresponding to the x-coordinate values. rc Cst|||||tj|_|||_|jj\|_ |_ tj |j d|j f|j d}|jd|d<tj |j |j f|j d}t d|j D]}d}||krh|||||krh|d7}||krh|||||ksV|d8}|j|t||d<t ||D]=}||||krtd|dkr||||||||||d<q}||d||||||||d<q}|||||<qD||_dS)Nr-rGrz Elements if `xi` can't be equal.)rArrHrr;rr3rrrJrYrPrr(rr0rj) rrrrrjVkkr,rWrrr rs, *. zKroghInterpolator.__init__cCsd}tjt||jf|jd}||jdtjddf7}td|jD]}||j |d}||}||ddtjf|j|7}q"|S)Nr-rGr) rrPr&rYrrjrer(rJr)rr pirirqwrrr rs"zKroghInterpolator._evaluateNc Cs|j}|j}|dur |j}t|t|f}t|t|f}d|d<tjt||jf|jd}||jdtjddf7}td|D].}||j |d||d<||d||d||<|||ddtjf|j|7}qBtjt ||dt||f|jd} | d|dddddf|jd|dtjddf7<|| d<td|D]B}td||dD],} ||| d|| d|| || <| ||| ddtjf| || | |<q| |t |9<qd| |ddddf<| d|S)Nr-rrG) rJrYrrPr&rrjrer(rrKr) rr rCrJrYrrrsrirqcnrWrrr rBs.$$@(. z'KroghInterpolator._evaluate_derivativesrr7)r=r>r?r@rrrBrrrr ros   rocCsPt|||d}|dkr||St|r|j||dS|j|t|dd|S)aLConvenience function for polynomial interpolation Parameters ---------- xi : cupy.ndarray x-coordinate yi : cupy.ndarray y-coordinates, of shape ``(xi.size, R)``. Interpreted as vectors of length R, or scalars if R=1 x : cupy.ndarray Point or points at which to evaluate the derivatives der : int or list, optional How many derivatives to extract; None for all potentially nonzero derivatives (that is a number equal to the number of points), or a list of derivatives to extract. This number includes the function value as 0th derivative axis : int, optional Axis in the yi array corresponding to the x-coordinate values Returns ------- d : cupy.ndarray If the interpolator's values are R-D then the returned array will be the number of derivatives by N by R. If `x` is a scalar, the middle dimension will be dropped; if the `yi` are scalars then the last dimension will be dropped See Also -------- scipy.interpolate.krogh_interpolate rcr)rCr-)ror rErDramax)rrr rCrPrrr krogh_interpolates !rxcCs|j}t|t|kr@t|ddd|dddD]\}}|dkr(||kr(nq|jdkr<|j|kr x[-1]``. Anything that is not a 2-element tuple (e.g., list or ndarray, regardless of shape) is taken to be a single array-like argument meant to be used for both bounds as ``below, above = fill_value, fill_value``. Using a two-element tuple or ndarray requires ``bounds_error=False``. - If "extrapolate", then points outside the data range will be extrapolated. assume_sorted : bool, optional If False, values of `x` can be in any order and they are sorted first. If True, `x` has to be an array of monotonically increasing values. See Also -------- scipy.interpolate.interp1d Notes ----- Calling `interp1d` with NaNs present in input values results in undefined behaviour. Input values `x` and `y` must be convertible to `float` values like `int` or `float`. If the values in `x` are not unique, the resulting behavior is undefined and specific to the choice of `kind`, i.e., changing `kind` will change the behavior for duplicates. linearr.TNFc Cstj||||d||_||_|dvrddddd|} d}nt|tr)|} d}n |dvr3td |tj||jd }tj||jd }|sXtj |d d } || }tj || |d}|j dkrat d |j dkrjt dt |jjtjsx|tj}||j |_||_||j|_||_~~||_|dvrrd} |dkrd|_|jd|_|jdd|jdd|_|jj|_n'|dkrd|_|jd|_|jdd|jdd|_|jj|_n|dkr d|_d|_t|jtj |_!|jj"|_t#|r |$tj%t |jd|f}n|dkr:d|_d|_t|jtj |_!|jj"|_t#|r9|$t |jd|tj%f}nttjttf} |jj| voQ|jj| v} | oZ|jj dk} | obt#| } | rl|jj&|_nu|jj'|_no| d} d}|j|j}}| dkrt(|j}|)r|j|}|j*dkrt dt+t,|jt-|jt.|j}d}t(|j)rt/|j}d}ddl0m1}|||| dd|_2|r|jj3|_n|jj4|_t.|j| krt d| ||_5dS)z- Initialize a 1-D linear interpolation class.rc)zeroslinear quadraticcubicrr-spline)rnearest nearest-uppreviousnextz8%s is unsupported: Use fitpack routines for other types.)copystable)kindz,the x array must have exactly one dimension.z-the y array must have at least one dimension.rleftg@Nr.rrightrrFz`x` array is all-nanT)make_interp_spline)rqr!z,x and y arrays must have at least %d entries)6r r bounds_errorrrintrrarrayargsorttaker5r0 issubclassrtypeinexactrHr;rrr3_yr _kind_sidex_bdsrb _call_nearest_call_ind nextafterinf_x_shift_call_previousnextr0_check_and_update_bounds_error_for_extrapolationnan_call_linear_np _call_linearisnananyrdlinspacenanminnanmaxr& ones_likecupyx.scipy.interpolater_spline_call_nan_spline _call_spliner)rr rrrrrr assume_sortedorderindminval np_dtypescond rewrite_nanxxyymasksxrrrr rws                           zinterp1d.__init__cCs|jS)zThe fill value.)_fill_value_origrrrr r r zinterp1d.fill_valuecCst|r |d|_nj|jjd|j|jj|jdd}t|dkr(d}t|trWt|dkrWt |dt |dg}d}t dD]}t |||||||<qGnt |}t ||dgd}|\|_ |_d|_|jdurvd|_||_dS) NTr-rr4r)zfill_value (below)zfill_value (above)rF)rr _extrapolaterrrr&rtuplerr#r(r_fill_value_below_fill_value_aboverr)rrbroadcast_shape below_abovenamesiirrr rs:         cCs|jrtdd|_dS)Nz.Cannot extrapolate and raise at the same time.F)rr0rrrr r1s z9interp1d._check_and_update_bounds_error_for_extrapolationcCst||j|jSr7)rinterpr rrx_newrrr r7szinterp1d._call_linear_npc Cst|j|}|dt|jdt}|d}|}|j|}|j|}|j|}|j|}||||dddf} | ||dddf|} | S)Nr-)r searchsortedr clipr&rHrr) rr x_new_indiceslohix_lox_hiy_loy_hislopey_newrrr r;s    zinterp1d._call_linearcCs@tj|j||jd}|dt|jdtj}|j |}|S)z5 Find nearest neighbor interpolated y_new = f(x_new).siderr-) rrrrrr&r rHintpr)rrrrrrr rXs zinterp1d._call_nearestcCsVtj|j||jd}t|j|j}|d|j|tj }|j ||jd}|S)z6Use previous/next neighbor of x_new, y_new = f(x_new).rr-) rrrrr&r rrrHrr)rrrxnrrrr ris  zinterp1d._call_previousnextcCs ||Sr7)rrrrr rzs zinterp1d._call_splinecCs||}tj|d<|S)N.)rrr)rroutrrr r}s  zinterp1d._call_nan_splinecCsNt|}|||}|js%||\}}t|dkr%|j||<|j||<|Srl)rr#rr _check_boundsr&rr)rrr below_bounds above_boundsrrr rs     zinterp1d._evaluatecCs||jdk}||jdk}|jr*|r*|t|}td|d|jdd|jrF|rF|t|}td|d|jdd||fS)aCheck the inputs for being in the bounds of the interpolated data. Parameters ---------- x_new : array Returns ------- out_of_bounds : bool array The mask on x_new of values that are out of the bounds. rr.z A value (z=) in x_new is below the interpolation range's minimum value (z).z=) in x_new is above the interpolation range's maximum value ()r rrrargmaxr0)rrrrbelow_bounds_valueabove_bounds_valuerrr rs    zinterp1d._check_bounds)r=r>r?r@rrrpropertyrsetterrrrrrrrrrrrrr r+s(K    rru)rr) __future__rrcupyx.scipy._lib._utilrrr r rArFrnrorxrrrrrrr s D & Z*