`i]_|ddgZddlZddlZddlmZddlmZd dZdZ dZ Gd dZ d d ej fd Z dS)RegularGridInterpolatorinterpnNmake_interp_splinePchipInterpolatorct|trt|dkr|d}t|trtj|}t|}t d|D]-}||j|djkrtd.tj|djt|fzt}t|D] \}}||d|f< nNtj |}|j dkr/|| dd}n| d|}|S)zM Convert a tuple of coordinate arrays to a (..., ndim)-shaped array. rz,coordinate arrays do not have the same shapedtype.N) isinstancetuplelencpbroadcast_arraysrangeshape ValueErroremptyfloat enumerate asanyarrayndimreshape)pointsrpnjitems p/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/scipy/interpolate/_rgi.py_ndim_coords_from_arraysr" sL&%  S[[A%5%5&%  2   ( FFq! D DAtzQqTZ'' BDDD(!A$*F ~5UCCC || " "GAt!F36NN "v&& ;!  |A..D11 Mcg}g}t|D]\}}tj|t}tj|dd|ddksxtj|dd|ddkr>||tj|}tj|}ntd|z||t|t|fS)Nr r r zCThe points in dimension %d must be strictly ascending or descending) rrasarrayrallappendflipascontiguousarrayrr)rdescending_dimensionsgridirs r! _check_pointsr-$s  D&!!1 Jq & & &vaeafn%% 3vaeafn%% 3%,,Q///GAJJ(++ .012333 A ;;344 44r#ct||jkr&tdt||jfzt|D]\}}t j|jdkstd|z|j|t|ks-tdt||j||fzdS)N7There are %d point arrays, but values has %d dimensionsr z0The points in dimension %d must be 1-dimensionalz1There are %d points and %d values in dimension %d)rrrrrr%r)rvaluesr,rs r!_check_dimensionalityr19s 6{{V[  &),Vfk(BCDD D&!!LL1z!}}!Q&&-/0122 2|A#a&&((,/21vvv|A.JKLL L) LLr#ceZdZdZdddddZeeZddgezZdde j fd Z d Z d Z d Zd ZdZddZdZdZdZdZedZedZdZdZdS)ra Interpolation on a regular or rectilinear grid in arbitrary dimensions. The data must be defined on a rectilinear grid; that is, a rectangular grid with even or uneven spacing. Linear and nearest-neighbor interpolations are supported. After setting up the interpolator object, the interpolation method may be chosen at each evaluation. Parameters ---------- points : tuple of ndarray of float, with shapes (m1, ), ..., (mn, ) The points defining the regular grid in n dimensions. The points in each dimension (i.e. every elements of the points tuple) must be strictly ascending or descending. values : ndarray, shape (m1, ..., mn, ...) The data on the regular grid in n dimensions. Complex data can be acceptable. method : str, optional The method of interpolation to perform. Supported are "linear", "nearest", "slinear", "cubic", "quintic" and "pchip". This parameter will become the default for the object's ``__call__`` method. Default is "linear". bounds_error : bool, optional If True, when interpolated values are requested outside of the domain of the input data, a ValueError is raised. If False, then `fill_value` is used. Default is True. fill_value : float or None, optional The value to use for points outside of the interpolation domain. If None, values outside the domain are extrapolated. Default is ``cp.nan``. Notes ----- Contrary to scipy's `LinearNDInterpolator` and `NearestNDInterpolator`, this class avoids expensive triangulation of the input data by taking advantage of the regular grid structure. In other words, this class assumes that the data is defined on a *rectilinear* grid. If the input data is such that dimensions have incommensurate units and differ by many orders of magnitude, the interpolant may have numerical artifacts. Consider rescaling the data before interpolating. Examples -------- **Evaluate a function on the points of a 3-D grid** As a first example, we evaluate a simple example function on the points of a 3-D grid: >>> from cupyx.scipy.interpolate import RegularGridInterpolator >>> import cupy as cp >>> def f(x, y, z): ... return 2 * x**3 + 3 * y**2 - z >>> x = cp.linspace(1, 4, 11) >>> y = cp.linspace(4, 7, 22) >>> z = cp.linspace(7, 9, 33) >>> xg, yg ,zg = cp.meshgrid(x, y, z, indexing='ij', sparse=True) >>> data = f(xg, yg, zg) ``data`` is now a 3-D array with ``data[i, j, k] = f(x[i], y[j], z[k])``. Next, define an interpolating function from this data: >>> interp = RegularGridInterpolator((x, y, z), data) Evaluate the interpolating function at the two points ``(x,y,z) = (2.1, 6.2, 8.3)`` and ``(3.3, 5.2, 7.1)``: >>> pts = cp.array([[2.1, 6.2, 8.3], ... [3.3, 5.2, 7.1]]) >>> interp(pts) array([ 125.80469388, 146.30069388]) which is indeed a close approximation to >>> f(2.1, 6.2, 8.3), f(3.3, 5.2, 7.1) (125.54200000000002, 145.894) **Interpolate and extrapolate a 2D dataset** As a second example, we interpolate and extrapolate a 2D data set: >>> x, y = cp.array([-2, 0, 4]), cp.array([-2, 0, 2, 5]) >>> def ff(x, y): ... return x**2 + y**2 >>> xg, yg = cp.meshgrid(x, y, indexing='ij') >>> data = ff(xg, yg) >>> interp = RegularGridInterpolator((x, y), data, ... bounds_error=False, fill_value=None) >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> ax = fig.add_subplot(projection='3d') >>> ax.scatter(xg.ravel().get(), yg.ravel().get(), data.ravel().get(), ... s=60, c='k', label='data') Evaluate and plot the interpolator on a finer grid >>> xx = cp.linspace(-4, 9, 31) >>> yy = cp.linspace(-4, 9, 31) >>> X, Y = cp.meshgrid(xx, yy, indexing='ij') >>> # interpolator >>> ax.plot_wireframe(X.get(), Y.get(), interp((X, Y)).get(), rstride=3, cstride=3, alpha=0.4, color='m', label='linear interp') >>> # ground truth >>> ax.plot_wireframe(X.get(), Y.get(), ff(X, Y).get(), rstride=3, cstride=3, ... alpha=0.4, label='ground truth') >>> plt.legend() >>> plt.show() See Also -------- interpn : a convenience function which wraps `RegularGridInterpolator` scipy.ndimage.map_coordinates : interpolation on grids with equal spacing (suitable for e.g., N-D image resampling) References ---------- [1] Python package *regulargrid* by Johannes Buchner, see https://pypi.python.org/pypi/regulargrid/ [2] Wikipedia, "Trilinear interpolation", https://en.wikipedia.org/wiki/Trilinear_interpolation [3] Weiser, Alan, and Sergio E. Zarantonello. "A note on piecewise linear and multilinear table interpolation in many dimensions." MATH. COMPUT. 50.181 (1988): 189-196. https://www.ams.org/journals/mcom/1988-50-181/S0025-5718-1988-0917826-0/S0025-5718-1988-0917826-0.pdf r )slinearcubicquinticpchiplinearnearestTc||jvrtd|z||jvr|||||_||_t |\|_|_| ||_ | |j|j | |j ||_ |jr"tj||j|_ dSdS)NMethod '%s' is not definedaxis) _ALL_METHODSr_SPLINE_METHODS_validate_grid_dimensionsmethod bounds_errorr-r+_descending_dimensions _check_valuesr0r1_check_fill_value fill_valuerr()selfrr0rBrCrGs r!__init__z RegularGridInterpolator.__init__s * * *9FBCC C t+ + +  * *66 : : : (1>v1F1F. 4.((00  ""49dk:::00jII  & L'&t/JKKKDKKK L Lr#c&t||dSN)r1)rHr+r0s r!r1z-RegularGridInterpolator._check_dimensionalitysdF+++++r#c |j|}t|D]K\}}ttj|}||krt d|d|d|d|dzd LdS)Nz There are z points in dimension z , but method z requires at least r z points per dimension.)_SPLINE_DEGREE_MAPrrr atleast_1dr)rHrrBkr,pointrs r!rAz1RegularGridInterpolator._validate_grid_dimensionss  #F +!&)) B BHAur}U++,,Dqyy "Ad"A"A"A"A06"A"A%&qS"A"A"ABBB B Br#c t|SrK)r-)rHrs r!r-z%RegularGridInterpolator._check_pointssV$$$r#ctj|jtjs|t }|SrK)r issubdtyper inexactastyper)rHr0s r!rEz%RegularGridInterpolator._check_valuess0}V\2:66 *]]5))F r#c|Ttj|j}t|dr+tj||jdst d|S)Nr same_kind)castingzDfill_value must be either 'None' or of a type compatible with values)rr%r hasattrcan_castr)rHr0rGfill_value_dtypes r!rFz)RegularGridInterpolator._check_fill_valuesu  !!z*55; (( EK 0&,(3555 E!"DEEEr#Nc|j|k}||jn|}||jvrtd|z||\}}}}}|dkr4||j\}} ||| } nv|dkr4||j\}} ||| } n<||jvr3|r| |j || ||} |j s|j |j | |<|j| jkr|d}tj|tj| } | |dd|jj|dzS)a Interpolation at coordinates. Parameters ---------- xi : cupy.ndarray of shape (..., ndim) The coordinates to evaluate the interpolator at. method : str, optional The method of interpolation to perform. Supported are "linear" and "nearest". Default is the method chosen when the interpolator was created. Returns ------- values_x : cupy.ndarray, shape xi.shape[:-1] + values.shape[ndim:] Interpolated values at `xi`. See notes for behaviour when ``xi.ndim == 1``. Notes ----- In the case that ``xi.ndim == 1`` a new axis is inserted into the 0 position of the returned array, values_x, so its shape is instead ``(1,) + values.shape[ndim:]``. Examples -------- Here we define a nearest-neighbor interpolator of a simple function >>> import cupy as cp >>> x, y = cp.array([0, 1, 2]), cp.array([1, 3, 7]) >>> def f(x, y): ... return x**2 + y**2 >>> data = f(*cp.meshgrid(x, y, indexing='ij', sparse=True)) >>> from cupyx.scipy.interpolate import RegularGridInterpolator >>> interp = RegularGridInterpolator((x, y), data, method='nearest') By construction, the interpolator uses the nearest-neighbor interpolation >>> interp([[1.5, 1.3], [0.3, 4.5]]) array([2., 9.]) We can however evaluate the linear interpolant by overriding the `method` parameter >>> interp([[1.5, 1.3], [0.3, 4.5]], method='linear') array([ 4.7, 24.3]) Nr<r9r:).Nr )rBr?r _prepare_xi _find_indicesT_evaluate_linear_evaluate_nearestr@rAr+_evaluate_splinerCrGrrwherenanrr0r) rHxirBis_method_changedxi_shapernans out_of_boundsindicesnorm_distancesresults r!__call__z RegularGridInterpolator.__call__sd!K61 &F * * *9FBCC C262B2B22F2F/HdD- X  &*&8&8&>&> #G^**7NCCFF y &*&8&8&>&> #G^++G^DDFF t+ + +  B..ty&AAA**2v66F  4T_%@$(OF= ! 9v{ " " ?D$//~~hssmdk.?.FFGGGr#c nt|j}t||}|jdt|jkr t d|jdd||j}|d|d}t j|t}t j |j }|d }|ddD]}t j ||||j rt|j D]z\}}t jt j|j|d|kt j||j|dkst d|z{d} n||j } ||||| fS) Nrr z.The requested sample points xi have dimension z0 but this RegularGridInterpolator has dimension r rr 8One of the requested xi is out of bounds in dimension %d)rr+r"rrrrr%risnanr_copy logical_orrCr logical_andr&_find_out_of_bounds) rHrerrgis_nansrhis_nanr,rris r!r]z#RegularGridInterpolator._prepare_xiTs49~~ %bt 4 4 4 8B<3ty>> ) )M " MMFJMMNN N8 ZZHRL ) ) Z% ( ( ((2,,.qz  abbk . .F M$ - - - -   ;!"$ = =1~bfTYq\!_-A&B&B&(fQ$)A,r2B-B&C&CEE=$&8:;&<====!MM 44RT::M8T466r#ctdfd|jjt|z zz}d|D}d|D}t ||}t ||}t jt ||}tjdg} |D]B} t | \} } tj |j| } | D] }| ||z} | | z} C| S)NrKcg|]}d|z Sr ).0yis r! z.ws@@@2B@@@r#cg|]}|dzSrzr{)r|r,s r!r~z.xs0001Q000r#g) slicer0rrzip itertoolsproductrarrayr%)rHrjrkvsliceshift_norm_distances shift_indiceszipped1zipped2 hypercubevalueh edge_indicesweightstermws r!r`z(RegularGridInterpolator._evaluate_linearrs++'4;+;c'll+J"KK A@@@@00000 g344m^44 %s7G'<'<= " ! !A$'G !L':dk,788D " "& !DLEE r#cjdt||D}|jt|S)NcNg|]"\}}tj|dk||dz#S)g?r )rrc)r|r,r}s r!r~z=RegularGridInterpolator._evaluate_nearest..sB>>>q"8B"HaQ//>>>r#)rr0r)rHrjrkidx_ress r!raz)RegularGridInterpolator._evaluate_nearests=>> #G^ < <>>>{5>>**r#c |jdkr|d|jf}|j\}}t t |jj}|d|ddd||dz}|j|}|dkr|j}n|j }|j |} |dz } ||j | ||dd| f| } |g|jj|dR} tj | |jj} t |D]K}| |df}t | dz ddD]#}||j |||||f| }$|| |df<L| S)Nr r r8r .)rrsizerrrr0 transpose _do_pchip_do_spline_fitrMr+rrr )rHrerBmraxesaxxr0 _eval_funcrOlast_dim first_valuesrrlr folded_valuesr,s r!rbz(RegularGridInterpolator._evaluate_splines 7a<<QL))Bx1U4;+,,--2A2htttntABBx'&&s++ W  JJ,J  #F +q5!z$)H"5"("$QQQ[/"#%% +T[&qrr*++%t{'8999q + +A)C0M8A:r2.. . .!+ 49Q<+8+-ad8+,!.!. +F1c6NN r#cBt|||d}||}|S)Nr)rOr>rxyptrO local_interpr0s r!rz&RegularGridInterpolator._do_spline_fits,)!Q!!<<< b!! r#c@t||d}||}|S)Nrr=rrs r!rz!RegularGridInterpolator._do_pchips*(AA666 b!! r#c~g}g}t||jD]\}}tj||dz }tj|d|jdz |||||dz||z }tj|dk|||z |z d}||||fS)Nr r)rr+r searchsortedcliprr'rc) rHrerjrkrr+r,denom norm_dists r!r^z%RegularGridInterpolator._find_indicess2ty)) - -GAta((1,A GAq$)a- + + + NN1   QK$q')E!a$q'kU-BAFFI  ! !) , , , ,&&r#ctj|jdt}t ||jD]#\}}|||dkz }|||dkz }$|S)Nr r rr )rzerosrboolrr+)rHrerirr+s r!ruz+RegularGridInterpolator._find_out_of_boundssg"(1+d;;; 2ty)) * *GAt Qa[ (M Qb\ )MMr#rK)__name__ __module__ __qualname____doc__rMlistkeysr@r?rrdrIr1rAr-rErFrmr]r`rarb staticmethodrrr^rur{r#r!rrFs~JJ\&'q1MMd-224455Oi(?:L.6TFLLLL ,,,BBB%%% JHJHJHJHX777<<+++ 555n\ \ '''&r#r9Tc  |dvrtd|j}t||kr!tdt||fzt|\}}t ||t |t|}|jdt|kr,td|jdt|fz|rt|jD]p\} } tj tj || d| ktj | || dkstd| zq|dvrt||||| } | |Sd S) a Multidimensional interpolation on regular or rectilinear grids. Strictly speaking, not all regular grids are supported - this function works on *rectilinear* grids, that is, a rectangular grid with even or uneven spacing. Parameters ---------- points : tuple of cupy.ndarray of float, with shapes (m1, ), ..., (mn, ) The points defining the regular grid in n dimensions. The points in each dimension (i.e. every elements of the points tuple) must be strictly ascending or descending. values : cupy.ndarray of shape (m1, ..., mn, ...) The data on the regular grid in n dimensions. Complex data can be acceptable. xi : cupy.ndarray of shape (..., ndim) The coordinates to sample the gridded data at method : str, optional The method of interpolation to perform. Supported are "linear", "nearest", "slinear", "cubic", "quintic" and "pchip". bounds_error : bool, optional If True, when interpolated values are requested outside of the domain of the input data, a ValueError is raised. If False, then `fill_value` is used. fill_value : number, optional If provided, the value to use for points outside of the interpolation domain. If None, values outside the domain are extrapolated. Returns ------- values_x : ndarray, shape xi.shape[:-1] + values.shape[ndim:] Interpolated values at `xi`. See notes for behaviour when ``xi.ndim == 1``. Notes ----- In the case that ``xi.ndim == 1`` a new axis is inserted into the 0 position of the returned array, values_x, so its shape is instead ``(1,) + values.shape[ndim:]``. If the input data is such that input dimensions have incommensurate units and differ by many orders of magnitude, the interpolant may have numerical artifacts. Consider rescaling the data before interpolation. Examples -------- Evaluate a simple example function on the points of a regular 3-D grid: >>> import cupy as cp >>> from cupyx.scipy.interpolate import interpn >>> def value_func_3d(x, y, z): ... return 2 * x + 3 * y - z >>> x = cp.linspace(0, 4, 5) >>> y = cp.linspace(0, 5, 6) >>> z = cp.linspace(0, 6, 7) >>> points = (x, y, z) >>> values = value_func_3d(*cp.meshgrid(*points, indexing='ij')) Evaluate the interpolating function at a point >>> point = cp.array([2.21, 3.12, 1.15]) >>> print(interpn(points, values, point)) [12.63] See Also -------- RegularGridInterpolator : interpolation on a regular or rectilinear grid in arbitrary dimensions (`interpn` wraps this class). cupyx.scipy.ndimage.map_coordinates : interpolation on grids with equal spacing (suitable for e.g., N-D image resampling) )r9r:r5r6r7r8z{interpn only understands the methods 'linear', 'nearest', 'slinear', 'cubic', 'quintic' and 'pchip'. You provided {method}.r/ror zcThe requested sample points xi have dimension %d, but this RegularGridInterpolator has dimension %drrp)rBrCrGN) rrrr-r1r"rrr_rrtr&r) rr0rerBrCrGrr+r*r,rinterps r!rrsj*** %&& & ;D 6{{T&),Vd(;<== =#0"7"7D $''' ""3t99 5 5 5B x|s4yy  (+-8B<T*CDEE E8bdOO 8 8DAq>"&aq"9"9"$&d1gbk)9":":<< 8 "356"7888 8 NNN(6B4>@@@vbzz ONr#rK)__all__rcupyr!cupyx.scipy.interpolate._bspline2rcupyx.scipy.interpolate._cubicrr"r-r1rrdrr{r#r!rs $i 0@@@@@@<<<<<<6555* L L Lllllllll^ (0dvyyyyyyr#