a BCCf{@sddgZddlZddlZddlZddlmmZddl m Z ddl m Z ddl mZmZddlmZdd lmZdd lmZd d Zd dZGdddZddejfddZdS)RegularGridInterpolatorinterpnN)_ndim_coords_from_arraysPchipInterpolator)evaluate_linear_2d find_indicesmake_interp_spline)RectBivariateSpline) make_ndbsplcCsg}g}t|D]\}}tj|td}t|dd|ddkst|dd|ddkrx||t|}n td|t|}||qt |t |fS)NdtyperzCThe points in dimension %d must be strictly ascending or descending) enumeratenpasarrayfloatallappendflip ValueErrorZascontiguousarraytuple)pointsdescending_dimensionsgridiprR/var/www/html/django/DPS/env/lib/python3.9/site-packages/scipy/interpolate/_rgi.py _check_pointss     r!cCst||jkr$tdt||jft|D]R\}}t|jdksPtd||j|t|ks,tdt||j||fq,dS)N7There are %d point arrays, but values has %d dimensionsrz0The points in dimension %d must be 1-dimensionalz1There are %d points and %d values in dimension %d)lenndimrrrrshape)rvaluesrrrrr _check_dimensionality(s r'c@seZdZdZddddddddZhdZhdZeeZ dd ge Z dd e j fd d d d dZ d.ddZddZddZddZddZd/d dddZddZddZd d!Zd"d#Zd$d%Zed&d'Zed(d)Zd*d+Zd,d-Zd S)0ra Interpolator 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, nearest-neighbor, spline 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 : array_like, shape (m1, ..., mn, ...) The data on the regular grid in n dimensions. Complex data is accepted. .. deprecated:: 1.13.0 Complex data is deprecated with ``method="pchip"`` and will raise an error in SciPy 1.15.0. This is because ``PchipInterpolator`` only works with real values. If you are trying to use the real components of the passed array, use ``np.real`` on ``values``. 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 ``np.nan``. solver : callable, optional Only used for methods "slinear", "cubic" and "quintic". Sparse linear algebra solver for construction of the NdBSpline instance. Default is the iterative solver `scipy.sparse.linalg.gcrotmk`. .. versionadded:: 1.13 solver_args: dict, optional Additional arguments to pass to `solver`, if any. .. versionadded:: 1.13 Methods ------- __call__ Attributes ---------- grid : tuple of ndarrays The points defining the regular grid in n dimensions. This tuple defines the full grid via ``np.meshgrid(*grid, indexing='ij')`` values : ndarray Data values at the grid. method : str Interpolation method. fill_value : float or ``None`` Use this value for out-of-bounds arguments to `__call__`. bounds_error : bool If ``True``, out-of-bounds argument raise a ``ValueError``. Notes ----- Contrary to `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. .. versionadded:: 0.14 The 'slinear'(k=1), 'cubic'(k=3), and 'quintic'(k=5) methods are tensor-product spline interpolators, where `k` is the spline degree, If any dimension has fewer points than `k` + 1, an error will be raised. .. versionadded:: 1.9 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. **Choosing a solver for spline methods** Spline methods, "slinear", "cubic" and "quintic" involve solving a large sparse linear system at instantiation time. Depending on data, the default solver may or may not be adequate. When it is not, you may need to experiment with an optional `solver` argument, where you may choose between the direct solver (`scipy.sparse.linalg.spsolve`) or iterative solvers from `scipy.sparse.linalg`. You may need to supply additional parameters via the optional `solver_args` parameter (for instance, you may supply the starting value or target tolerance). See the `scipy.sparse.linalg` documentation for the full list of available options. Alternatively, you may instead use the legacy methods, "slinear_legacy", "cubic_legacy" and "quintic_legacy". These methods allow faster construction but evaluations will be much slower. 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 scipy.interpolate import RegularGridInterpolator >>> import numpy as np >>> def f(x, y, z): ... return 2 * x**3 + 3 * y**2 - z >>> x = np.linspace(1, 4, 11) >>> y = np.linspace(4, 7, 22) >>> z = np.linspace(7, 9, 33) >>> xg, yg ,zg = np.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 = np.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 = np.array([-2, 0, 4]), np.array([-2, 0, 2, 5]) >>> def ff(x, y): ... return x**2 + y**2 >>> xg, yg = np.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(), yg.ravel(), data.ravel(), ... s=60, c='k', label='data') Evaluate and plot the interpolator on a finer grid >>> xx = np.linspace(-4, 9, 31) >>> yy = np.linspace(-4, 9, 31) >>> X, Y = np.meshgrid(xx, yy, indexing='ij') >>> # interpolator >>> ax.plot_wireframe(X, Y, interp((X, Y)), rstride=3, cstride=3, ... alpha=0.4, color='m', label='linear interp') >>> # ground truth >>> ax.plot_wireframe(X, Y, ff(X, Y), rstride=3, cstride=3, ... alpha=0.4, label='ground truth') >>> plt.legend() >>> plt.show() Other examples are given :ref:`in the tutorial `. See Also -------- NearestNDInterpolator : Nearest neighbor interpolator on *unstructured* data in N dimensions LinearNDInterpolator : Piecewise linear interpolator on *unstructured* data in N dimensions 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 :doi:`10.1090/S0025-5718-1988-0917826-0` r)slinearcubicquinticpchipslinear_legacy cubic_legacyquintic_legacy>r.r-r/r0>r,r+r*linearnearestTN)solver solver_argsc Cs||jvrtd|n||jvr.|||||_||_t|\|_|_| ||_ | |j|j | |j ||_ |jrtj||jd|_ |jdkrt|j rd}tj|tdd||jvr|duri}|j||fi||_n*|dus|rtd|d|d |d dS) NMethod '%s' is not definedaxisr-a'`PchipInterpolator` only works with real values. Passing complex-dtyped `values` with `method='pchip'` is deprecated and will raise an error in SciPy 1.15.0. If you are trying to use the real components of the passed array, use `np.real` on the array before passing to `RegularGridInterpolator`.) stacklevelzmethod =z6 does not accept the 'solver' argument. Got solver = z and with arguments .) _ALL_METHODSr_SPLINE_METHODS_validate_grid_dimensionsmethod bounds_errorr!rZ_descending_dimensions _check_valuesr&r'_check_fill_value fill_valuerrZ iscomplexobjwarningswarnDeprecationWarning_SPLINE_METHODS_ndbspl_construct_spline_spline) selfrr&r>r?rBr3r4msgrrr __init__s6     z RegularGridInterpolator.__init__cKs4|durtj}t|j|j|j|fd|i|}|S)Nr3)sslZgcrotmkr rr&_SPLINE_DEGREE_MAP)rIr>r3r4Zsplrrr rG2sz)RegularGridInterpolator._construct_splinecCst||dSN)r')rIrr&rrr r';sz-RegularGridInterpolator._check_dimensionalitycCst|SrN)r!)rIrrrr r!>sz%RegularGridInterpolator._check_pointscCsFt|dst|}t|drBt|drBt|jtjsB|t}|S)Nr$rastype)hasattrrrZ issubdtyperZinexactrOr)rIr&rrr r@As    z%RegularGridInterpolator._check_valuescCs<|dur8t|j}t|dr8tj||jdds8td|S)NrZ same_kind)ZcastingzDfill_value must be either 'None' or of a type compatible with values)rrrrPZcan_castr)rIr&rBZfill_value_dtyperrr rALs   z)RegularGridInterpolator._check_fill_valuenuc Cs|dur|jn|}|j|k}||jvr2td||rL||jvrL|||_|durv||jvrvtd|jd|d||\}}}}}|dkr8||j\} } |dkr*t |j dr*|j j dkr*|j j j r*|j jtjtjfvr*|j jjd kr*tj| jd |j jd } t|j | | |j| } n || | } np|d kr`||j\} } || | } nH||jvr|r||j|||jvr|||} n|j||d } |js|jdur|j| |<t|rtj | |<| !|dd|j j|dS)a Interpolation at coordinates. Parameters ---------- xi : ndarray of shape (..., ndim) The coordinates to evaluate the interpolator at. method : str, optional The method of interpolation to perform. Supported are "linear", "nearest", "slinear", "cubic", "quintic" and "pchip". Default is the method chosen when the interpolator was created. nu : sequence of ints, length ndim, optional If not None, the orders of the derivatives to evaluate. Each entry must be non-negative. Only allowed for methods "slinear", "cubic" and "quintic". .. versionadded:: 1.13 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:]``. Examples -------- Here we define a nearest-neighbor interpolator of a simple function >>> import numpy as np >>> x, y = np.array([0, 1, 2]), np.array([1, 3, 7]) >>> def f(x, y): ... return x**2 + y**2 >>> data = f(*np.meshgrid(x, y, indexing='ij', sparse=True)) >>> from 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]) Nr5z)Can only compute derivatives for methods z, got method =r:r1r8r=rrr2rQr)"r>r;rrFrGrH _prepare_xi _find_indicesTrPr&r$flagsZ writeablerrZfloat64Z complex128 byteorderemptyr%rr_evaluate_linear_evaluate_nearestr<r=_SPLINE_METHODS_recursive_evaluate_spliner?rBanynanreshape) rIxir>rRZis_method_changedxi_shaper$nans out_of_boundsindicesnorm_distancesoutresultrrr __call__Vs`9             z RegularGridInterpolator.__call__c Cst|j}t||d}|jdt|jkrDtd|jdd||j}|d|d}tj|td}tj t |dd}|j rt |j D]H\}}tt|j|d|kt||j|dkstd|qd}n ||j }|||||fS) Nr$rz.The requested sample points xi have dimension z0 but this RegularGridInterpolator has dimension rr6r8One of the requested xi is out of bounds in dimension %d)r#rrr%rr`rrrr^isnanr?rrV logical_andr_find_out_of_bounds)rIrar$rbrcrrrdrrr rTs.   z#RegularGridInterpolator._prepare_xicCstdfd|jjt|}dd|D}dd|D}t||}t||}tjt||}tdg} |D]N} t| \} } tdg} | D] }| |} qt |j| | |}| |} qn| S)NrNcSsg|] }d|qSrr).0yirrr z.cSsg|] }|dqSror)rprrrr rrrsgg?) slicer&r$r#zip itertoolsproductrarrayr)rIrerfZvsliceZshift_norm_distancesZ shift_indicesZzipped1Zzipped2Z hypercubevaluehZ edge_indicesweightsweightwtermrrr rZs       z(RegularGridInterpolator._evaluate_linearcCs"ddt||D}|jt|S)NcSs&g|]\}}t|dk||dqS)g?r)rwhere)rprrqrrr rrsz=RegularGridInterpolator._evaluate_nearest..)rur&r)rIrerfZidx_resrrr r[sz)RegularGridInterpolator._evaluate_nearestc Cs\|j|}t|D]D\}}tt|}||krtd|d|d|d|dd qdS)Nz There are z points in dimension z , but method z requires at least rz points per dimension.)rMrr#rZ atleast_1dr)rIrr>krpointr$rrr r=s z1RegularGridInterpolator._validate_grid_dimensionscCs0|jdkr|d|jf}|j\}}tt|jj}|d|ddd||d}|j|}|dkrr|j}n|j }|j |} |d} ||j | ||dd| f| } |g|jj|dR} t j | |jjd} t|D]N}| |df}t| dddD] }||j |||||f| }q|| |df<q| S)Nrrr-r.)r$r`sizer%rranger&Z transpose _do_pchip_do_spline_fitrMrrrYr)rIrar>mnZaxesZaxxr&Z _eval_funcrZlast_dimZ first_valuesr%rhjZ folded_valuesrrrr r] s8  "       z(RegularGridInterpolator._evaluate_splinecCst|||dd}||}|S)Nr)rr7r xyptrZ local_interpr&rrr rAsz&RegularGridInterpolator._do_spline_fitcCst||dd}||}|S)Nrr6rrrrr rGsz!RegularGridInterpolator._do_pchipcCs t|j|SrN)r r)rIrarrr rUMsz%RegularGridInterpolator._find_indicescCsNtj|jdtd}t||jD](\}}|||dk7}|||dk7}q |S)Nrrrr)rZzerosr%boolrur)rIrardrrrrr rnPs z+RegularGridInterpolator._find_out_of_bounds)N)N)__name__ __module__ __qualname____doc__rMr\rFlistkeysr<r;rr_rKrGr'r!r@rArirTrZr[r=r] staticmethodrrrUrnrrrr r5s>U     l 7  r1Tc Cs|dvrtd|dt|ds,t|}|j}|dkrJ|dkrJtd|sf|durf|dkrftd t||krtd t||ft||kr|dkrtd t|\}}t||t|t|d }|j d t|krtd|j d t|f|rNt |j D]H\} } t t || d| kt | || d kstd| q|tjvrtt|||||d} | |S|dkr~|j } |d |j d }tj |dd|dddfk|dddf|dd k|dd|dddfk|dddf|dd kfdd} t|dddf}t|d|d|dd} | || df|| df|| <||t| <|| dd Std|dS)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 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 : array_like, shape (m1, ..., mn, ...) The data on the regular grid in n dimensions. Complex data is accepted. .. deprecated:: 1.13.0 Complex data is deprecated with ``method="pchip"`` and will raise an error in SciPy 1.15.0. This is because ``PchipInterpolator`` only works with real values. If you are trying to use the real components of the passed array, use ``np.real`` on ``values``. xi : 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", "pchip", and "splinef2d". "splinef2d" is only supported for 2-dimensional data. 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. Extrapolation is not supported by method "splinef2d". Returns ------- values_x : ndarray, shape xi.shape[:-1] + values.shape[ndim:] Interpolated values at `xi`. See notes for behaviour when ``xi.ndim == 1``. See Also -------- NearestNDInterpolator : Nearest neighbor interpolation on unstructured data in N dimensions LinearNDInterpolator : Piecewise linear interpolant on unstructured data in N dimensions RegularGridInterpolator : interpolation on a regular or rectilinear grid in arbitrary dimensions (`interpn` wraps this class). RectBivariateSpline : Bivariate spline approximation over a rectangular mesh scipy.ndimage.map_coordinates : interpolation on grids with equal spacing (suitable for e.g., N-D image resampling) Notes ----- .. versionadded:: 0.14 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 numpy as np >>> from scipy.interpolate import interpn >>> def value_func_3d(x, y, z): ... return 2 * x + 3 * y - z >>> x = np.linspace(0, 4, 5) >>> y = np.linspace(0, 5, 6) >>> z = np.linspace(0, 6, 7) >>> points = (x, y, z) >>> values = value_func_3d(*np.meshgrid(*points, indexing='ij')) Evaluate the interpolating function at a point >>> point = np.array([2.21, 3.12, 1.15]) >>> print(interpn(points, values, point)) [12.63] ) r1r2r+r,r- splinef2dr*r.r/r0zinterpn only understands the methods 'linear', 'nearest', 'slinear', 'cubic', 'quintic', 'pchip', and 'splinef2d'. You provided r:r$r8rzBThe method splinef2d can only be used for 2-dimensional input dataNz4The method splinef2d does not support extrapolation.r"zSThe method splinef2d can only be used for scalar data with one point per coordinaterjrzcThe requested sample points xi have dimension %d, but this RegularGridInterpolator has dimension %drrk)r>r?rBrr6zunknown method = )rrPrrr$r#r!r'rr%rrVrmrrr;r`Z empty_liker ZevZ logical_not)rr&rar>r?rBr$rrrrZinterprbZ idx_validrhrrr rZshc          84 )__all__rvrCnumpyrZscipy.sparse.linalgsparseZlinalgrLZinterpndrZ_cubicrZ _rgi_cythonrr Z _bsplinesr Z _fitpack2r Z _ndbspliner r!r'rr_rrrrr s(      )