| Server IP : 35.80.110.71 / Your IP : 216.73.216.221 Web Server : Apache/2.4.58 (Ubuntu) System : Linux ip-172-31-21-44 6.17.0-1019-aws #19~24.04.1-Ubuntu SMP Tue Jun 23 18:53:06 UTC 2026 x86_64 User : ubuntu ( 1000) PHP Version : 8.3.31 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /lib/python3/dist-packages/scipy/interpolate/__pycache__/ |
Upload File : |
�
x�f�% � �t � d Z ddlZddlmZmZmZmZ ddlm Z g d�Z
G d� de� Z d ej d
fd �Z
y) zD
Convenience interface to N-D interpolation
.. versionadded:: 0.9
� N� )�LinearNDInterpolator�NDInterpolatorBase�CloughTocher2DInterpolator�_ndim_coords_from_arrays)�cKDTree)�griddata�NearestNDInterpolatorr r c � � e Zd ZdZdd�Zd� Zy)r
aL NearestNDInterpolator(x, y).
Nearest-neighbor interpolation in N > 1 dimensions.
.. versionadded:: 0.9
Methods
-------
__call__
Parameters
----------
x : (npoints, ndims) 2-D ndarray of floats
Data point coordinates.
y : (npoints, ) 1-D ndarray of float or complex
Data values.
rescale : boolean, optional
Rescale points to unit cube before performing interpolation.
This is useful if some of the input dimensions have
incommensurable units and differ by many orders of magnitude.
.. versionadded:: 0.14.0
tree_options : dict, optional
Options passed to the underlying ``cKDTree``.
.. versionadded:: 0.17.0
See Also
--------
griddata :
Interpolate unstructured D-D data.
LinearNDInterpolator :
Piecewise linear interpolant in N dimensions.
CloughTocher2DInterpolator :
Piecewise cubic, C1 smooth, curvature-minimizing interpolant in 2D.
interpn : Interpolation on a regular grid or rectilinear grid.
RegularGridInterpolator : Interpolation on a regular or rectilinear grid
in arbitrary dimensions (`interpn` wraps this
class).
Notes
-----
Uses ``scipy.spatial.cKDTree``
.. note:: For data on a regular grid use `interpn` instead.
Examples
--------
We can interpolate values on a 2D plane:
>>> from scipy.interpolate import NearestNDInterpolator
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
>>> x = rng.random(10) - 0.5
>>> y = rng.random(10) - 0.5
>>> z = np.hypot(x, y)
>>> X = np.linspace(min(x), max(x))
>>> Y = np.linspace(min(y), max(y))
>>> X, Y = np.meshgrid(X, Y) # 2D grid for interpolation
>>> interp = NearestNDInterpolator(list(zip(x, y)), z)
>>> Z = interp(X, Y)
>>> plt.pcolormesh(X, Y, Z, shading='auto')
>>> plt.plot(x, y, "ok", label="input point")
>>> plt.legend()
>>> plt.colorbar()
>>> plt.axis("equal")
>>> plt.show()
Nc � � t j | |||dd�� |�
t � }t | j fi |��| _ t
j |� | _ y )NF)�rescale�need_contiguous� need_values) r �__init__�dictr �points�tree�np�asarray�values)�self�x�yr
� tree_optionss �?/usr/lib/python3/dist-packages/scipy/interpolate/_ndgriddata.pyr z NearestNDInterpolator.__init__\ sQ � ��#�#�D�!�Q��49�05� 7� � � �6�L��D�K�K�8�<�8�� ��j�j��m�� � c �� � t || j j d �� }| j |� }| j |� }| j
j
|� \ }}| j | S )aV
Evaluate interpolator at given points.
Parameters
----------
x1, x2, ... xn : array-like of float
Points where to interpolate data at.
x1, x2, ... xn can be array-like of float with broadcastable shape.
or x1 can be array-like of float with shape ``(..., ndim)``
r )�ndim)r r �shape�_check_call_shape�_scale_xr �queryr )r �args�xi�dist�is r �__call__z NearestNDInterpolator.__call__e sa � � &�d����1B�1B�1�1E�
F��
�
#�
#�B�
'��
�]�]�2�
���)�)�/�/�"�%���a��{�{�1�~� r )FN)�__name__�
__module__� __qualname__�__doc__r r' � r r r
r
s � �E�N$� r r
�linearFc �N � t | � } | j dk r
| j }n| j d }|dk( r�|dv rddlm} | j � } t
|t � r t |� dk7 r t d� �|\ }t j | � }| | } || }|dk( rd} || ||d d
|� � } | |� S |dk( rt | ||� � } | |� S |d
k( rt | |||�� } | |� S |dk( r |dk( rt | |||�� } | |� S t d||fz � �)aX
Interpolate unstructured D-D data.
Parameters
----------
points : 2-D ndarray of floats with shape (n, D), or length D tuple of 1-D ndarrays with shape (n,).
Data point coordinates.
values : ndarray of float or complex, shape (n,)
Data values.
xi : 2-D ndarray of floats with shape (m, D), or length D tuple of ndarrays broadcastable to the same shape.
Points at which to interpolate data.
method : {'linear', 'nearest', 'cubic'}, optional
Method of interpolation. One of
``nearest``
return the value at the data point closest to
the point of interpolation. See `NearestNDInterpolator` for
more details.
``linear``
tessellate the input point set to N-D
simplices, and interpolate linearly on each simplex. See
`LinearNDInterpolator` for more details.
``cubic`` (1-D)
return the value determined from a cubic
spline.
``cubic`` (2-D)
return the value determined from a
piecewise cubic, continuously differentiable (C1), and
approximately curvature-minimizing polynomial surface. See
`CloughTocher2DInterpolator` for more details.
fill_value : float, optional
Value used to fill in for requested points outside of the
convex hull of the input points. If not provided, then the
default is ``nan``. This option has no effect for the
'nearest' method.
rescale : bool, optional
Rescale points to unit cube before performing interpolation.
This is useful if some of the input dimensions have
incommensurable units and differ by many orders of magnitude.
.. versionadded:: 0.14.0
Returns
-------
ndarray
Array of interpolated values.
See Also
--------
LinearNDInterpolator :
Piecewise linear interpolant in N dimensions.
NearestNDInterpolator :
Nearest-neighbor interpolation in N dimensions.
CloughTocher2DInterpolator :
Piecewise cubic, C1 smooth, curvature-minimizing interpolant in 2D.
interpn : Interpolation on a regular grid or rectilinear grid.
RegularGridInterpolator : Interpolation on a regular or rectilinear grid
in arbitrary dimensions (`interpn` wraps this
class).
Notes
-----
.. versionadded:: 0.9
.. note:: For data on a regular grid use `interpn` instead.
Examples
--------
Suppose we want to interpolate the 2-D function
>>> import numpy as np
>>> def func(x, y):
... return x*(1-x)*np.cos(4*np.pi*x) * np.sin(4*np.pi*y**2)**2
on a grid in [0, 1]x[0, 1]
>>> grid_x, grid_y = np.mgrid[0:1:100j, 0:1:200j]
but we only know its values at 1000 data points:
>>> rng = np.random.default_rng()
>>> points = rng.random((1000, 2))
>>> values = func(points[:,0], points[:,1])
This can be done with `griddata` -- below we try out all of the
interpolation methods:
>>> from scipy.interpolate import griddata
>>> grid_z0 = griddata(points, values, (grid_x, grid_y), method='nearest')
>>> grid_z1 = griddata(points, values, (grid_x, grid_y), method='linear')
>>> grid_z2 = griddata(points, values, (grid_x, grid_y), method='cubic')
One can see that the exact result is reproduced by all of the
methods to some degree, but for this smooth function the piecewise
cubic interpolant gives the best results:
>>> import matplotlib.pyplot as plt
>>> plt.subplot(221)
>>> plt.imshow(func(grid_x, grid_y).T, extent=(0,1,0,1), origin='lower')
>>> plt.plot(points[:,0], points[:,1], 'k.', ms=1)
>>> plt.title('Original')
>>> plt.subplot(222)
>>> plt.imshow(grid_z0.T, extent=(0,1,0,1), origin='lower')
>>> plt.title('Nearest')
>>> plt.subplot(223)
>>> plt.imshow(grid_z1.T, extent=(0,1,0,1), origin='lower')
>>> plt.title('Linear')
>>> plt.subplot(224)
>>> plt.imshow(grid_z2.T, extent=(0,1,0,1), origin='lower')
>>> plt.title('Cubic')
>>> plt.gcf().set_size_inches(6, 6)
>>> plt.show()
� ���r )�nearestr- �cubic)�interp1dz"invalid number of dimensions in xir1 � extrapolater F)�kind�axis� bounds_error�
fill_value)r
r- )r8 r
r2 z7Unknown interpolation method %r for %d dimensional data)r r r � _interpolater3 �ravel�
isinstance�tuple�len�
ValueErrorr �argsortr
r r )
r r r$ �methodr8 r
r r3 �idx�ips
r r r | sQ � �t &�f�
-�F�
�{�{�Q���{�{���|�|�B� �� �q�y�V� =�=�*�� � � �� �b�%� ��2�w�!�|� �!E�F�F��C�B��j�j�� ���������� �Y� �&�J�
�f�f�6���!+�-���"�v�
� �9� �
"�6�6�7�
C���"�v�
� �8� �
!�&�&�Z�*1�3���"�v�
� �7� �t�q�y�
'���:�07�9���"�v�
�� /�28�$� �@� A� Ar )r+ �numpyr �interpndr r r r �
scipy.spatialr �__all__r
�nanr r, r r �<module>rH sH ��� �:� :� !� )��a � .� a �P )1�R�V�V��^Ar