o 5ήc'_@stddgZddlZddlZddlmZddlmZddlm Z ddl m Z d d Z Gd ddZ d d ejfddZdS)RegularGridInterpolatorinterpnN)_ndim_coords_from_arrays)PchipInterpolatormake_interp_spline)RectBivariateSplinec Cstdd|D}tddt||D}tdd|D}tddtj|D}tddtj|D}tt|}t||D]\}} |t| |t|<qI||fS)Ncss|]}t|VqdSN)npargsort).0pointr=/tmp/pip-target-vg8gfxp4/lib/python/scipy/interpolate/_rgi.py sz4_make_points_and_values_ascending..css"|] \}}t||VqdSr r asarray)r r sort_indexrrrrs css |] }gtt|VqdSr )rangelen)r xrrrrscSg|]}|qSrflattenr irrr z5_make_points_and_values_ascending..cSrrrrrrrrr)tuplezipr arraymeshgrid transpose zeros_liker) pointsvaluessorted_indexes points_ascordered_indexesordered_indexes_arraysorted_indexes_array values_ascosrrr!_make_points_and_values_ascending s&r/c@seZdZdZddddZeeZddgeZdde j fd d Z dd d Z ddZ ddZddZddZeddZddZd S)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, 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 can be acceptable. method : str, optional The method of interpolation to perform. Supported are "linear", "nearest", "slinear", "cubic", and "quintic". 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``. 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 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 >>> 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 interpolation on *unstructured* data in N dimensions LinearNDInterpolator : Piecewise linear interpolant 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)slinearcubicquinticlinearnearestTc Cs||jvr td|||jvr|||||_||_t|ds&t|}t ||j kr8tdt ||j ft|drOt|drOt |j tj sO|t}||_|durnt|j }t|drntj||j ddsntdt|D]J\}}t|} t| d kst| d krt||\}}ntd |t|j d kstd ||j|t |kstd t ||j||fqrtdd|D|_||_dS)NMethod '%s' is not definedndim7There are %d point arrays, but values has %d dimensionsdtypeastype same_kind)castingzDfill_value must be either 'None' or of a type compatible with valuesCThe points in dimension %d must be strictly ascending or descendingr0The points in dimension %d must be 1-dimensional1There are %d points and %d values in dimension %dcSg|]}t|qSrrr prrrrz4RegularGridInterpolator.__init__..) _ALL_METHODS ValueError_SPLINE_METHODS_validate_grid_dimensionsmethod bounds_errorhasattrr rrr8 issubdtyper:inexactr;float fill_valuecan_cast enumeratediffallr/shapergridr&) selfr%r&rJrKrPfill_value_dtyperrDdiff_prrr__init__s^              z RegularGridInterpolator.__init__Nc Cs|j|k}|dur |jn|}||jvrtd|t|j}t||d}|jdt|jkr9td|jd|f|j}|d|d}tj t |dd}|j r{t |j D]$\}}tt|j|d|kt||j|dksztd |qV||j \} } } |d kr|| | | } n&|d kr|| | | } n||jvr|r||j|||jj ||j|} |j s|jdur|j| | <t |rtj| |<| |dd|jj|dS) aV Interpolation at coordinates. Parameters ---------- xi : ndarray of shape (..., ndim) The coordinates to evaluate the interpolator at. method : str The method of interpolation to perform. Supported are "linear" and "nearest". Examples -------- Here we define a nearest-neighbor interpolator of a simple function >>> 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]) Nr7r8cThe requested sample points xi have dimension %d, but this RegularGridInterpolator has dimension %draxisr8One of the requested xi is out of bounds in dimension %dr5r6)rJrFrGrrVrrUreshaper anyisnanrKrRT logical_andrT _find_indices_evaluate_linear_evaluate_nearestrHrI_evaluate_spliner&_SPLINE_DEGREE_MAPrPnan) rWxirJis_method_changedr8xi_shapenansrrDindicesnorm_distances out_of_boundsresultrrr__call__sX $          "z RegularGridInterpolator.__call__c Cstdfd|jjt|}tjdd|D}d}|D]+}d}t|||D]\} } } |t| | kd| | 9}q'|t |j|||7}q|S)Nr cSsg|]}||dgqS)rrrrrrr`sz.r>g?r) slicer&r8r itertoolsproductr r wherer) rWrprqrrvsliceedgesr& edge_indicesweighteiryirrrrgZsz(RegularGridInterpolator._evaluate_linearcCs"ddt||D}|jt|S)NcSs&g|]\}}t|dk||dqS)g?r)r rx)r rr~rrrrjsz=RegularGridInterpolator._evaluate_nearest..)r r&r)rWrprqrridx_resrrrrhisz)RegularGridInterpolator._evaluate_nearestc Cs\|j|}t|D]"\}}tt|}||kr+td|d|d|d|dd q dS)Nz There are z points in dimension z , but method z requires at least rz points per dimension.)rjrRrr atleast_1drG)rWr%rJkrrr8rrrrIns  z1RegularGridInterpolator._validate_grid_dimensionsc Cs|jdkr |d|jf}|j\}}|d}||j|||dd|f|}tj||jj d}t |D]$} || } t |dddD]} ||j| | || | f|} qB| || <q4|S)Nrr:r\) r8rasizerU_do_spline_fitrVr emptyr&r:r) rWr&rl spline_degreemnlast_dim first_valuesrsj folded_valuesrrrrriws(       z(RegularGridInterpolator._evaluate_splinecCst|||dd}||}|S)Nr)rr_r)ryptr local_interpr&rrrrsz&RegularGridInterpolator._do_spline_fitc Cs g}g}tj|jdtd}t||jD]k\}}t||d}d||dk<|jd|||jdk<||||d||}tj dddt |dk||||d} Wdn1sbwY|| |j s|||dk7}|||dk7}q|||fS)Nrrrignore)divideinvalidr\) r zerosrUboolr rV searchsortedrappenderrstaterxrK) rWrlrprqrrrrVrdenom norm_distrrrrfs$     z%RegularGridInterpolator._find_indicesr )__name__ __module__ __qualname____doc__rjlistkeysrHrFr rkrZrtrgrhrIri staticmethodrrfrrrrr"s" .   2T %  r5Tc Cs4|dvr td|t|dst|}|j}|dkr#|dkr#td|s1|dur1|dkr1tdt||krAtd t||ft||krO|dkrOtd t|D]J\}}t|} t| d ksxt| d krrt ||\}}ntd |t|jd kstd||j |t|kstdt||j ||fqSt dd|D} t |t| d}|j dt| krtd|j dt| f|rt|j D]"\}}tt| |d|kt|| |dkstd|q|dkrt||d||d} | |S|dkrt||d||d} | |S|dkr|j } |d|j d}tj| dd|dddfk|dddf| ddk| d d|ddd fk|ddd f| d dkfdd} t|dddf}t|d|d |dd} | || df|| d f|| <||t| <|| ddSdS)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 can be acceptable. 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" and "nearest", 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 input coordinates. Notes ----- .. versionadded:: 0.14 Examples -------- Evaluate a simple example function on the points of a regular 3-D grid: >>> 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] 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) )r5r6 splinef2dz[interpn only understands the methods 'linear', 'nearest', and 'splinef2d'. You provided %s.r8rrzBThe method splinef2d can only be used for 2-dimensional input dataNz4The method splinef2d does not support extrapolation.r9zSThe method splinef2d can only be used for scalar data with one point per coordinater>r?rr@rAcSrBrrrCrrrr<rEzinterpn..r[r\r]rr`r5)rJrKrPr6r^)rGrLr rr8rrRrSrTr/rUrrrdrerra empty_liker ev logical_not)r%r&rlrJrKrPr8rrDrYrVinterprn idx_validrsrrrrsW         84 )__all__rvnumpyr interpndr_cubicr _bsplinesr _fitpack2r r/rrkrrrrrs