SciPy 1.12 中文文档（十一）
scipy.interpolate.pchip_interpolate
scipy.interpolate.pchip_interpolate(xi, yi, x, der=0, axis=0)
Pchip 插值的便利函数。
xi 和 yi 是用来逼近某些函数 f 的值的数组，其中yi = f(xi)。插值器使用单调立方样条来找到新点 x 的值及其导数。
参见scipy.interpolate.PchipInterpolator以获取详细信息。
参数：
xi类似数组
排序后的 x 坐标列表，长度为 N。
yi类似数组
一个实数值的 1-D 数组。yi在插值轴上的长度必须等于xi的长度。如果是 N-D 数组，请使用轴参数选择正确的轴。
x标量或类似数组
长度为 M。
derint 或列表，可选
要提取的导数。可以包括第 0 阶导数以返回函数值。
axis整数，可选
在 yi 数组中对应于 x 坐标值的轴。
返回：
y标量或类似数组
结果的长度为 R 或长度为 M 或 M 乘以 R。
参见
PchipInterpolator
PCHIP 1-D 单调立方插值器。
示例
我们可以使用 Pchip 插值来插值 2D 观测数据：
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.interpolate import pchip_interpolate
>>> x_observed = np.linspace(0.0, 10.0, 11)
>>> y_observed = np.sin(x_observed)
>>> x = np.linspace(min(x_observed), max(x_observed), num=100)
>>> y = pchip_interpolate(x_observed, y_observed, x)
>>> plt.plot(x_observed, y_observed, "o", label="observation")
>>> plt.plot(x, y, label="pchip interpolation")
>>> plt.legend()
>>> plt.show()
scipy.interpolate.CubicHermiteSpline
class scipy.interpolate.CubicHermiteSpline(x, y, dydx, axis=0, extrapolate=None)
Piecewise-cubic interpolator matching values and first derivatives.
结果表示为 PPoly 实例。
Parameters:
xarray_like, shape (n,)
包含独立变量值的 1-D 数组。值必须是实数、有限且严格递增的顺序。
yarray_like
包含依赖变量的值的数组。它可以有任意数量的维度，但沿着 axis（见下文）的长度必须与 x 的长度匹配。值必须是有限的。
dydxarray_like
包含依赖变量的导数的数组。它可以有任意数量的维度，但沿着 axis（见下文）的长度必须与 x 的长度匹配。值必须是有限的。
axisint, optional
假设 y 可以变化的轴。这意味着对于 x[i]，相应的值是 np.take(y, i, axis=axis)。默认为 0。
extrapolate{bool, ‘periodic’, None}, 可选
如果是 bool，则确定是否基于第一个和最后一个区间来对超出边界的点进行外推，或返回 NaN。如果是 ‘periodic’，则使用周期外推。如果是 None（默认），则设置为 True。
See also
Akima 1D 插值器。
PCHIP 1-D 单调立方插值器。
立方样条数据插值器。
以系数和断点表示的分段多项式
Notes
如果您想创建匹配更高阶导数的高阶样条，请使用 BPoly.from_derivatives
References
[1]
Attributes:
xndarray, shape (n,)
断点。与构造函数中传递的 x 相同。
cndarray, shape (4, n-1, …)
每个段上多项式的系数。末尾的维度与 y 的维度匹配，不包括 axis。例如，如果 y 是 1-D，则 c[k, i] 是在 x[i] 和 x[i+1] 之间的段上 (x-x[i])**(3-k) 的系数。
axisint
插值轴。与构造函数中传递的相同轴。
Methods
__call__(x[, nu, extrapolate]) | 计算分段多项式或其导数在点 x 处的值。 |
|---|---|
derivative | 构造一个表示导数的新分段多项式。 |
antiderivative | 构造一个表示反导数的新分段多项式。 |
integrate(a, b[, extrapolate]) | 计算分段多项式在区间 [a, b] 上的定积分。 |
roots | 找到分段多项式的实根。 |
scipy.interpolate.PchipInterpolator
class scipy.interpolate.PchipInterpolator(x, y, axis=0, extrapolate=None)
PCHIP 1-D 单调立方插值。
x 和 y 是用于近似某个函数 f 的值数组。插值器使用单调三次样条来找到新点的值。（PCHIP 代表分段三次埃尔米特插值多项式）。
参数：
xndarray, shape (npoints, )
一个单调递增的实数值 1-D 数组。x 不能包含重复值（否则 f 就过度规定了）
yndarray, shape (…, npoints, …)
一个 N-D 实数数组。y 沿插值轴的长度必须等于 x 的长度。使用 axis 参数来选择插值轴。
axisint, optional
y 数组中对应于 x 坐标值的轴。默认为 axis=0。
extrapolatebool, optional
是否根据第一个和最后一个间隔对超出边界的点进行外推，或者返回 NaN。
另请参阅
CubicHermiteSpline
分段立方插值器。
Akima1DInterpolator
Akima 1D 插值器。
CubicSpline
立方样条数据插值器。
PPoly
在系数和断点的分段多项式。
注意事项
插值器保留插值数据的单调性，并且如果数据不平滑，则不会过冲。
第一导数保证连续，但第二导数可能在 (x_k) 处跳跃。
通过 PCHIP 算法确定点 (x_k) 处的导数 (f'_k) [1]。
设 (h_k = x_{k+1} - x_k)，(d_k = (y_{k+1} - y_k) / h_k) 是内部点 (x_k) 处的斜率。如果 (d_k) 和 (d_{k-1}) 的符号不同或其中任何一个为零，则 (f'_k = 0)。否则，它由加权调和平均数给出
[\frac{w_1 + w_2}{f'k} = \frac{w_1}{d{k-1}} + \frac{w_2}{d_k}]
其中 (w_1 = 2 h_k + h_{k-1})，(w_2 = h_k + 2 h_{k-1})。
采用单边方案设定末端斜率 [2]。
参考文献
[1]
F. N. Fritsch 和 J. Butland, 一种构建局部单调分段三次立方插值器的方法，SIAM J. Sci. Comput., 5(2), 300-304 (1984). DOI:10.1137/0905021。
[2]
参见，例如，C. Moler，《Matlab 数值计算》，2004 年。 DOI:10.1137/1.9780898717952
属性：
-
axis
-
c
-
extrapolate
-
x
方法：
__call__(x[, nu, extrapolate]) | 评估分段多项式或其导数。 |
|---|---|
derivative([nu]) | 构建表示导数的新分段多项式。 |
antiderivative([nu]) | 构建表示原函数的新分段多项式。 |
roots([discontinuity, extrapolate]) | 寻找分段多项式的实根。 |
scipy.interpolate.Akima1DInterpolator
class scipy.interpolate.Akima1DInterpolator(x, y, axis=0)
Akima 插值器
适合分段立方多项式，给定向量 x 和 y。Akima 插值方法使用连续可微的子样条构建自分段立方多项式。结果曲线经过给定数据点，看起来平滑自然。
参数：
xndarray, shape (npoints, )
1-D 数组，单调递增的实值。
yndarray, shape (…, npoints, …)
N-D 实值数组。沿插值轴的 y 的长度必须等于 x 的长度。使用 axis 参数选择插值轴。
axisint, optional
对应于 x 坐标值的 y 数组的轴。默认为 axis=0。
另见
PchipInterpolator
PCHIP 1-D 严格单调立方插值器。
CubicSpline
三次样条插值器。
PPoly
分段多项式的系数和分段点
注意事项
版本 0.14 中的新功能。
仅用于精确数据，因为拟合曲线确切地通过给定点。此例程适用于绘制通过少数给定点的令人愉悦平滑曲线的目的。
参考文献
[1] 基于插值和平滑曲线拟合的新方法
on local procedures. Hiroshi Akima, J. ACM, October 1970, 17(4), 589-602.
Attributes:
axis
c
extrapolate
x
Methods
__call__(x[, nu, extrapolate]) | Evaluate the piecewise polynomial or its derivative. |
|---|---|
derivative([nu]) | Construct a new piecewise polynomial representing the derivative. |
antiderivative([nu]) | Construct a new piecewise polynomial representing the antiderivative. |
roots([discontinuity, extrapolate]) | 寻找分段多项式的实根。 |
scipy.interpolate.CubicSpline
class scipy.interpolate.CubicSpline(x, y, axis=0, bc_type='not-a-knot', extrapolate=None)
分段立方样条数据插值器。
使用分段三次多项式对数据进行插值，其二阶连续可微性满足 [1]。结果表示为一个PPoly实例，其分段与给定数据匹配。
参数：
xarray_like, 形状为(n,)
包含自变量值的 1-D 数组。值必须是实数、有限的，并且严格递增。
yarray_like
包含因变量值的数组。它可以有任意维度，但沿着axis（见下文）的长度必须与x的长度匹配。值必须是有限的。
axisint, 可选
假设y变化的轴。这意味着对于x[i]，相应的值是np.take(y, i, axis=axis)。默认为 0。
bc_typestring 或 2-tuple, 可选
边界条件类型。需要额外的两个方程，由边界条件确定每个段上的所有多项式系数 [2]。
如果bc_type是一个字符串，则将在样条的两端应用指定条件。可用的条件有：
-
‘not-a-knot’（默认）：曲线端点的第一段和第二段是相同的多项式。当没有边界条件信息时，这是一个很好的默认值。
-
‘periodic’: 假定插值函数是周期性的，周期为
x[-1] - x[0]。y的第一个和最后一个值必须相同：y[0] == y[-1]。此边界条件将导致y'[0] == y'[-1]和y''[0] == y''[-1]。 -
‘clamped’: 曲线端点的一阶导数为零。假设 1D 的y，
bc_type=((1, 0.0), (1, 0.0))是相同的条件。 -
‘natural’: 曲线端点的二阶导数为零。假设 1D 的y，
bc_type=((2, 0.0), (2, 0.0))是相同的条件。
如果bc_type是一个 2 元组，则第一个和第二个值将分别应用于曲线的起始点和结束点。元组值可以是之前提到的字符串之一（除了‘periodic’）或一个元组*(order, deriv_values)*，允许在曲线端点指定任意导数：
-
order: 导数阶数，为 1 或 2。
-
deriv_value: 包含导数值的 array_like，形状必须与y相同，不包括
axis维度。例如，如果y是 1D 的，则deriv_value必须是标量。如果y是 3D 且形状为(n0, n1, n2)，且 axis=2，则deriv_value必须是 2D 且形状为(n0, n1)。
extrapolate{bool, ‘periodic’, None}, 可选
如果是布尔值，则决定基于第一个和最后一个间隔来拟合超出边界的点，或者返回 NaN。如果是‘periodic’，使用周期外推。如果是 None（默认值），则对于bc_type='periodic'，extrapolate设置为‘periodic’，否则设置为 True。
亦见
Akima1DInterpolator
Akima 1D 插值器。
PchipInterpolator
PCHIP 1-D 单调立方插值器。
PPoly
分段多项式在系数和断点方面。
注意
参数 bc_type 和 extrapolate 相互独立工作，即前者只控制样条的构造，后者只控制评估。
当边界条件为“非奇节点”且 n = 2 时，它被替换为条件，即第一阶导数等于线性插值斜率。当两个边界条件都是“非奇节点”且 n = 3 时，解被寻求为通过给定点的抛物线。
当‘非奇节点’边界条件被应用到两端时，得到的样条将与由splrep(with s=0)和InterpolatedUnivariateSpline返回的一样，但这两种方法使用 B 样条基数来表示。
新版本为 0.18.0。
参考
[1]
立方样条插值于维基学院。
[2]
Carl de Boor, “A Practical Guide to Splines”, Springer-Verlag, 1978。
例子
在这个例子中，立方样条被用来插值取样的正弦波。你可以看到样条对第一和第二阶导数的连续性成立，只违反了第三阶导数。
>>> import numpy as np
>>> from scipy.interpolate import CubicSpline
>>> import matplotlib.pyplot as plt
>>> x = np.arange(10)
>>> y = np.sin(x)
>>> cs = CubicSpline(x, y)
>>> xs = np.arange(-0.5, 9.6, 0.1)
>>> fig, ax = plt.subplots(figsize=(6.5, 4))
>>> ax.plot(x, y, 'o', label='data')
>>> ax.plot(xs, np.sin(xs), label='true')
>>> ax.plot(xs, cs(xs), label="S")
>>> ax.plot(xs, cs(xs, 1), label="S'")
>>> ax.plot(xs, cs(xs, 2), label="S''")
>>> ax.plot(xs, cs(xs, 3), label="S'''")
>>> ax.set_xlim(-0.5, 9.5)
>>> ax.legend(loc='lower left', ncol=2)
>>> plt.show()
在第二个例子中，单位圆被样条插值。使用了周期性边界条件。你可以看到周期点（1, 0）的第一导数值，ds/dx=0，ds/dy=1 被正确计算。请注意，圆不能被立方样条精确表示。要增加精度，需要更多的断点。
>>> theta = 2 * np.pi * np.linspace(0, 1, 5)
>>> y = np.c_[np.cos(theta), np.sin(theta)]
>>> cs = CubicSpline(theta, y, bc_type='periodic')
>>> print("ds/dx={:.1f} ds/dy={:.1f}".format(cs(0, 1)[0], cs(0, 1)[1]))
ds/dx=0.0 ds/dy=1.0
>>> xs = 2 * np.pi * np.linspace(0, 1, 100)
>>> fig, ax = plt.subplots(figsize=(6.5, 4))
>>> ax.plot(y[:, 0], y[:, 1], 'o', label='data')
>>> ax.plot(np.cos(xs), np.sin(xs), label='true')
>>> ax.plot(cs(xs)[:, 0], cs(xs)[:, 1], label='spline')
>>> ax.axes.set_aspect('equal')
>>> ax.legend(loc='center')
>>> plt.show()
第三个例子是在区间 0 <= x<= 1 上进行多项式 y = x3 的插值。立方样条可以精确表示这个函数。为了实现这一点，我们需要在区间的端点指定值和第一导数。请注意，y’ = 3 * x2 因此 y’(0) = 0 并且 y’(1) = 3。
>>> cs = CubicSpline([0, 1], [0, 1], bc_type=((1, 0), (1, 3)))
>>> x = np.linspace(0, 1)
>>> np.allclose(x**3, cs(x))
True
属性：
xndarray, shape (n,)
断点。与构造函数中传递的相同的x。
cndarray, shape (4, n-1, …)
多项式在每个段上的系数。尾随的维度与y的维度匹配，不包括axis。例如，如果y是 1 维，则c[k, i]是在x[i]和x[i+1]之间的段上(x-x[i])**(3-k)的系数。
axisint
插值轴。与构造函数中传递的相同的轴。
方法
__call__(x[, nu, extrapolate]) | 计算分段多项式或其导数的值。 |
|---|---|
derivative([nu]) | 构造一个代表导数的新分段多项式。 |
antiderivative([nu]) | 构造一个代表反导数的新分段多项式。 |
integrate(a, b[, extrapolate]) | 计算分段多项式的定积分。 |
roots([discontinuity, extrapolate]) | 寻找分段多项式的实根。 |
scipy.interpolate.PPoly
class scipy.interpolate.PPoly(c, x, extrapolate=None, axis=0)
以系数和断点表示的分段多项式
x[i] 和 x[i + 1] 之间的多项式写成局部幂基数：
S = sum(c[m, i] * (xp - x[i])**(k-m) for m in range(k+1))
其中 k 是多项式的次数。
参数：
cndarray, 形状 (k, m, …)
多项式的系数，次数 k 和 m 个区间。
xndarray, 形状 (m+1,)
多项式断点。必须以递增或递减顺序排序。
extrapolatebool 或 'periodic'，可选
如果是布尔值，则根据第一个和最后一个区间来确定是否对越界点进行外推，或者返回 NaN。如果是 'periodic'，则使用周期外推。默认为 True。
axisint，可选
插值轴。默认为零。
另请参阅
以伯恩斯坦基数表示的分段多项式
注意
高阶次幂的多项式在幂基数中可能不稳定。在大于 20-30 的阶数时，可能出现精度问题。
属性：
xndarray
断点。
cndarray
多项式的系数。它们被重新整形为一个 3-D 数组，最后一个维度表示原始系数数组的尾部维度。
axisint
插值轴。
方法
__call__(x[, nu, extrapolate]) | 计算分段多项式或其导数。 |
|---|---|
derivative([nu]) | 构造一个代表导数的新分段多项式。 |
antiderivative([nu]) | 构造一个代表原函数的新分段多项式。 |
integrate(a, b[, extrapolate]) | 计算分段多项式在给定区间内的定积分。 |
solve([y, discontinuity, extrapolate]) | 寻找方程 pp(x) == y 的实根。 |
roots([discontinuity, extrapolate]) | 寻找分段多项式的实根。 |
extend(c, x) | 向多项式添加额外的断点和系数。 |
from_spline(tck[, extrapolate]) | 从样条函数构建分段多项式 |
from_bernstein_basis(bp[, extrapolate]) | 从伯恩斯坦基础构建幂基数的分段多项式 |
construct_fast(c, x[, extrapolate, axis]) | 构建分段多项式，无需进行检查 |
scipy.interpolate.BPoly
class scipy.interpolate.BPoly(c, x, extrapolate=None, axis=0)
以系数和断点表示的分段多项式。
在x[i]和x[i + 1]之间的多项式以伯恩斯坦多项式基础写成：
S = sum(c[a, i] * b(a, k; x) for a in range(k+1)),
其中k是多项式的阶数，以及：
b(a, k; x) = binom(k, a) * t**a * (1 - t)**(k - a),
其中 t = (x - x[i]) / (x[i+1] - x[i])，binom 是二项式系数。
参数：
c数组，形状为(k, m, ...)
多项式系数，顺序k和m间隔
x数组，形状为(m+1,)
多项式断点。必须按升序或降序排序。
外推布尔值，可选
如果是布尔值，确定是否基于第一个和最后一个区间来对超出边界点进行外推，或者返回 NaN。如果是'periodic'，则使用周期外推。默认值为 True。
轴整数，可选
插值轴。默认值为零。
另见
PPoly
以幂基数表示的分段多项式
注释
伯恩斯坦多项式的性质在文献中有详细记录，例如参见[1] [2] [3]。
参考文献
[1]
en.wikipedia.org/wiki/Bernstein_polynomial
[2]
Kenneth I. Joy，伯恩斯坦多项式，www.idav.ucdavis.edu/education/CAGDNotes/Bernstein-Polynomials.pdf
[3]
E. H. Doha, A. H. Bhrawy, 和 M. A. Saker, 边值问题, vol 2011, article ID 829546, DOI:10.1155/2011/829543。
示例
>>> from scipy.interpolate import BPoly
>>> x = [0, 1]
>>> c = [[1], [2], [3]]
>>> bp = BPoly(c, x)
这创建了一个二阶多项式
[\begin{split}B(x) = 1 \times b_{0, 2}(x) + 2 \times b_{1, 2}(x) + 3 \times b_{2, 2}(x) \ = 1 \times (1-x)² + 2 \times 2 x (1 - x) + 3 \times x²\end{split}]
属性：
x数组
断点。
c数组
多项式的系数。它们被重塑为一个三维数组，最后一个维度表示原始系数数组的尾部维度。
轴整数
插值轴。
方法
__call__(x[, nu, extrapolate]) | 计算分段多项式或其导数。 |
|---|---|
extend(c, x) | 将额外的断点和系数添加到多项式中。 |
derivative | 构建表示导数的新分段多项式。 |
antiderivative([nu]) | 构造一个表示原函数的新分段多项式。 |
integrate(a, b[, extrapolate]) | 计算分段多项式在给定区间上的定积分。 |
construct_fast(c, x[, extrapolate, axis]) | 在不进行检查的情况下构造分段多项式。 |
from_power_basis(pp[, extrapolate]) | 从幂基础多项式构造一个以伯恩斯坦基础为基础的分段多项式。 |
from_derivatives(xi, yi[, orders, extrapolate]) | 根据给定断点处的值和导数构造与之兼容的伯恩斯坦基础分段多项式。 |
scipy.interpolate.griddata
scipy.interpolate.griddata(points, values, xi, method='linear', fill_value=nan, rescale=False)
对非结构化 D-D 数据进行插值。
参数：
points：形状为 (n, D) 的 2-D ndarray，或者长度为 D 的 1-D ndarray 元组，形状为 (n,)。
数据点坐标。
values：float 或 complex 的 ndarray，形状为 (n,)
数据值。
xi：形状为 (m, D) 的 2-D ndarray，或者长度为 D 的元组，其中包含可以广播到相同形状的 ndarray。
插值数据点。
method：{‘linear’, ‘nearest’, ‘cubic’}，可选
插值方法。其中之一为
nearest
返回距离插值点最近的数据点的值。详见NearestNDInterpolator。
linear
将输入点集网格化为 N-D 单纯形，并在线性上进行插值。详见LinearNDInterpolator。
cubic（1-D）
返回从三次样条确定的值。
cubic（2-D）
返回从分段立方体、连续可微（C1）、近似最小曲率的多项式表面确定的值。详见CloughTocher2DInterpolator。
fill_value：float，可选
用于在请求点位于输入点凸包外部时填充的值。如果未提供，则默认为 nan。对于 ‘nearest’ 方法，此选项无效。
rescale：bool，可选
在执行插值之前，将点重新缩放到单位立方体。如果某些输入维度具有不相容的单位并且相差多个数量级，则此选项非常有用。
新版本 0.14.0 中的新增功能。
返回：
ndarray
插值值数组。
参见
在 N 维中的分段线性插值器。
在 N 维中的最近邻插值器。
在 2D 中的分段立方体、C1 平滑、曲率最小化的插值器。
在规则网格或矩形网格上进行插值。
在任意维度上的正则或矩形网格插值器（interpn封装了这个类）。
注意
新版功能在 0.9 版中。
注意
对于正则网格数据，请使用interpn。
示例
假设我们要插值二维函数
>>> 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
在[0, 1]x[0, 1]网格上
>>> grid_x, grid_y = np.mgrid[0:1:100j, 0:1:200j]
但是我们只知道它在 1000 个数据点的值：
>>> rng = np.random.default_rng()
>>> points = rng.random((1000, 2))
>>> values = func(points[:,0], points[:,1])
这可以通过griddata完成——下面我们尝试所有插值方法：
>>> 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')
可以看到所有方法在某种程度上都复制了确切结果，但对于这个平滑函数，分段三次插值器提供了最佳结果：
>>> 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()
scipy.interpolate.LinearNDInterpolator
class scipy.interpolate.LinearNDInterpolator(points, values, fill_value=np.nan, rescale=False)
多维度中的分段线性插值器。
自版本 0.9 起新增。
参数：
points浮点数的 ndarray，形状为（npoints，ndims）；或 Delaunay
数据点坐标的 2D 数组，或预计算的 Delaunay 三角剖分。
values浮点数或复数的 ndarray，形状为（npoints，…），可选
points处的 N-D 数据值数组。values沿第一轴的长度必须等于points的长度。与某些插值器不同，插值轴无法更改。
fill_valuefloat，可选
用于填充请求点在输入点凸包之外的值。如果未提供，则默认为nan。
rescalebool，可选
在执行插值之前将点重新缩放到单位立方体。如果某些输入维度具有不可比较的单位并且差异为多个数量级，则这很有用。
另请参阅
对非结构化 D-D 数据进行插值。
N 维空间中的最近邻插值器。
二维中的分段三次、C1 平滑、曲率最小化插值器。
在规则网格或矩形网格上的插值。
在任意维度的规则或矩形网格上的插值器（[interpn](docs.scipy.org/doc/scipy-1… "scipy.interpolate.interpn"）封装了此类）。
注意
通过 Qhull（[1]）对输入数据进行三角剖分，并在每个三角形上执行线性重心插值来构造插值器。
注意
对于规则网格上的数据，请使用interpn。
参考
示例
我们可以在 2D 平面上进行插值：
>>> from scipy.interpolate import LinearNDInterpolator
>>> 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 = LinearNDInterpolator(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()
方法
__call__(xi) | 在给定点处评估插值器。 |
|---|
scipy.interpolate.NearestNDInterpolator
class scipy.interpolate.NearestNDInterpolator(x, y, rescale=False, tree_options=None)
NearestNDInterpolator(x, y).
N > 1 维的最近邻插值器。
自版本 0.9 新增。
参数：
x(npoints, ndims) 2-D ndarray of floats
数据点坐标。
y(npoints, ) 1-D ndarray of float or complex
数据值。
rescaleboolean, optional
在执行插值之前，将点重新缩放为单位立方体。如果输入维度具有不可比较的单位并且相差多个数量级，则此操作很有用。
自版本 0.14.0 新增。
tree_optionsdict, optional
传递给底层 cKDTree 的选项。
自版本 0.17.0 新增。
另请参阅
griddata
插值非结构化的 D-D 数据。
LinearNDInterpolator
N 维分段线性插值器。
CloughTocher2DInterpolator
2D 中分段三次、C1 平滑、曲率最小化插值器。
interpn
在规则网格或矩形网格上进行插值。
RegularGridInterpolator
在任意维度的规则或矩形网格上的插值器（interpn 封装了此类）。
注释
使用 scipy.spatial.cKDTree
注意
对于规则网格上的数据，请使用 interpn。
示例
我们可以在 2D 平面上插值数值：
>>> 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()
方法
__call__(*args, **query_options) | 在给定点评估插值器。 |
|---|
scipy.interpolate.CloughTocher2DInterpolator
class scipy.interpolate.CloughTocher2DInterpolator(points, values, fill_value=nan, tol=1e-06, maxiter=400, rescale=False)
CloughTocher2DInterpolator(points, values, tol=1e-6)。
2D 中分段三次、C1 平滑、曲率最小化的插值器。
从版本 0.9 开始新增。
参数：
points浮点数的 ndarray，形状为(npoints, ndims)；或 Delaunay
数据点坐标的 2-D 数组，或预计算的 Delaunay 三角化。
values浮点数或复数的 ndarray，形状为(npoints, …)
N-D 数组，表示points处的数据值。values沿第一个轴的长度必须等于points的长度。与某些插值器不同，插值轴不能更改。
fill_valuefloat, optional
用于填充请求点超出输入点凸包的值。如果未提供，则默认为nan。
tolfloat, optional
梯度估计的绝对/相对容差。
maxiterint, optional
梯度估计中的最大迭代次数。
rescalebool, optional
在执行插值之前将点重新缩放到单位立方体中。如果一些输入维度具有不可共享的单位，并且相差许多数量级，则这是有用的。
另请参阅
griddata
对非结构化 D-D 数据进行插值。
LinearNDInterpolator
N > 1 维度中的分段线性插值器。
NearestNDInterpolator
N > 1 维度中的最近邻插值器。
interpn
在规则网格或矩形网格上进行插值。
RegularGridInterpolator
在任意维度的规则或矩形网格上进行插值（interpn包装了这个类）。
注释
插值器通过使用 Qhull 对输入数据进行三角化，并在每个三角形上使用 Clough-Tocher 方案构造分段三次插值 Bezier 多项式来构建。插值器保证连续可微。
插值曲面的梯度被选择为使得插值曲面的曲率近似最小化。为此所需的梯度是使用[Nielson83]和[Renka84]中描述的全局算法估计的。
注意
对于规则网格数据，请使用interpn。
参考文献
[1]
[CT]
例如，参见 P. Alfeld, ‘’A trivariate Clough-Tocher scheme for tetrahedral data’’. Computer Aided Geometric Design, 1, 169 (1984); G. Farin, ‘’Triangular Bernstein-Bezier patches’’. Computer Aided Geometric Design, 3, 83 (1986).
[Nielson83]
G. Nielson, ‘’A method for interpolating scattered data based upon a minimum norm network’’. Math. Comp., 40, 253 (1983).
[Renka84]
R. J. Renka and A. K. Cline. ‘’A Triangle-based C1 interpolation method.’’, Rocky Mountain J. Math., 14, 223 (1984).
示例
我们可以在二维平面上进行插值：
>>> from scipy.interpolate import CloughTocher2DInterpolator
>>> 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 = CloughTocher2DInterpolator(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()
方法
__call__(xi) | 在给定点处评估插值器。 |
|---|
scipy.interpolate.RBFInterpolator
class scipy.interpolate.RBFInterpolator(y, d, neighbors=None, smoothing=0.0, kernel='thin_plate_spline', epsilon=None, degree=None)
N 维中的径向基函数（RBF）插值。
参数：
y(npoints, ndims) 数组类
二维数据点坐标数组。
d(npoints, …) 数组类
在y处的 N 维数据值数组。d沿第一个轴的长度必须等于y的长度。与某些插值器不同，插值轴不能更改。
邻居int，可选
如果指定，每个评估点处的插值器值将仅使用这些最近的数据点。默认情况下使用所有数据点。
平滑float 或 (npoints, ) 数组类，可选
平滑参数。当设置为 0 时，插值器完美适合数据。对于较大的值，插值器接近指定次数多项式的最小二乘拟合。默认值为 0。
核心str，可选
RBF 的类型。应为以下之一
- ‘线性’：
-r- ‘薄板样条’：
r**2 * log(r)- ‘三次’：
r**3- ‘五次’：
-r**5- ‘多孔径’：
-sqrt(1 + r**2)- ‘逆多孔径’：
1/sqrt(1 + r**2)- ‘逆二次’：
1/(1 + r**2)- ‘高斯’：
exp(-r**2)
默认为‘薄板样条’。
epsilonfloat，可选
形状参数，将输入缩放到 RBF。如果kernel为‘线性’、‘薄板样条’、‘三次’或‘五次’，默认为 1，可以忽略，因为它与缩放平滑参数具有相同效果。否则，必须指定此参数。
次数int，可选
添加多项式的次数。对于某些 RBF，如果多项式次数太小，插值器可能不是良好的形式。这些 RBF 及其对应的最小次数为
- ‘多孔径’：0
- ‘线性’：0
- ‘薄板样条’：1
- ‘三次’：1
- ‘五次’：2
默认值为kernel的最小次数，如果没有最小次数则为 0。将其设置为-1 以取消添加多项式。
另请参阅
注释
RBF 是 N 维空间中的标量值函数，其在(x)处的值可以用(r=||x - c||)表示，其中(c)是 RBF 的中心。
数据值向量(d)的 RBF 插值器，这些数据值来自位置(y)，是以(y)为中心的 RBF 的线性组合加上指定度数的多项式。RBF 插值器表示为
[f(x) = K(x, y) a + P(x) b]
其中 (K(x, y)) 是以(y)为中心的 RBF 矩阵，在点(x)处评估，(P(x)) 是包含具有指定度数的多项式的矩阵，评估在(x)处。系数(a)和(b)是线性方程组的解
[(K(y, y) + \lambda I) a + P(y) b = d]
和
[P(y)^T a = 0]
其中 (\lambda) 是一个非负的平滑参数，控制我们希望拟合数据的程度。当平滑参数为 0 时，数据可以完全拟合。
以上系统在满足以下要求时是唯一可解的：
- (P(y)) 必须具有完整的列秩。当degree为-1 或 0 时，(P(y)) 总是具有完整的列秩。当degree为 1 时，如果数据点位置不全共线（N=2）、共面（N=3）等，则(P(y)) 具有完整的列秩。
- 如果kernel是 'multiquadric'、'linear'、'thin_plate_spline'、'cubic' 或 'quintic'，则degree不能低于上述最小值。
- 如果smoothing为 0，则每个数据点的位置必须不同。
当使用非尺度不变的 RBF（如 'multiquadric'、'inverse_multiquadric'、'inverse_quadratic' 或 'gaussian'）时，必须选择适当的形状参数（例如通过交叉验证）。形状参数较小的值对应于较宽的 RBF。当形状参数过小时，问题可能变得病态或奇异。
解决 RBF 插值系数所需的内存随数据点数的增加而呈二次增长，当插值超过约一千个数据点时可能变得不实用。为了克服大型插值问题的内存限制，可以指定neighbors参数，仅使用最近的数据点为每个评估点计算 RBF 插值。
新版本 1.7.0 中新增。
参考文献
[1]
Fasshauer, G., 2007. 使用 Matlab 的无网格逼近方法。World Scientific Publishing Co.
[2]
amadeus.math.iit.edu/~fass/603_ch3.pdf
[3]
Wahba, G., 1990. 观测数据的样条模型。SIAM。
[4]
pages.stat.wisc.edu/~wahba/stat860public/lect/lect8/lect8.pdf
示例
演示如何将散点数据插值到二维网格。
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.interpolate import RBFInterpolator
>>> from scipy.stats.qmc import Halton
>>> rng = np.random.default_rng()
>>> xobs = 2*Halton(2, seed=rng).random(100) - 1
>>> yobs = np.sum(xobs, axis=1)*np.exp(-6*np.sum(xobs**2, axis=1))
>>> xgrid = np.mgrid[-1:1:50j, -1:1:50j]
>>> xflat = xgrid.reshape(2, -1).T
>>> yflat = RBFInterpolator(xobs, yobs)(xflat)
>>> ygrid = yflat.reshape(50, 50)
>>> fig, ax = plt.subplots()
>>> ax.pcolormesh(*xgrid, ygrid, vmin=-0.25, vmax=0.25, shading='gouraud')
>>> p = ax.scatter(*xobs.T, c=yobs, s=50, ec='k', vmin=-0.25, vmax=0.25)
>>> fig.colorbar(p)
>>> plt.show()
方法
__call__(x) | 在x处评估插值器。 |
|---|
scipy.interpolate.Rbf
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.Rbf.html#scipy.interpolate.Rbf
class scipy.interpolate.Rbf(*args, **kwargs)
用于将 N-D 分散数据上的函数插值到 M-D 域的径向基函数插值类。
传统
此类被视为传统，将不再接收更新。这也可能意味着在未来的 SciPy 版本中将其移除。Rbf 是传统代码，请使用新的 RBFInterpolator。
参数：
*args 数组
x, y, z, …, d，其中 x, y, z, … 是节点的坐标，d 是节点处的值数组
functionstr 或 callable，可选
基于半径 r 的径向基函数，由范数给出（默认为欧几里得距离）；默认为 ‘multiquadric’：
'multiquadric': sqrt((r/self.epsilon)**2 + 1)
'inverse': 1.0/sqrt((r/self.epsilon)**2 + 1)
'gaussian': exp(-(r/self.epsilon)**2)
'linear': r
'cubic': r**3
'quintic': r**5
'thin_plate': r**2 * log(r)
如果是 callable，则必须接受 2 个参数（self, r）。epsilon 参数将作为 self.epsilon 可用。还将可用其他传入的关键字参数。
epsilonfloat，可选
用于高斯或多重四边形函数的可调整常数 - 默认为节点之间的近似平均距离（这是一个良好的起点）。
smoothfloat，可选
值大于零增加了近似的平滑度。0 是插值（默认），在这种情况下，函数将始终通过节点。
normstr，callable，可选
一个返回两点之间‘距离’的函数，输入为位置数组（x, y, z, ...），输出为距离数组。例如，默认为 ‘euclidean’，使得结果是从 x1 中的每个点到 x2 中的每个点的距离矩阵。更多选项，请参阅 scipy.spatial.distances.cdist 的文档。
modestr，可选
插值的模式，可以是 ‘1-D’（默认）或 ‘N-D’。当为 ‘1-D’ 时，数据 d 将被视为 1-D 并在内部被展平。当为 ‘N-D’ 时，数据 d 假定为形状为 (n_samples, m) 的数组，其中 m 是目标域的维数。
另请参阅
RBFInterpolator
示例
>>> import numpy as np
>>> from scipy.interpolate import Rbf
>>> rng = np.random.default_rng()
>>> x, y, z, d = rng.random((4, 50))
>>> rbfi = Rbf(x, y, z, d) # radial basis function interpolator instance
>>> xi = yi = zi = np.linspace(0, 1, 20)
>>> di = rbfi(xi, yi, zi) # interpolated values
>>> di.shape
(20,)
属性：
Nint
数据点的数量（由输入数组确定）。
dindarray
在每个数据坐标 xi 处的 1-D 数据值数组。
xindarray
数据坐标的 2-D 数组。
functionstr 或 callable
径向基函数。请参阅参数下的描述。
epsilonfloat
用于高斯或多重四边形函数的参数。请参阅参数。
smoothfloat
平滑参数。请参阅参数下的描述。
normstr 或 callable
距离函数。请参阅参数下的描述。
modestr
插值的模式。详见参数描述。
nodes ndarray
用于插值的节点值的一维数组。
A内部属性，不要使用
方法
__call__(*args) | 将自身作为函数调用。 |
|---|
scipy.interpolate.interp2d
class scipy.interpolate.interp2d(x, y, z, kind='linear', copy=True, bounds_error=False, fill_value=None)
从 1.10.0 版本开始不推荐使用：interp2d 在 SciPy 1.10 中已经不推荐使用，并将在 SciPy 1.14.0 中移除。
对于旧代码，几乎可以逐字替换的是正则网格上的 RectBivariateSpline ，以及散落的 2D 数据的 bisplrep/bisplev。
在新代码中，对于规则网格，请使用 RegularGridInterpolator 。对于散射数据，请优先考虑使用 LinearNDInterpolator 或 CloughTocher2DInterpolator。
更多细节请参阅 scipy.github.io/devdocs/notebooks/interp_transition_guide.html
在 2-D 网格上进行插值。
x、y 和 z 是用于逼近某个函数 f 的值的数组：z = f(x, y) 返回标量值 z。此类返回一个函数，其调用方法使用样条插值来找到新点的值。
如果 x 和 y 表示规则网格，请考虑使用 RectBivariateSpline。
如果 z 是矢量值，请考虑使用 interpn。
请注意，对带有 NaN 的输入值调用 interp2d ，或者在 x 和 y 的值递减时调用该函数会导致未定义的行为。
参数：
x, yarray_like
定义数据点坐标的数组。数据点坐标需要按递增顺序排序。
如果点位于规则网格上，x 可以指定列坐标，y 可以指定行坐标，例如：
>>> x = [0,1,2]; y = [0,3]; z = [[1,2,3], [4,5,6]]
此外，x 和 y 必须指定每个点的完整坐标，例如：
>>> x = [0,1,2,0,1,2]; y = [0,0,0,3,3,3]; z = [1,4,2,5,3,6]
如果 x 和 y 是多维的，则在使用之前进行扁平化。
zarray_like
要在数据点处进行插值的函数值。如果z是多维数组，则在使用之前将其展平，假设 Fortran 顺序（order=’F’）。展平的z数组的长度是 len(x)len(y)，如果x和y指定了列和行坐标，或者len(z) == len(x) == len(y)，如果x和y*为每个点指定了坐标。
kind{‘linear’, ‘cubic’, ‘quintic’}，可选
要使用的样条插值类型。默认为'linear'。
copybool，可选
如果为 True，类会对 x、y 和 z 进行内部复制。如果为 False，可能使用引用。默认是复制。
bounds_errorbool，可选
如果为 True，在请求输入数据（x，y）域之外的插值值时引发 ValueError。如果为 False，则使用fill_value。
fill_valuenumber，可选
如果提供了，在插值域之外的点所使用的值。如果省略（None），则通过最近邻外推来进行外推。
另请参阅
如果您的输入数据在网格上，则进行 2-D 插值速度更快
基于 FITPACK 的样条插值
FITPACK 例程的更新封装
此函数的一维版本
在任意维度的规则或矩形网格上进行插值。
在规则网格上的多维插值（封装RegularGridInterpolator和RectBivariateSpline）。
注意事项
插值轴上所需的最小数据点数为(k+1)**2，其中 k=1 对于线性插值，k=3 对于三次插值，k=5 对于五次插值。
插值器是通过bisplrep构建的，平滑因子为 0。如果需要更多对平滑的控制，应直接使用bisplrep。
要插值的数据点坐标xnew和ynew必须按升序排序。interp2d 是遗留代码，不推荐在新代码中使用。新代码应改用 RegularGridInterpolator。
示例
构建一个二维网格并进行插值：
>>> import numpy as np
>>> from scipy import interpolate
>>> x = np.arange(-5.01, 5.01, 0.25)
>>> y = np.arange(-5.01, 5.01, 0.25)
>>> xx, yy = np.meshgrid(x, y)
>>> z = np.sin(xx**2+yy**2)
>>> f = interpolate.interp2d(x, y, z, kind='cubic')
现在使用获得的插值函数并绘制结果：
>>> import matplotlib.pyplot as plt
>>> xnew = np.arange(-5.01, 5.01, 1e-2)
>>> ynew = np.arange(-5.01, 5.01, 1e-2)
>>> znew = f(xnew, ynew)
>>> plt.plot(x, z[0, :], 'ro-', xnew, znew[0, :], 'b-')
>>> plt.show()
方法
__call__(x, y[, dx, dy, assume_sorted]) | 插值函数。 |
|---|
scipy.interpolate.interpn
scipy.interpolate.interpn(points, values, xi, method='linear', bounds_error=True, fill_value=nan)
在常规或矩形网格上的多维插值。
严格来说，并非所有常规网格都受支持 - 此函数适用于矩形网格，即具有均匀或不均匀间距的矩形网格。
参数：
points 数组的元组，其中每个元素为 float 的 ndarray，形状为 (m1, ), …, (mn, )
定义 n 维常规网格的点。每个维度的点（即点元组的每个元素）必须严格升序或降序。
values 类似数组，形状为 (m1, …, mn, …)
在 n 维常规网格上的数据。复杂数据可以接受。
xi 形状为 (…, ndim) 的 ndarray
用于对网格化数据进行采样的坐标
method 字符串，可选
执行的插值方法。支持的方法有“linear”、“nearest”、“slinear”、“cubic”、“quintic”、“pchip” 和 “splinef2d”。仅支持二维数据的“splinef2d”方法。
bounds_error 布尔值，可选
如果为 True，则在请求超出输入数据域的插值值时，会引发 ValueError。如果为 False，则使用 fill_value。
fill_value 数字，可选
如果提供，则用于超出插值域的点的值。如果为 None，则在域外使用外推。不支持方法“splinef2d”进行外推。
返回：
values_x ndarray，形状为 xi.shape[:-1] + values.shape[ndim:]
xi 处的插值值。查看笔记以了解当 xi.ndim == 1 时的行为。
另请参见
NearestNDInterpolator
在 N 维非结构化数据上的最近邻插值
LinearNDInterpolator
在 N 维非结构化数据上的分段线性插值
RegularGridInterpolator
任意维度的常规或矩形网格上的插值（interpn 封装了这个类）。
RectBivariateSpline
在矩形网格上的双变量样条逼近
scipy.ndimage.map_coordinates
等间距网格上的插值（适用于例如 N 维图像重采样）
注意事项
新增于版本 0.14。
如果 xi.ndim == 1，则在返回的数组 values_x 的位置 0 处插入一个新的轴，因此其形状变为 (1,) + values.shape[ndim:]。
如果输入数据的输入维度具有不兼容的单位，并且相差多个数量级，插值可能会产生数值上的人为现象。在插值之前考虑重新缩放数据。
示例
在一个常规的三维网格上对点评估一个简单的示例函数：
>>> 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'))
在一个点上评估插值函数
>>> point = np.array([2.21, 3.12, 1.15])
>>> print(interpn(points, values, point))
[12.63]
scipy.interpolate.RegularGridInterpolator
class scipy.interpolate.RegularGridInterpolator(points, values, method='linear', bounds_error=True, fill_value=nan)
在任意维度的规则或矩形网格上的插值器。
数据必须在矩形网格上定义；即，具有均匀或不均匀间距的矩形网格。支持线性、最近邻、样条插值。设置插值器对象后，可以在每次评估时选择插值方法。
参数：
points浮点数的 ndarray 元组，形状为(m1, ), …, (mn, )
定义 n 维度规则网格的点。每个维度的点（即 points 元组的每个元素）必须严格升序或降序排列。
valuesarray_like，形状为(m1, …, mn, …)
n 维度正则网格上的数据。复杂数据可以接受。
method字符串，可选
执行的插值方法。支持的有“linear”、“nearest”、“slinear”、“cubic”、“quintic”和“pchip”。此参数将成为对象的__call__方法的默认值。默认为“linear”。
bounds_error布尔值，可选
如果为 True，在请求超出输入数据域的插值值时，将引发 ValueError。如果为 False，则使用fill_value。默认为 True。
fill_value浮点数或 None，可选
用于超出插值域的点的值。如果为 None，则在域外使用外推值。默认为np.nan。
另请参阅
NearestNDInterpolator
在 N 维度的非结构化数据上使用最近邻插值器
LinearNDInterpolator
在 N 维度的非结构化数据上的分段线性插值器
interpn
包装了RegularGridInterpolator的便利函数
scipy.ndimage.map_coordinates
在具有相等间距的网格上插值（适用于例如 N-D 图像重采样）
注意事项
与 LinearNDInterpolator 和 NearestNDInterpolator 相反，这个类通过利用规则网格结构来避免输入数据的昂贵三角化。
换句话说，这个类假设数据定义在矩形网格上。
自版本 0.14 新增。
‘slinear’（k=1），‘cubic’（k=3）和‘quintic’（k=5）方法是张量积样条插值器，其中 k 是样条度数，如果任何维度的点少于 k + 1，则会引发错误。
自版本 1.9 新增。
如果输入数据的维度具有不可比较的单位并且相差多个数量级，则插值可能会出现数值伪影。在插值之前考虑重新缩放数据。
参考
[1]
Python 包 regulargrid 由 Johannes Buchner 提供，详见 pypi.python.org/pypi/regulargrid/
[2]
维基百科，“三线性插值”，en.wikipedia.org/wiki/Trilinear_interpolation
[3]
Weiser, Alan, 和 Sergio E. Zarantonello. “关于分段线性和多线性表插值的注记。” MATH. COMPUT. 50.181 (1988): 189-196. 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
示例
在三维网格点上评估函数
作为第一个例子，我们在三维网格点上评估一个简单的示例函数：
>>> 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 现在是一个三维数组，其中 data[i, j, k] = f(x[i], y[j], z[k])。接下来，从这些数据定义一个插值函数：
>>> interp = RegularGridInterpolator((x, y, z), data)
在两个点 (x,y,z) = (2.1, 6.2, 8.3) 和 (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])
它实际上是与
>>> f(2.1, 6.2, 8.3), f(3.3, 5.2, 7.1)
(125.54200000000002, 145.894)
插值和外推一个二维数据集
作为第二个例子，我们插值和外推一个二维数据集：
>>> 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')
在更细的网格上评估和绘制插值器
>>> 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()
在教程中还提供了其他示例 ../../tutorial/interpolate/ND_regular_grid.html#tutorial-interpolate-regular-grid-interpolator。
属性：
gridndarrays 的元组
定义 n 维规则网格的点。此元组通过 np.meshgrid(*grid, indexing='ij') 定义完整网格。
valuesndarray
网格上的数据值。
methodstr
插值方法。
fill_valuefloat 或 None
在超出范围的参数上使用此值来调用__call__。
bounds_errorbool
如果为True，超出范围的参数会引发ValueError。
方法
__call__(xi[, method]) | 在坐标处进行插值。 |
|---|
scipy.interpolate.RectBivariateSpline
class scipy.interpolate.RectBivariateSpline(x, y, z, bbox=[None, None, None, None], kx=3, ky=3, s=0)
矩形网格上的双变量样条逼近。
可用于平滑和插值数据。
参数：
x,y数组型
严格升序的坐标 1-D 数组。对于超出数据范围的评估点将进行外推。
z数组型
形状为(x.size, y.size)的 2-D 数据数组。
bbox数组型，可选
长度为 4 的序列，指定矩形逼近域的边界，这意味着每个维度的起始和结束样条结点由这些值设定。默认情况下，bbox=[min(x), max(x), min(y), max(y)]。
kx, ky整数，可选
Bivariate spline 的度数。默认为 3。
s浮点数，可选
正的平滑因子，用于估计条件：sum((z[i]-f(x[i], y[i]))**2, axis=0) <= s，其中 f 是样条函数。默认为s=0，用于插值。
另请参见
BivariateSpline
用于双变量样条的基类。
UnivariateSpline
平滑的单变量样条，用于拟合给定的数据点集。
SmoothBivariateSpline
通过给定点的平滑双变量样条
LSQBivariateSpline
使用加权最小二乘拟合的双变量样条
RectSphereBivariateSpline
球面上矩形网格上的双变量样条
SmoothSphereBivariateSpline
球面坐标中的平滑双变量样条
LSQSphereBivariateSpline
使用加权最小二乘拟合的球面坐标中的双变量样条
bisplrep
找到表面的双变量 B 样条表示的函数
bisplev
评估双变量 B 样条及其导数的函数
笔记
如果输入数据的输入维度具有不兼容的单位并且相差许多数量级，则插值可能会产生数值人工现象。考虑在插值之前重新缩放数据。
方法
__call__(x, y[, dx, dy, grid]) | 在给定位置评估样条或其导数。 |
|---|---|
ev(xi, yi[, dx, dy]) | 在给定点评估样条 |
get_coeffs() | 返回样条系数。 |
get_knots() | 返回一个元组 (tx,ty)，其中 tx,ty 分别包含关于 x 变量和 y 变量的样条结点位置。 |
get_residual() | 返回样条逼近的加权残差的平方和：sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0) |
integral(xa, xb, ya, yb) | 评估样条在区域 [xa,xb] x [ya,yb] 上的积分。 |
partial_derivative(dx, dy) | 构建表示此样条的偏导数的新样条。 |
scipy.interpolate.NdPPoly
class scipy.interpolate.NdPPoly(c, x, extrapolate=None)
分段张量积多项式
评估点 xp = (x', y', z', ...) 处的值首先通过计算使得区间索引 i 满足条件：
x[0][i[0]] <= x' < x[0][i[0]+1]
x[1][i[1]] <= y' < x[1][i[1]+1]
...
然后计算：
S = sum(c[k0-m0-1,...,kn-mn-1,i[0],...,i[n]]
* (xp[0] - x[0][i[0]])**m0
* ...
* (xp[n] - x[n][i[n]])**mn
for m0 in range(k[0]+1)
...
for mn in range(k[n]+1))
其中 k[j] 是维度 j 中多项式的次数。这种表示是分段多变量幂基础。
参数：
c：ndarray，形状为 (k0, …, kn, m0, …, mn, …)
多项式系数，具有多项式阶数 kj 和每个维度 j 的 mj+1 个区间。
x：ndim-ndarray，形状为 (mj+1,)
每个维度的多项式断点。这些必须按升序排序。
extrapolate：bool，可选
是否基于第一个和最后一个区间对越界点进行外推，或返回 NaN。默认值：True。
参见
1D 中的分段多项式
注意事项
功率基础中的高阶多项式可能数值不稳定。
属性：
x：ndarrays 元组
断点。
c：ndarray
多项式的系数。
方法
__call__(x[, nu, extrapolate]) | 计算分段多项式或其导数的值。 |
|---|---|
derivative(nu) | 构造一个表示导数的新分段多项式。 |
antiderivative(nu) | 构造一个表示原函数的新分段多项式。 |
integrate(ranges[, extrapolate]) | 计算分段多项式的定积分。 |
integrate_1d(a, b, axis[, extrapolate]) | 计算一维定积分的 NdPPoly 表示 |
construct_fast(c, x[, extrapolate]) | 构造分段多项式，无需进行检查。 |
