SciPy-1-12-中文文档-五-
SciPy 1.12 中文文档（五）
scipy.integrate.complex_ode
class scipy.integrate.complex_ode(f, jac=None)
用于复杂系统的 ode 的包装器。
这个函数类似于ode，但在使用积分器之前，将复值方程系统重新映射为实值方程系统。
参数：
f可调用函数 f(t, y, *f_args)
方程的右手边。t 是标量，y.shape == (n,)。通过调用 set_f_params(*args) 设置 f_args。
jac可调用函数 jac(t, y, *jac_args)
方程的雅可比矩阵，jac[i,j] = d f[i] / d y[j]。通过调用 set_f_params(*args) 设置 jac_args。
示例
有关用法示例，请参见ode。
属性：
t浮点数
当前时间。
y数组
当前变量值。
方法
get_return_code() |
提取积分的返回代码，以便在积分失败时更好地控制。 |
|---|---|
integrate(t[, step, relax]) |
找到 y=y(t)，将 y 设置为初始条件，并返回 y。 |
set_f_params(*args) |
为用户提供的函数 f 设置额外参数。 |
set_initial_value(y[, t]) |
设置初始条件 y(t) = y。 |
set_integrator(name, **integrator_params) |
按名称设置积分器。 |
set_jac_params(*args) |
为用户提供的函数 jac 设置额外参数。 |
set_solout(solout) |
设置在每次成功积分步骤时调用的可调用函数。 |
successful() |
检查积分是否成功。 |
scipy.integrate.ODEintWarning
exception scipy.integrate.ODEintWarning
在执行odeint时引发警告。
with_traceback()
Exception.with_traceback(tb) – 将 self.traceback 设置为 tb 并返回 self。
scipy.integrate.odeint
scipy.integrate.odeint(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None, tcrit=None, h0=0.0, hmax=0.0, hmin=0.0, ixpr=0, mxstep=0, mxhnil=0, mxordn=12, mxords=5, printmessg=0, tfirst=False)
求解一组普通微分方程。
注意
对于新代码，使用scipy.integrate.solve_ivp来求解微分方程。
使用来自 FORTRAN 库 odepack 的 lsoda 解决一组普通微分方程。
解决第一阶 ODE-s 的初始值问题，对于刚性或非刚性系统：
dy/dt = func(y, t, ...) [or func(t, y, ...)]
其中 y 可以是一个向量。
注意
默认情况下，func的前两个参数的顺序与scipy.integrate.ode类和函数scipy.integrate.solve_ivp中系统定义函数的参数顺序相反。要使用带有签名func(t, y, ...)的函数，必须将参数tfirst设置为True。
参数：
funccallable(y, t, …) 或 callable(t, y, …)
计算 t 处 y 的导数。如果签名是callable(t, y, ...)，则必须设置参数tfirst为True。
y0数组
y 的初始条件（可以是向量）。
t数组
用于求解 y 的时间点序列。初始值点应该是此序列的第一个元素。该序列必须单调递增或单调递减；允许重复值。
args元组，可选
传递给函数的额外参数。
Dfuncallable(y, t, …) 或 callable(t, y, …)
func的梯度（雅可比）。如果签名是callable(t, y, ...)，则必须设置参数tfirst为True。
col_deriv布尔值，可选
如果Dfun沿列定义导数（更快），否则Dfun应在行间定义导数。
full_output布尔值，可选
如果返回第二个输出作为可选输出字典，则为 True。
printmessg布尔值，可选
是否打印收敛消息
tfirst布尔值，可选
如果为 True，则func（以及如果给出的话Dfun）的前两个参数必须是t, y，而不是默认的y, t。
版本 1.1.0 中的新功能。
返回：
y数组，形状为(len(t), len(y0))
包含每个所需时间点 t 处 y 值的数组，第一行中的初始值y0。
infodict字典，仅当 full_output == True 时返回
包含额外输出信息的字典。
| 键 | 含义 |
|---|---|
| ‘hu’ | 每个时间步骤成功使用的步长向量 |
| ‘tcur’ | 每个时间步骤达到的 t 值的向量（始终至少与输入时间大） |
| ‘tolsf’ | 当检测到请求过高精度时计算的容差比例因子向量，大于 1.0 |
| ‘tsw’ | 最后一次方法切换时的 t 值（每个时间步给出） |
| ‘nst’ | 累计时间步数 |
| ‘nfe’ | 每个时间步的累计函数评估次数 |
| ‘nje’ | 每个时间步的累计雅可比矩阵评估次数 |
| ‘nqu’ | 每个成功步骤的方法阶数向量 |
| ‘imxer’ | 权重局部误差向量（e / ewt）的最大分量的索引，或错误返回时为-1 |
| ‘lenrw’ | 所需双精度工作数组的长度 |
| ‘leniw’ | 所需整数工作数组的长度 |
| ‘mused’ | 每个成功时间步的方法指示器向量：1 表示 Adams（非刚性），2 表示 BDF（刚性） |
其他参数：
ml, muint, optional
如果这两者都不是 None 或非负，则假定雅可比矩阵为带状矩阵。这些数字给出此带状矩阵中的下限和上限非零对角线数。对于带状情况，Dfun应返回一个矩阵，其行包含非零带（从最低对角线开始）。因此，来自Dfun的返回矩阵jac在ml >=0或mu >=0时应具有形状(ml + mu + 1, len(y0))。jac中的数据必须存储为jac[i - j + mu, j]，其中i方程对j状态变量的导数。如果col_deriv为 True，则必须返回此jac的转置。
rtol, atolfloat, optional
输入参数rtol和atol确定求解器执行的误差控制。求解器将根据形式为max-norm of (e / ewt) <= 1的不等式控制 y 的估计局部误差向量 e，其中 ewt 是计算为ewt = rtol * abs(y) + atol的正误差权重向量。rtol 和 atol 可以是与 y 相同长度的向量或标量。默认为 1.49012e-8。
tcritndarray, optional
需要进行积分关注的临界点（例如奇点）的向量。
h0float, (0: solver-determined), optional
第一步尝试的步长。
hmaxfloat, (0: solver-determined), optional
允许的最大绝对步长。
hminfloat, (0: solver-determined), optional
允许的最小绝对步长。
ixprbool, optional
是否在方法切换时生成额外的打印输出。
mxstepint, (0: solver-determined), optional
每个 t 积分点允许的最大（内部定义的）步数。
mxhnilint, (0: solver-determined), optional
打印的最大消息数。
mxordnint, (0: solver-determined), optional
最大允许的非刚性（Adams）方法阶数。
mxordsint, (0: solver-determined), optional
允许的刚性（BDF）方法的最大阶数。
参见
solve_ivp
解决常微分方程初始值问题
ode
基于 VODE 的更面向对象的积分器
[quad`
用于找到曲线下面积
示例
受重力和摩擦影响的钟摆角度 theta 的二阶微分方程可以写成：
theta''(t) + b*theta'(t) + c*sin(theta(t)) = 0
其中 b 和 c 是正常数，prime（’）表示导数。要用 odeint 解决这个方程，我们必须先将它转换为一阶方程组。通过定义角速度 omega(t) = theta'(t)，我们得到如下系统：
theta'(t) = omega(t)
omega'(t) = -b*omega(t) - c*sin(theta(t))
让 y 为向量 [theta, omega]。我们在 Python 中实现这个系统如下：
>>> import numpy as np
>>> def pend(y, t, b, c):
... theta, omega = y
... dydt = [omega, -b*omega - c*np.sin(theta)]
... return dydt
...
我们假设常数为 b = 0.25 和 c = 5.0：
>>> b = 0.25
>>> c = 5.0
对于初始条件，我们假设钟摆几乎垂直，即 theta(0) = pi - 0.1，并且最初静止，因此 omega(0) = 0。然后初始条件的向量是：
>>> y0 = [np.pi - 0.1, 0.0]
我们将在区间 0 <= t <= 10 中生成 101 个均匀间隔的样本点。因此我们的时间数组是：
>>> t = np.linspace(0, 10, 101)
调用 odeint 生成解。要将参数 b 和 c 传递给 pend，我们使用 args 参数将它们传递给 odeint。
>>> from scipy.integrate import odeint
>>> sol = odeint(pend, y0, t, args=(b, c))
解是一个形状为 (101, 2) 的数组。第一列是 theta(t)，第二列是 omega(t)。下面的代码绘制了这两个分量。
>>> import matplotlib.pyplot as plt
>>> plt.plot(t, sol[:, 0], 'b', label='theta(t)')
>>> plt.plot(t, sol[:, 1], 'g', label='omega(t)')
>>> plt.legend(loc='best')
>>> plt.xlabel('t')
>>> plt.grid()
>>> plt.show()
scipy.integrate.solve_bvp
scipy.integrate.solve_bvp(fun, bc, x, y, p=None, S=None, fun_jac=None, bc_jac=None, tol=0.001, max_nodes=1000, verbose=0, bc_tol=None)
解决 ODE 系统的边界值问题。
此函数数值解一个带有两点边界条件的一阶 ODE 系统：
dy / dx = f(x, y, p) + S * y / (x - a), a <= x <= b
bc(y(a), y(b), p) = 0
这里 x 是一个 1-D 独立变量，y(x) 是一个 N-D 向量值函数，p 是一个 k-D 未知参数向量，它与 y(x) 一起被找到。为了确定问题，必须有 n + k 个边界条件，即 bc 必须是一个 (n + k)-D 函数。
系统右手边的最后一个奇异项是可选的。它由一个 n×n 矩阵 S 定义，使得解必须满足 S y(a) = 0。此条件将在迭代过程中强制执行，因此不得与边界条件相矛盾。详见 [2]，解释在数值求解 BVPs 时如何处理此项。
也可以解决复杂域中的问题。在这种情况下，y 和 p 被视为复数，f 和 bc 被假定为复值函数，但 x 保持实数。注意 f 和 bc 必须是复可微的（满足柯西-黎曼方程 [4]），否则应将问题分别重写为实部和虚部。要在复杂域中解决问题，请传递一个带有复数数据类型的初始猜测值 y。
参数：
funcallable
系统的右手边。调用签名为 fun(x, y) 或者如果存在参数则为 fun(x, y, p)。所有参数都是 ndarray：x 的形状为 (m,)，y 的形状为 (n, m)，意味着 y[:, i] 对应于 x[i]，p 的形状为 (k,)。返回值必须是形状为 (n, m) 的数组，并且与 y 的布局相同。
bccallable
评估边界条件残差的函数。调用签名为 bc(ya, yb) 或者如果存在参数则为 bc(ya, yb, p)。所有参数都是 ndarray：ya 和 yb 的形状为 (n,)，p 的形状为 (k,)。返回值必须是形状为 (n + k,) 的数组。
xarray_like，形状为 (m,)
初始网格。必须是一系列严格增加的实数，满足 x[0]=a 和 x[-1]=b。
yarray_like，形状为 (n, m)
函数在网格节点处的初始猜测值，第 i 列对应于 x[i]。对于复数域中的问题，即使初始猜测是纯实数，也要传递带有复数数据类型的 y。
p形状为 (k,) 的数组或 None，可选
未知参数的初始猜测值。如果为 None（默认），则假定问题不依赖于任何参数。
S形状为 (n, n) 的数组或 None
定义奇异项的矩阵。如果为 None（默认），则在没有奇异项的情况下解决问题。
fun_jaccallable 或 None，可选
计算 f 对 y 和 p 的导数的函数。其调用签名为 fun_jac(x, y) 或者如果存在参数则为 fun_jac(x, y, p)。返回必须按以下顺序包含 1 或 2 个元素：
- df_dy：形状为 (n, n, m) 的 array_like，其中元素 (i, j, q) 等于 d f_i(x_q, y_q, p) / d (y_q)_j。
- df_dp：形状为 (n, k, m) 的 array_like，其中元素 (i, j, q) 等于 d f_i(x_q, y_q, p) / d p_j。
此处 q 表示 x 和 y 定义的节点数，而 i 和 j 表示向量分量数。如果问题在没有未知参数的情况下解决，则不应返回 df_dp。
如果 fun_jac 为 None（默认情况下），则通过向前有限差分法估计导数。
bc_jac可调用对象或 None，可选
计算 bc 对 ya、yb 和 p 的导数的函数。其调用签名为 bc_jac(ya, yb) 或者如果存在参数则为 bc_jac(ya, yb, p)。返回必须按以下顺序包含 2 或 3 个元素：
- dbc_dya：形状为 (n, n) 的 array_like，其中元素 (i, j) 等于 d bc_i(ya, yb, p) / d ya_j。
- dbc_dyb：形状为 (n, n) 的 array_like，其中元素 (i, j) 等于 d bc_i(ya, yb, p) / d yb_j。
- dbc_dp：形状为 (n, k) 的 array_like，其中元素 (i, j) 等于 d bc_i(ya, yb, p) / d p_j。
如果问题在没有未知参数的情况下解决，则不应返回 dbc_dp。
如果 bc_jac 为 None（默认情况下），则通过向前有限差分法估计导数。
tolfloat，可选
求解的所需解的容差。如果我们定义 r = y' - f(x, y)，其中 y 是找到的解，则求解器试图在每个网格间隔上实现 norm(r / (1 + abs(f)) < tol 的标准（使用数值积分公式估计的均方根）。默认为 1e-3。
max_nodesint，可选
允许的最大网格节点数。如果超过，则算法终止。默认为 1000。
verbose，可选
算法详细程度的级别：
- 0（默认值）：静默工作。
- 1：显示终止报告。
- 2：迭代过程中显示进展。
bc_tolfloat，可选
边界条件残差的所需绝对容差：bc 值应满足 abs(bc) < bc_tol 每个分量。默认为 tol。允许最多 10 次迭代以达到此容差。
返回：
具有以下字段定义的 Bunch 对象：
solPPoly
找到关于 y 的解为 scipy.interpolate.PPoly 实例，一个 C1 连续的三次样条。
pndarray 或 None，形状 (k,)
找到的参数。如果问题中不存在参数，则为 None。
xndarray，形状为 (m,)
最终网格的节点。
yndarray，形状为 (n, m)
在网格节点处的解值。
ypndarray，形状为 (n, m)
解在网格节点处的导数。
rms_residualsndarray，形状为 (m - 1,)
相对于每个网格间隔的相对残差的 RMS 值（请参阅 tol 参数的描述）。
niterint
完成迭代的次数。
statusint
算法终止的原因：
- 0: 算法收敛到期望的精度。
- 1: 超过了最大网格节点数。
- 2: 在解决匹配系统时遇到奇异雅可比矩阵。
messagestring
终止原因的口头描述。
successbool
如果算法收敛到期望的精度（status=0）则返回真。
注释
此函数实现了一个具有残差控制的 4 阶匹配算法，类似于 [1]。一个匹配系统通过一个具有仿射不变判据函数的阻尼牛顿法解决，如 [3] 所述。
注意，在 [1] 中，积分残差的定义没有通过区间长度进行归一化。因此，它们的定义与此处使用的定义相差一个 h**0.5 的乘数（其中 h 是区间长度）。
从版本 0.18.0 开始新增。
参考文献
[1] (1,2)
J. Kierzenka, L. F. Shampine, “基于残差控制和 Maltab PSE 的 BVP 求解器”，ACM 数学软件交易，第 27 卷，第 3 期，2001 年，299-316 页。
[2]
L.F. Shampine, P. H. Muir 和 H. Xu，“一个用户友好的 Fortran BVP 求解器”。
[3]
U. Ascher, R. Mattheij 和 R. Russell，“常微分方程边值问题的数值解法”。
[4]
共轭复数-黎曼方程 在维基百科上。
示例
在第一个例子中，我们解决 Bratu 的问题：
y'' + k * exp(y) = 0
y(0) = y(1) = 0
对于 k = 1。
我们将方程重写为一个一阶系统，并实现其右手边的评估：
y1' = y2
y2' = -exp(y1)
>>> import numpy as np
>>> def fun(x, y):
... return np.vstack((y[1], -np.exp(y[0])))
实现边界条件残差的评估：
>>> def bc(ya, yb):
... return np.array([ya[0], yb[0]])
定义具有 5 个节点的初始网格：
>>> x = np.linspace(0, 1, 5)
这个问题已知有两个解。为了获得这两个解，我们对 y 使用两个不同的初始猜测，分别用下标 a 和 b 表示。
>>> y_a = np.zeros((2, x.size))
>>> y_b = np.zeros((2, x.size))
>>> y_b[0] = 3
现在我们准备运行求解器。
>>> from scipy.integrate import solve_bvp
>>> res_a = solve_bvp(fun, bc, x, y_a)
>>> res_b = solve_bvp(fun, bc, x, y_b)
让我们绘制这两个找到的解。我们利用解的样条形式来产生*滑的图形。
>>> x_plot = np.linspace(0, 1, 100)
>>> y_plot_a = res_a.sol(x_plot)[0]
>>> y_plot_b = res_b.sol(x_plot)[0]
>>> import matplotlib.pyplot as plt
>>> plt.plot(x_plot, y_plot_a, label='y_a')
>>> plt.plot(x_plot, y_plot_b, label='y_b')
>>> plt.legend()
>>> plt.xlabel("x")
>>> plt.ylabel("y")
>>> plt.show()
我们看到两个解的形状相似，但在尺度上有显著差异。
在第二个例子中，我们解决一个简单的 Sturm-Liouville 问题：
y'' + k**2 * y = 0
y(0) = y(1) = 0
已知对于 k = pi * n（其中 n 是整数），存在非*凡解 y = A * sin(k * x)。为了建立归一化常数 A = 1，我们添加一个边界条件：
y'(0) = k
再次，我们将方程重写为一个一阶系统，并实现其右手边的评估：
y1' = y2
y2' = -k**2 * y1
>>> def fun(x, y, p):
... k = p[0]
... return np.vstack((y[1], -k**2 * y[0]))
注意，在 [1] 中，参数 p 被作为一个向量传递（在我们的情况下只有一个元素）。
实现边界条件：
>>> def bc(ya, yb, p):
... k = p[0]
... return np.array([ya[0], yb[0], ya[1] - k])
设置初始网格和 y 的猜测。我们旨在找到 k = 2 * pi 的解，为此我们设置 y 的值以*似 sin(2 * pi * x)：
>>> x = np.linspace(0, 1, 5)
>>> y = np.zeros((2, x.size))
>>> y[0, 1] = 1
>>> y[0, 3] = -1
使用 6 作为 k 的初始猜测来运行求解器。
>>> sol = solve_bvp(fun, bc, x, y, p=[6])
我们看到找到的 k 大致正确：
>>> sol.p[0]
6.28329460046
最后，绘制解以查看预期的正弦波形：
>>> x_plot = np.linspace(0, 1, 100)
>>> y_plot = sol.sol(x_plot)[0]
>>> plt.plot(x_plot, y_plot)
>>> plt.xlabel("x")
>>> plt.ylabel("y")
>>> plt.show()
插值（scipy.interpolate）
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/interpolate.html
用于插值的子包对象。
如下所列，这个子包含有样条函数和类、1-D 和多维（单变量和多变量）插值类、Lagrange 和 Taylor 多项式插值器，以及 FITPACK 和 DFITPACK 函数的封装。
单变量插值
interp1d(x, y[, kind, axis, copy, ...]) |
对一个 1-D 函数进行插值 |
|---|---|
BarycentricInterpolator(xi[, yi, axis, wi, ...]) |
一组点的插值多项式 |
KroghInterpolator(xi, yi[, axis]) |
一组点的插值多项式 |
barycentric_interpolate(xi, yi, x[, axis, der]) |
多项式插值的便捷函数 |
krogh_interpolate(xi, yi, x[, der, axis]) |
多项式插值的便捷函数 |
pchip_interpolate(xi, yi, x[, der, axis]) |
pchip 插值的便捷函数 |
CubicHermiteSpline(x, y, dydx[, axis, ...]) |
分段立方插值器，匹配值和一阶导数 |
PchipInterpolator(x, y[, axis, extrapolate]) |
PCHIP 1-D 单调立方插值器 |
Akima1DInterpolator(x, y[, axis]) |
Akima 插值器 |
CubicSpline(x, y[, axis, bc_type, extrapolate]) |
立方样条数据插值器 |
PPoly(c, x[, extrapolate, axis]) |
由系数和断点表示的分段多项式 |
BPoly(c, x[, extrapolate, axis]) |
根据系数和分断点的分段多项式。 |
多变量插值
非结构化数据：
griddata(points, values, xi[, method, ...]) |
插值非结构化 D-D 数据。 |
|---|---|
LinearNDInterpolator(points, values[, ...]) |
N > 1 维的分段线性插值器。 |
NearestNDInterpolator(x, y[, rescale, ...]) |
最*邻插值器 NearestNDInterpolator(x, y)。 |
CloughTocher2DInterpolator(points, values[, ...]) |
CloughTocher2DInterpolator(points, values, tol=1e-6)。 |
RBFInterpolator(y, d[, neighbors, ...]) |
N 维径向基函数（RBF）插值。 |
Rbf(*args, **kwargs) |
从 N-D 离散数据到 M-D 域的径向基函数插值的类。 |
interp2d(x, y, z[, kind, copy, ...]) |
自版本 1.10.0 起不推荐使用。
|
对于网格数据：
interpn(points, values, xi[, method, ...]) |
在正则或直角网格上进行多维插值。 |
|---|---|
RegularGridInterpolator(points, values[, ...]) |
在任意维度的正则或直角网格上的插值器。 |
RectBivariateSpline(x, y, z[, bbox, kx, ky, s]) |
矩形网格上的双变量样条插值。 |
See also
scipy.ndimage.map_coordinates
张量积多项式：
NdPPoly(c, x[, extrapolate]) |
分段张量积多项式 |
|---|---|
NdBSpline(t, c, k, *[, extrapolate]) |
张量积样条对象。 |
1-D Splines
BSpline(t, c, k[, extrapolate, axis]) |
B 样条基础上的单变量样条。 |
|---|---|
make_interp_spline(x, y[, k, t, bc_type, ...]) |
计算（系数的）插值 B 样条。 |
make_lsq_spline(x, y, t[, k, w, axis, ...]) |
计算（系数的）基于 LSQ（最小二乘）拟合的 B 样条。 |
make_smoothing_spline(x, y[, w, lam]) |
使用 lam 控制曲线*滑度和数据接*度之间的权衡，计算（系数的）*滑立方样条函数。 |
Functional interface to FITPACK routines:
splrep(x, y[, w, xb, xe, k, task, s, t, ...]) |
查找 1-D 曲线的 B 样条表示。 |
|---|---|
splprep(x[, w, u, ub, ue, k, task, s, t, ...]) |
查找 N-D 曲线的 B 样条表示。 |
splev(x, tck[, der, ext]) |
计算 B 样条或其导数的值。 |
splint(a, b, tck[, full_output]) |
计算 B 样条在给定两点之间的定积分。 |
sproot(tck[, mest]) |
查找立方 B 样条的根。 |
spalde(x, tck) |
计算 B 样条的所有导数。 |
splder(tck[, n]) |
计算给定样条导数的样条表示。 |
splantider(tck[, n]) |
计算给定样条的反导数（积分）样条。 |
insert(x, tck[, m, per]) |
在 B 样条中插入结点。 |
Object-oriented FITPACK interface:
UnivariateSpline(x, y[, w, bbox, k, s, ext, ...]) |
给定数据点的一维*滑样条拟合。 |
|---|---|
InterpolatedUnivariateSpline(x, y[, w, ...]) |
给定数据点的一维插值样条。 |
LSQUnivariateSpline(x, y, t[, w, bbox, k, ...]) |
具有显式内结的一维样条。 |
2-D Splines
网格数据：
RectBivariateSpline(x, y, z[, bbox, kx, ky, s]) |
矩形网格上的二元样条逼*。 |
|---|---|
RectSphereBivariateSpline(u, v, r[, s, ...]) |
球面上矩形网格的二元样条逼*。 |
无结构数据：
BivariateSpline() |
二元样条基类。 |
|---|---|
SmoothBivariateSpline(x, y, z[, w, bbox, ...]) |
*滑二元样条逼*。 |
SmoothSphereBivariateSpline(theta, phi, r[, ...]) |
球坐标中*滑二元样条逼*。 |
LSQBivariateSpline(x, y, z, tx, ty[, w, ...]) |
加权最小二乘二元样条逼*。 |
LSQSphereBivariateSpline(theta, phi, r, tt, tp) |
球坐标中加权最小二乘二元样条逼*。 |
FITPACK 函数的底层接口：
bisplrep(x, y, z[, w, xb, xe, yb, ye, kx, ...]) |
表面的二元 B 样条表示。 |
|---|---|
bisplev(x, y, tck[, dx, dy]) |
计算二元 B 样条及其导数。 |
附加工具
lagrange(x, w) |
返回拉格朗日插值多项式。 |
|---|---|
approximate_taylor_polynomial(f, x, degree, ...) |
通过多项式拟合估算 f 在 x 处的 Taylor 多项式。 |
pade(an, m[, n]) |
返回多项式的 Pade *似作为两个多项式的比值。 |
另请参阅
scipy.ndimage.map_coordinates, scipy.ndimage.spline_filter, scipy.signal.resample, scipy.signal.bspline, scipy.signal.gauss_spline, scipy.signal.qspline1d, scipy.signal.cspline1d, scipy.signal.qspline1d_eval, scipy.signal.cspline1d_eval, scipy.signal.qspline2d, scipy.signal.cspline2d.
pchip 是 PchipInterpolator 的别名，用于向后兼容性（新代码中不应使用）。
scipy.interpolate.interp1d
class scipy.interpolate.interp1d(x, y, kind='linear', axis=-1, copy=True, bounds_error=None, fill_value=nan, assume_sorted=False)
插值 1-D 函数。
遗留版本
此类被视为遗留版本，将不再接收更新。这也可能意味着在未来的 SciPy 版本中将其移除。有关预期替代 interp1d 的指南，请参阅 1-D interpolation。
x 和 y 是用来*似某个函数 f 的值的数组：y = f(x)。此类返回一个函数，其调用方法使用插值来找到新点的值。
参数：
x(npoints, ) 类似数组
一个包含实数值的 1-D 数组。
y(…, npoints, …) 类似数组
一个包含实数值的 N-D 数组。沿插值轴的 y 的长度必须等于 x 的长度。使用 axis 参数选择正确的轴。与其他插值器不同，默认插值轴是 y 的最后一个轴。
kindstr 或 int，可选
指定插值类型的字符串或指定要使用的样条插值器的顺序的整数。字符串必须是以下之一：'linear'、'nearest'、'nearest-up'、'zero'、'slinear'、'quadratic'、'cubic'、'previous' 或 'next'。'zero'、'slinear'、'quadratic' 和 'cubic' 分别指零阶、一阶、二阶或三阶样条插值；'previous' 和 'next' 分别返回点的前一个或后一个值；'nearest-up' 和 'nearest' 在插值半整数（例如 0.5、1.5）时有所不同，'nearest-up' 向上取整，而 'nearest' 向下取整。默认为 'linear'。
axisint，可选
y 数组中对应于 x 坐标值的轴。与其他插值器不同，默认为 axis=-1。
copybool，可选
如果为 True，则该类会对 x 和 y 进行内部复制。如果为 False，则使用对 x 和 y 的引用。默认情况下为复制。
bounds_errorbool，可选
如果为 True，在尝试在 x 范围之外的值（需要外推）进行插值时会引发 ValueError。如果为 False，则将超出范围的值分配给 fill_value。默认情况下会引发错误，除非 fill_value="extrapolate"。
fill_value类似数组或（类似数组，类似数组）或“extrapolate”，可选
-
如果是 ndarray（或 float），则此值将用于填充数据范围外请求的点。如果未提供，则默认为 NaN。类似数组必须正确传播到非插值轴的维度。
-
如果是两个元素的元组，则第一个元素用作
x_new < x[0]的填充值，第二个元素用于x_new > x[-1]。任何不是两个元素的元组（例如列表或 ndarray，无论形状如何）都被视为单个类似数组的参数，用于below, above = fill_value, fill_value。使用两个元素的元组或 ndarray 需要bounds_error=False。版本 0.17.0 中的新功能。
-
如果为“extrapolate”，则数据范围外的点将被外推。
版本 0.17.0 中的新功能。
assume_sortedbool，可选
如果为 False，则x的值可以按任意顺序排列，并且它们首先被排序。如果为 True，则x必须是单调递增值的数组。
另请参阅
splrep，splev
基于 FITPACK 的样条插值/*滑。
UnivariateSpline
FITPACK 例程的面向对象封装。
interp2d
二维插值
注意事项
在输入值中存在 NaN 时调用interp1d将导致未定义的行为。
输入值x和y必须可转换为float值，如int或float。
如果x中的值不唯一，则结果行为未定义，并且取决于kind的选择，即更改kind会改变重复项的行为。
示例
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy import interpolate
>>> x = np.arange(0, 10)
>>> y = np.exp(-x/3.0)
>>> f = interpolate.interp1d(x, y)
>>> xnew = np.arange(0, 9, 0.1)
>>> ynew = f(xnew) # use interpolation function returned by `interp1d`
>>> plt.plot(x, y, 'o', xnew, ynew, '-')
>>> plt.show()
属性：
fill_value
填充值。
方法
__call__(x) |
评估插值 |
|---|
scipy.interpolate.BarycentricInterpolator
class scipy.interpolate.BarycentricInterpolator(xi, yi=None, axis=0, *, wi=None, random_state=None)
一组点的插值多项式。
构造通过给定点集的多项式。允许评估多项式及其所有导数，有效更改要插值的 y 值，并通过添加更多的 x 和 y 值进行更新。
出于数值稳定性的原因，此函数不计算多项式的系数。
在函数评估之前需要提供 yi 的值，但前处理不依赖于它们，因此可以快速更新。
参数：
xiarray_like，形状为 (npoints, )
一维数组，多项式应通过的点的 x 坐标
yiarray_like，形状为 (…, npoints, …)，可选
y 坐标的 N-D 数组，多项式应通过这些点。如果为 None，则稍后通过 set_y 方法提供 y 值。沿插值轴的 yi 的长度必须等于 xi 的长度。使用 axis 参数选择正确的轴。
axisint，可选
yi 数组中对应于 x 坐标值的轴。默认为 axis=0。
wiarray_like，可选
所选插值点 xi 的重心权重。如果缺少或为 None，则从 xi 计算权重（默认）。这允许在使用相同节点 xi 计算多个插值时重复使用权重 wi，而无需重新计算。
random_state{None, int, numpy.random.Generator，numpy.random.RandomState}，可选
如果 seed 为 None（或 np.random），则使用 numpy.random.RandomState 单例。如果 seed 是整数，则使用新的 RandomState 实例，并使用 seed 进行种子化。如果 seed 已经是 Generator 或 RandomState 实例，则使用该实例。
注意事项
此类使用“重心插值”方法，将问题视为有理函数插值的特例。这种算法在数值上非常稳定，但即使在精确计算的世界中，除非选择 x 坐标非常仔细 - Chebyshev 零点（例如，cos(i*pi/n)）是一个很好的选择 - 多项式插值本身也是一个非常病态的过程，这是由于 Runge 现象。
基于 Berrut 和 Trefethen 2004 年的“Barycentric Lagrange Interpolation”。
示例
要在区间 ((0, \frac{\pi}{2})) 内使用六个随机分布的节点生成一个*似于函数 (\sin x) 及其前四阶导数的五次重心插值多项式：
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.interpolate import BarycentricInterpolator
>>> rng = np.random.default_rng()
>>> xi = rng.random(6) * np.pi/2
>>> f, f_d1, f_d2, f_d3, f_d4 = np.sin, np.cos, lambda x: -np.sin(x), lambda x: -np.cos(x), np.sin
>>> P = BarycentricInterpolator(xi, f(xi), random_state=rng)
>>> fig, axs = plt.subplots(5, 1, sharex=True, layout='constrained', figsize=(7,10))
>>> x = np.linspace(0, np.pi, 100)
>>> axs[0].plot(x, P(x), 'r:', x, f(x), 'k--', xi, f(xi), 'xk')
>>> axs[1].plot(x, P.derivative(x), 'r:', x, f_d1(x), 'k--', xi, f_d1(xi), 'xk')
>>> axs[2].plot(x, P.derivative(x, 2), 'r:', x, f_d2(x), 'k--', xi, f_d2(xi), 'xk')
>>> axs[3].plot(x, P.derivative(x, 3), 'r:', x, f_d3(x), 'k--', xi, f_d3(xi), 'xk')
>>> axs[4].plot(x, P.derivative(x, 4), 'r:', x, f_d4(x), 'k--', xi, f_d4(xi), 'xk')
>>> axs[0].set_xlim(0, np.pi)
>>> axs[4].set_xlabel(r"$x$")
>>> axs[4].set_xticks([i * np.pi / 4 for i in range(5)],
... ["0", r"$\frac{\pi}{4}$", r"$\frac{\pi}{2}$", r"$\frac{3\pi}{4}$", r"$\pi$"])
>>> axs[0].set_ylabel("$f(x)$")
>>> axs[1].set_ylabel("$f'(x)$")
>>> axs[2].set_ylabel("$f''(x)$")
>>> axs[3].set_ylabel("$f^{(3)}(x)$")
>>> axs[4].set_ylabel("$f^{(4)}(x)$")
>>> labels = ['Interpolation nodes', 'True function $f$', 'Barycentric interpolation']
>>> axs[0].legend(axs[0].get_lines()[::-1], labels, bbox_to_anchor=(0., 1.02, 1., .102),
... loc='lower left', ncols=3, mode="expand", borderaxespad=0., frameon=False)
>>> plt.show()
属性:
dtype
方法
__call__(x) |
在点 x 处评估插值多项式 |
|---|---|
add_xi(xi[, yi]) |
将更多 x 值添加到待插值的集合中 |
derivative(x[, der]) |
在点 x 处评估多项式的单个导数 |
derivatives(x[, der]) |
在点 x 处评估多项式的多个导数 |
set_yi(yi[, axis]) |
更新待插值的 y 值 |
scipy.interpolate.KroghInterpolator
class scipy.interpolate.KroghInterpolator(xi, yi, axis=0)
一组点的插值多项式。
该多项式通过所有配对的(xi, yi)。还可以指定每个点xi处的多个导数；通过重复值xi并按顺序指定导数值yi来完成。
允许评估多项式及其所有导数。出于数值稳定性的原因，此函数不计算多项式的系数，但可以通过评估所有导数来获得它们。
参数：
xi类数组，形状（npoints，）
已知的 x 坐标。必须按升序排列。
yi类数组，形状（…，npoints，…）
已知的 y 坐标。当 xi 连续出现两次或更多时，对应的 yi 表示导数值。沿插值轴的yi的长度必须等于xi的长度。使用axis参数选择正确的轴。
axis整型，可选
在yi数组中对应于 x 坐标值的轴。默认为axis=0。
注意事项
请注意，这里实现的算法不一定是已知的最稳定的。此外，即使在精确计算的世界中，除非选择的 x 坐标非常谨慎 - Chebyshev 零点（例如，cos(i*pi/n)）是一个很好的选择 - 多项式插值本身也是一个非常病态的过程，因为 Runge 现象。一般来说，即使选择了良好的 x 值，在本代码中，大于约 30 的度数会导致数值不稳定性问题。
基于[1]。
参考资料
[1]
Krogh，《多项式插值和数值微分的高效算法》，1970 年。
示例
要生成一个在 0 和 1 处为零且在 0 处导数为 2 的多项式，请调用
>>> from scipy.interpolate import KroghInterpolator
>>> KroghInterpolator([0,0,1],[0,2,0])
这构造了二次多项式(2x²-2x)。在xi数组中通过重复的零指示导数条件；对应的 yi 值为 0，函数值为 2，导数值为 2。
举个例子，对于给定的xi、yi和每个点的导数ypi，可以构建适当的数组如下：
>>> import numpy as np
>>> rng = np.random.default_rng()
>>> xi = np.linspace(0, 1, 5)
>>> yi, ypi = rng.random((2, 5))
>>> xi_k, yi_k = np.repeat(xi, 2), np.ravel(np.dstack((yi,ypi)))
>>> KroghInterpolator(xi_k, yi_k)
要生成一个向量值多项式，请为yi提供一个更高维度的数组：
>>> KroghInterpolator([0,1],[[2,3],[4,5]])
这构造了一个线性多项式，在 0 处给出(2,3)，在 1 处给出(4,5)。
属性：
dtype
方法
__call__(x) |
评估插值 |
|---|---|
derivative(x[, der]) |
在点 x 处评估单个多项式导数。 |
derivatives(x[, der]) |
在点 x 处评估多个多项式导数。 |
scipy.interpolate.barycentric_interpolate
scipy.interpolate.barycentric_interpolate(xi, yi, x, axis=0, *, der=0)
多项式插值的便捷函数。
构造一个通过给定点集的多项式，然后评估多项式。由于数值稳定性的原因，此函数不计算多项式的系数。
此函数使用“重心插值”方法，将问题视为有理函数插值的特殊情况。这种算法在数值上非常稳定，但即使在精确计算的世界中，除非非常谨慎地选择x坐标（例如，切比雪夫零点（例如，cos(i*pi/n)）是一个很好的选择），多项式插值本身也是一个由于 Runge 现象而非常病态的过程。
参数：
xiarray_like
多项式应通过的点的 x 坐标的 1-D 数组
yiarray_like
多项式应通过的点的 y 坐标。
x标量 或 array_like
评估插值函数的点或点。
derint 或 列表 或 None, 可选
要评估的导数数量，或者对所有可能非零导数评估（即与点数相等的数量），或者要评估的导数列表。这个数字包括函数值作为“0th”导数。
axisint, 可选
与yi数组中的轴相对应的 x 坐标值。
返回：
y标量 或 array_like
插值值。形状由用x替换原始数组中的插值轴决定。
另请参阅
BarycentricInterpolator
重心插值器
注解
插值权重的构造是一个相对较慢的过程。如果您希望多次使用相同的 xi 调用此函数（但可能会变化 yi 或 x），您应该使用类BarycentricInterpolator。这是此函数在内部使用的内容。
示例
我们可以使用重心插值法对 2D 观察数据进行插值：
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.interpolate import barycentric_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 = barycentric_interpolate(x_observed, y_observed, x)
>>> plt.plot(x_observed, y_observed, "o", label="observation")
>>> plt.plot(x, y, label="barycentric interpolation")
>>> plt.legend()
>>> plt.show()
scipy.interpolate.krogh_interpolate
scipy.interpolate.krogh_interpolate(xi, yi, x, der=0, axis=0)
用于多项式插值的便捷函数。
参见 KroghInterpolator 了解更多细节。
参数：
xiarray_like
插值点（已知 x 坐标）。
yiarray_like
已知的 y 坐标，形状为 (xi.size, R)。如果 R=1，则解释为长度为 R 的向量或标量。
xarray_like
要评估导数的点或点。
derint 或 列表 或 None，可选
要评估的导数数量，或者对所有可能非零导数（即与点数相等的数字）进行评估，或者要评估的导数列表。该数字包括函数值作为第 '0' 导数。
axisint，可选
yi 数组中对应于 x 坐标值的轴。
返回：
dndarray
如果插值器的值为 R-D，则返回的数组将为 N by R 的导数数量。如果 x 是标量，则将去掉中间维度；如果 yi 是标量，则将去掉最后维度。
参见
KroghInterpolator
Krogh 插值器
注意
插值多项式的构造是一个相对昂贵的过程。如果需要重复评估它，请考虑使用类 KroghInterpolator（这正是该函数使用的内容）。
示例
我们可以使用 Krogh 插值来插值 2D 观测数据：
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.interpolate import krogh_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 = krogh_interpolate(x_observed, y_observed, x)
>>> plt.plot(x_observed, y_observed, "o", label="observation")
>>> plt.plot(x, y, label="krogh interpolation")
>>> plt.legend()
>>> plt.show()
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，则确定是否基于第一个和最后一个区间来对超出边界的点进行外推，或返回 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, 可选
如果是布尔值，则决定基于第一个和最后一个间隔来拟合超出边界的点，或者返回 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](https://docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.interpn.html#scipy.interpolate.interpn "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'。
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]) |
构造分段多项式，无需进行检查。 |
scipy.interpolate.NdBSpline
class scipy.interpolate.NdBSpline(t, c, k, *, extrapolate=None)
张量积样条对象。
在点xp = (x1, x2, ..., xN)处的值被评估为每个N维度中的一维 B 样条的乘积的线性组合：
c[i1, i2, ..., iN] * B(x1; i1, t1) * B(x2; i2, t2) * ... * B(xN; iN, tN)
这里B(x; i, t)是由结节点向量t定义的第i个 B 样条在x处的评估。
参数：
t一维 ndarrays 的元组
在每个方向上的结节点向量，len(t[i]) == n[i] + k + 1
cndarray，形状为(n1, n2, …, nN, …)
B 样条系数
k整数或长度为 d 的整数元组
样条度数。单个整数被解释为所有维度具有此度数。
extrapolate布尔值，可选
是否对超出范围的输入进行外推，或返回nan。默认是外推。
另请参见
一个一维 B 样条对象
一个 N 维分段张量积多项式
属性：
tndarray 的元组
结节点向量。
cndarray
张量产品样条的系数。
k整数的元组
每个维度的度数。
extrapolate布尔值，可选
是否对超出范围的输入进行外推或返回 nan。默认为真。
方法
__call__(xi, *[, nu, extrapolate]) |
在xi处评估张量积 B 样条。 |
|---|
scipy.interpolate.BSpline
class scipy.interpolate.BSpline(t, c, k, extrapolate=True, axis=0)
B 样条基上的单变量样条。
[S(x) = \sum_{j=0}^{n-1} c_j B_{j, k; t}(x)]
其中(B_{j, k; t})是度为k和结点t的 B 样条基函数。
参数：
tndarray，形状（n+k+1，）
结点
cndarray，形状（>=n，…）
样条系数
kint
B 样条度
外推bool 或'周期性'，可选
是否在基本区间t[k] .. t[n]之外外推，或返回 nans。如果为 True，则在基本区间上激活 B 样条函数的第一个和最后一个多项式片段。如果是'周期性'，则使用周期性外推。默认值为 True。
轴int，可选
插值轴。默认为零。
注意事项
B 样条基函数通过以下方式定义
[ \begin{align}\begin{aligned}B_{i, 0}(x) = 1, \textrm{if \(t_i \le x < t_{i+1}\), otherwise \(0\),}\B_{i, k}(x) = \frac{x - t_i}{t_{i+k} - t_i} B_{i, k-1}(x) + \frac{t_{i+k+1} - x}{t_{i+k+1} - t_{i+1}} B_{i+1, k-1}(x)\end{aligned}\end{align} ]
实现细节
-
对于度为k的样条，至少需要k+1个系数，因此n >= k+1。额外的系数c[j]（其中j > n）将被忽略。
-
度为k的 B 样条基函数在基本区间t[k] <= x <= t[n]上形成一个单位分区。
参考文献
[1]
Tom Lyche 和 Knut Morken，样条方法，www.uio.no/studier/emner/matnat/ifi/INF-MAT5340/v05/undervisningsmateriale/
[2]
Carl de Boor，样条的实用指南，Springer，2001。
示例
将 B 样条的递归定义翻译成 Python 代码，我们有：
>>> def B(x, k, i, t):
... if k == 0:
... return 1.0 if t[i] <= x < t[i+1] else 0.0
... if t[i+k] == t[i]:
... c1 = 0.0
... else:
... c1 = (x - t[i])/(t[i+k] - t[i]) * B(x, k-1, i, t)
... if t[i+k+1] == t[i+1]:
... c2 = 0.0
... else:
... c2 = (t[i+k+1] - x)/(t[i+k+1] - t[i+1]) * B(x, k-1, i+1, t)
... return c1 + c2
>>> def bspline(x, t, c, k):
... n = len(t) - k - 1
... assert (n >= k+1) and (len(c) >= n)
... return sum(c[i] * B(x, k, i, t) for i in range(n))
请注意，这是评估 B 样条的一种低效（虽然直接）的方法 —— 这个样条类以一种等效但更高效的方式执行。
在基本区间2 <= x <= 4上构建二次样条函数，并与评估样条的朴素方式进行比较：
>>> from scipy.interpolate import BSpline
>>> k = 2
>>> t = [0, 1, 2, 3, 4, 5, 6]
>>> c = [-1, 2, 0, -1]
>>> spl = BSpline(t, c, k)
>>> spl(2.5)
array(1.375)
>>> bspline(2.5, t, c, k)
1.375
请注意，在基本区间之外的结果会有所不同。这是因为BSpline会在基本区间上激活的 B 样条函数的第一个和最后一个多项式片段进行外推。
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> fig, ax = plt.subplots()
>>> xx = np.linspace(1.5, 4.5, 50)
>>> ax.plot(xx, [bspline(x, t, c ,k) for x in xx], 'r-', lw=3, label='naive')
>>> ax.plot(xx, spl(xx), 'b-', lw=4, alpha=0.7, label='BSpline')
>>> ax.grid(True)
>>> ax.legend(loc='best')
>>> plt.show()
属性：
tndarray
结点向量
cndarray
样条系数
kint
样条度
外推bool
如果为 True，则在基本区间上激活的 B 样条函数的第一个和最后一个多项式片段进行外推。
轴int
插值轴。
tck元组
等同于(self.t, self.c, self.k)（只读）。
方法
__call__(x[, nu, extrapolate]) |
求解样条函数。 |
|---|---|
basis_element(t[, extrapolate]) |
返回 B 样条基底元素 `B(x |
derivative([nu]) |
返回表示导数的 B 样条。 |
antiderivative([nu]) |
返回表示原函数的 B 样条。 |
integrate(a, b[, extrapolate]) |
计算样条的定积分。 |
construct_fast(t, c, k[, extrapolate, axis]) |
构造一个不进行检查的样条。 |
design_matrix(x, t, k[, extrapolate]) |
返回一个以 CSR 格式稀疏数组表示的设计矩阵。 |
from_power_basis(pp[, bc_type]) |
从幂基底中的分段多项式构造 B 样条基底的多项式。 |
scipy.interpolate.make_interp_spline
scipy.interpolate.make_interp_spline(x, y, k=3, t=None, bc_type=None, axis=0, check_finite=True)
计算（系数的）插值 B 样条。
参数：
x array_like，形状为 (n,)
横坐标。
y array_like，形状为 (n, …)
纵坐标。
k int，可选
B 样条度数。默认为三次，k = 3。
t array_like，形状为 (nt + k + 1,)，可选。
节点。结点数量需要与数据点数量和边界导数数量一致。具体来说，nt - n 必须等于 len(deriv_l) + len(deriv_r)。
bc_type 2-元组或 None
边界条件。默认为 None，这意味着自动选择边界条件。否则，必须是一个长度为二的元组，第一个元素（deriv_l）设置在 x[0] 处的边界条件，第二个元素（deriv_r）设置在 x[-1] 处的边界条件。每个元素必须是一个给定插值区间边缘上指定阶数导数的可迭代对 (order, value)。另外，还可以识别以下字符串别名：
-
"clamped"：两端的一阶导数为零。这是等效于
bc_type=([(1, 0.0)], [(1, 0.0)])。 -
"natural"：两端的二阶导数为零。这等效于bc_type=([(2, 0.0)], [(2, 0.0)])。 -
"not-a-knot"（默认）：第一和第二段是同一个多项式。这等效于bc_type=None。 -
"periodic"：值和前k-1阶导数在两端是等价的。
axis int，可选
插值轴。默认为 0。
check_finite bool，可选
是否检查输入数组只包含有限数。禁用可能会带来性能提升，但如果输入确实包含无穷大或 NaN，则可能会导致问题（崩溃、非终止）。默认为 True。
返回：
b 一个度为 k 且带结点 t 的 BSpline 对象。
另请参阅
表示 B 样条对象的基类
多项式基底上的三次样条
一个类似的用于样条拟合的工厂函数
FITPACK 样条拟合例程的一个封装
FITPACK 样条拟合例程的一个封装
示例
在切比雪夫节点上使用三次插值：
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> def cheb_nodes(N):
... jj = 2.*np.arange(N) + 1
... x = np.cos(np.pi * jj / 2 / N)[::-1]
... return x
>>> x = cheb_nodes(20)
>>> y = np.sqrt(1 - x**2)
>>> from scipy.interpolate import BSpline, make_interp_spline
>>> b = make_interp_spline(x, y)
>>> np.allclose(b(x), y)
True
注意，默认情况下是使用具有非结点边界条件的三次样条插值。
>>> b.k
3
这里我们使用了‘自然’样条插值，边缘处的二阶导数为零。
>>> l, r = [(2, 0.0)], [(2, 0.0)]
>>> b_n = make_interp_spline(x, y, bc_type=(l, r)) # or, bc_type="natural"
>>> np.allclose(b_n(x), y)
True
>>> x0, x1 = x[0], x[-1]
>>> np.allclose([b_n(x0, 2), b_n(x1, 2)], [0, 0])
True
同样支持参数曲线的插值。举例来说，我们计算极坐标下蜗牛曲线的离散化。
>>> phi = np.linspace(0, 2.*np.pi, 40)
>>> r = 0.3 + np.cos(phi)
>>> x, y = r*np.cos(phi), r*np.sin(phi) # convert to Cartesian coordinates
构建一个插值曲线，通过角度进行参数化。
>>> spl = make_interp_spline(phi, np.c_[x, y])
在更细的网格上评估插值器（注意我们转置结果以将其解压为 x 和 y 数组的一对）。
>>> phi_new = np.linspace(0, 2.*np.pi, 100)
>>> x_new, y_new = spl(phi_new).T
绘制结果。
>>> plt.plot(x, y, 'o')
>>> plt.plot(x_new, y_new, '-')
>>> plt.show()
构建一个具有 2 维 y 的 B 样条曲线。
>>> x = np.linspace(0, 2*np.pi, 10)
>>> y = np.array([np.sin(x), np.cos(x)])
由于端点的 y 坐标相等，满足周期性条件。
>>> ax = plt.axes(projection='3d')
>>> xx = np.linspace(0, 2*np.pi, 100)
>>> bspl = make_interp_spline(x, y, k=5, bc_type='periodic', axis=1)
>>> ax.plot3D(xx, *bspl(xx))
>>> ax.scatter3D(x, *y, color='red')
>>> plt.show()
scipy.interpolate.make_lsq_spline
scipy.interpolate.make_lsq_spline(x, y, t, k=3, w=None, axis=0, check_finite=True)
计算（系数的）基于 LSQ（最小二乘）拟合的 B 样条。
结果是线性组合
[S(x) = \sum_j c_j B_j(x; t)]
B 样条基函数元素(B_j(x; t))的轴，默认为零。
[\sum_{j} \left( w_j \times (S(x_j) - y_j) \right)²]
参数：
xarray_like，形状为（m，）
横坐标。
yarray_like，形状为（m，…）
纵坐标。
tarray_like，形状为（n + k + 1，）。
结节。结节和数据点必须满足 Schoenberg-Whitney 条件。
kint，可选
B 样条度。默认为三次，k = 3。
warray_like，形状为（m，），可选
用于样条拟合的权重。必须是正数。如果为None，则所有权重相等。默认为None。
axisint，可选
插值轴。默认为零。
check_finitebool，可选
是否检查输入数组仅包含有限数。禁用可能会提高性能，但如果输入包含无限或 NaN，则可能会导致问题（崩溃，非终止）。默认为 True。
返回：
b一个 B 样条对象，度为k，结节为t。
另见
表示 B 样条对象的基类
一个类似的插值样条的工厂函数
一个基于 FITPACK 的样条拟合例程
一个基于 FITPACK 的拟合例程
注释
数据点的数量必须大于样条度k。
结节t必须满足 Schoenberg-Whitney 条件，即必须存在数据点x[j]的子集使得t[j] < x[j] < t[j+k+1]，对于j=0, 1,...,n-k-2。
示例
生成一些噪声数据：
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
>>> x = np.linspace(-3, 3, 50)
>>> y = np.exp(-x**2) + 0.1 * rng.standard_normal(50)
现在使用预定义的内部结节拟合*滑立方样条。这里我们通过添加边界结节使结节向量（k+1）-正则化：
>>> from scipy.interpolate import make_lsq_spline, BSpline
>>> t = [-1, 0, 1]
>>> k = 3
>>> t = np.r_[(x[0],)*(k+1),
... t,
... (x[-1],)*(k+1)]
>>> spl = make_lsq_spline(x, y, t, k)
为了比较，我们还构造了相同数据集的插值样条：
>>> from scipy.interpolate import make_interp_spline
>>> spl_i = make_interp_spline(x, y)
绘制两者：
>>> xs = np.linspace(-3, 3, 100)
>>> plt.plot(x, y, 'ro', ms=5)
>>> plt.plot(xs, spl(xs), 'g-', lw=3, label='LSQ spline')
>>> plt.plot(xs, spl_i(xs), 'b-', lw=3, alpha=0.7, label='interp spline')
>>> plt.legend(loc='best')
>>> plt.show()
NaN 处理：如果输入数组包含nan值，则结果是无用的，因为底层样条拟合程序无法处理nan。一种解决方法是对非数字数据点使用零权重：
>>> y[8] = np.nan
>>> w = np.isnan(y)
>>> y[w] = 0.
>>> tck = make_lsq_spline(x, y, t, w=~w)
注意需要用数值值替换nan（只要对应的权重为零，具体值并不重要。）
scipy.interpolate.make_smoothing_spline
scipy.interpolate.make_smoothing_spline(x, y, w=None, lam=None)
使用 lam 控制曲线光滑度和其接*数据的*滑立方样条函数的（系数）。如果 lam 是 None，则使用 GCV 标准 [1] 来找到它。
*滑样条作为解决带有给定参数 lam 的正则化加权线性回归问题的解：
[\sum\limits_{i=1}^n w_i\lvert y_i - f(x_i) \rvert² + \lambda\int\limits_{x_1}^{x_n} (f^{(2)}(u))² d u]
其中 (f) 是一个样条函数，(w) 是一个权重向量，(\lambda) 是一个正则化参数。
如果 lam 是 None，则使用 GCV 标准来找到最优的正则化参数，否则使用给定的参数解决带有给定参数的正则化加权线性回归问题。该参数控制如下的权衡：参数越大，函数越*滑。
参数：
x 数组，形状 (n,)
横坐标。n 至少为 5。
y 数组，形状 (n,)
纵坐标。n 至少为 5。
w 数组，形状 (n,)，可选
权重向量。默认为np.ones_like(x)。
lam 浮点数，((\lambda \geq 0))，可选
正则化参数。如果 lam 是 None，则根据 GCV 标准来确定。默认为 None。
返回：
func 一个 BSpline 对象。
一个可调用的 B 样条基函数表示为使用 GCV 标准 [1] 的*滑样条的解，在 lam 是 None 的情况下，使用给定的参数 lam。
注意
该算法是 Woltring 在 FORTRAN 中引入的算法的重新实现。由于许可问题，原始版本不能在 SciPy 源代码中使用。重新实现的详细信息在这里讨论（仅限俄语）[4]。
如果权重向量 w 是 None，则假设所有点在权重上是相等的，并且权重向量是全 1 向量。
注意，在加权残差*方和中，权重不是*方的：(\sum\limits_{i=1}^n w_i\lvert y_i - f(x_i) \rvert²) 而在 splrep 中，总和是由*方权重构建的。
在初始问题病态的情况下（例如，乘积 (X^T W X) 其中 (X) 是设计矩阵不是正定矩阵时），会引发 ValueError。
参考文献
[1]
G. Wahba，“Estimating the smoothing parameter” in Spline models for observational data，Philadelphia, Pennsylvania：Society for Industrial and Applied Mathematics，1990，pp. 45-65。DOI:10.1137/1.9781611970128
[2]
H. J. Woltring, 广义交叉验证样条*滑和微分的 Fortran 包, 《工程软件进展》, 第 8 卷, 第 2 期, 1986 年, pp. 104-113. DOI:10.1016/0141-1195(86)90098-7
[3]
T. Hastie, J. Friedman, 和 R. Tisbshirani, "*滑样条" in 《统计学习的要素: 数据挖掘、推断和预测》, 纽约: Springer, 2017, pp. 241-249. DOI:10.1007/978-0-387-84858-7
[4]
E. Zemlyanoy, "广义交叉验证*滑样条", 学士学位论文, 2022 年. www.hse.ru/ba/am/students/diplomas/620910604 (俄语)
示例
生成一些噪声数据
>>> import numpy as np
>>> np.random.seed(1234)
>>> n = 200
>>> def func(x):
... return x**3 + x**2 * np.sin(4 * x)
>>> x = np.sort(np.random.random_sample(n) * 4 - 2)
>>> y = func(x) + np.random.normal(scale=1.5, size=n)
制作*滑样条函数
>>> from scipy.interpolate import make_smoothing_spline
>>> spl = make_smoothing_spline(x, y)
绘制两者
>>> import matplotlib.pyplot as plt
>>> grid = np.linspace(x[0], x[-1], 400)
>>> plt.plot(grid, spl(grid), label='Spline')
>>> plt.plot(grid, func(grid), label='Original function')
>>> plt.scatter(x, y, marker='.')
>>> plt.legend(loc='best')
>>> plt.show()
scipy.interpolate.splrep
scipy.interpolate.splrep(x, y, w=None, xb=None, xe=None, k=3, task=0, s=None, t=None, full_output=0, per=0, quiet=1)
查找一维曲线的 B 样条表示。
给定数据点集合(x[i], y[i])，确定区间xb <= x <= xe上程度为 k 的*滑样条*似。
参数：
x, yarray_like
定义曲线 y = f(x)的数据点。
warray_like，可选
与 x 和 y 长度相同的严格正数的权重的秩-1 数组。权重用于计算加权最小二乘样条拟合。如果 y 值的误差由向量 d 给出的标准偏差，则 w 应为 1/d。默认值为 ones(len(x))。
xb, xefloat，可选
拟合的区间。如果为 None，默认为 x[0]和 x[-1]。
kint，可选
拟合的样条拟合程度。建议使用三次样条。特别是在小的 s 值下，应避免使用偶数 k 值。1 <= k <= 5
task，可选
如果 task==0，则为给定的*滑因子 s 找到 t 和 c。
如果 task==1，为另一个*滑因子 s 的值找到 t 和 c。必须之前有过 task=0 或 task=1 的调用，使用相同的数据集（t 将被存储并在内部使用）。
如果 task=-1，则为给定的节点 t 找到加权最小二乘样条。这些应为内部节点，因为端点上的节点将自动添加。
sfloat，可选
*滑条件。通过满足条件来确定*滑插值 g(x)的条件：sum((w * (y - g))**2,axis=0) <= s。用户可以使用 s 来控制拟合的贴*度和*滑度之间的权衡。较大的 s 值意味着更*滑，而较小的 s 值则表示较少*滑。建议的 s 值取决于权重 w。如果权重表示 y 的标准偏差的倒数，则好的 s 值应在范围(m-sqrt(2m), m+sqrt(2m))内找到，其中 m 是 x、y 和 w 中的数据点数。默认值：如果提供了权重，则 s=m-sqrt(2*m)，如果未提供权重，则 s=0.0（插值）。
tarray_like，可选
task=-1 所需的节点。如果给定，则自动将 task 设置为-1。
full_outputbool，可选
如果非零，则返回可选输出。
perbool，可选
如果非零，则数据点被认为是周期性的，周期为 x[m-1] - x[0]，并返回*滑的周期性样条*似。y[m-1]和 w[m-1]的值不会被使用。
quietbool，可选
非零以抑制消息。
返回：
tcktuple
包含节点向量、B 样条系数和样条度数的元组(t,c,k)。
fparray，可选
样条*似的加权残差*方和。
ierint，可选
一个关于 splrep 成功的整数标志。如果 ier<=0 表示成功。如果 ier 在 [1,2,3] 范围内表示发生了错误但没有被引发。否则将引发错误。
msgstr，可选
一个与整数标志 ier 对应的消息。
另见
UnivariateSpline，BivariateSpline
splprep，splev，sproot，spalde，splint
注意
查看 splev 以评估样条及其导数。使用来自 FITPACK 的 FORTRAN 程序 curfit。
用户负责确保 x 的值是唯一的。否则，splrep 将不会返回合理的结果。
如果提供的，节点 t 必须满足 Schoenberg-Whitney 条件，即必须存在数据点 x[j] 的子集，使得 t[j] < x[j] < t[j+k+1]，对于 j=0, 1,...,n-k-2。
该例程对系数数组 c 进行零填充，使其与节点数组 t 的长度相同（评估例程 splev 和 BSpline 将忽略末尾的 k + 1 个系数）。这与 splprep 相反，后者不对系数进行零填充。
参考
[1]
P. Dierckx，《使用样条函数*滑、微分和积分实验数据的算法》，J.Comp.Appl.Maths 1 (1975) 165-184。
[2]
P. Dierckx，《使用样条函数在矩形网格上*滑数据的快速算法》，SIAM J.Numer.Anal. 19 (1982) 1286-1304。
[3]
P. Dierckx，《一种改进的样条函数曲线拟合算法》，报告 tw54，计算机科学系，鲁汶大学，1981 年。
[4]
P. Dierckx，《样条曲线和曲面拟合》，《数值分析专著》，牛津大学出版社，1993 年。
示例
你可以用 B-样条曲线对 1-D 点进行插值。更多示例见教程中。
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.interpolate import splev, splrep
>>> x = np.linspace(0, 10, 10)
>>> y = np.sin(x)
>>> spl = splrep(x, y)
>>> x2 = np.linspace(0, 10, 200)
>>> y2 = splev(x2, spl)
>>> plt.plot(x, y, 'o', x2, y2)
>>> plt.show()
scipy.interpolate.splprep
scipy.interpolate.splprep(x, w=None, u=None, ub=None, ue=None, k=3, task=0, s=None, t=None, full_output=0, nest=None, per=0, quiet=1)
找到 N 维曲线的 B 样条表示。
给定 N 个秩-1 数组 x 列表，它们表示参数化为 u 的 N 维空间中的曲线，找到*滑的*似样条曲线 g(u)。使用 FITPACK 的 FORTRAN 程序包中的 parcur。
参数：
xarray_like
代表曲线的样本向量数组的列表。
warray_like，可选
严格正的秩-1 权重数组，长度与 x[0] 相同。这些权重用于计算加权最小二乘样条拟合。如果 x 值的误差标准差由向量 d 给出，则 w 应为 1/d。默认为 ones(len(x[0]))。
uarray_like，可选
参数值的数组。如果未给出，则这些值会自动计算为 M = len(x[0])，其中
v[0] = 0
v[i] = v[i-1] + distance(x[i], x[i-1])
u[i] = v[i] / v[M-1]
ub, ueint，可选
参数区间的端点。默认为 u[0] 和 u[-1]。
kint，可选
样条的阶数。建议使用三次样条。尤其是在小的 s 值下，应避免使用偶数的 k。1 <= k <= 5，默认值为 3。
taskint，可选
如果 task0（默认），找到给定*滑因子 s 的 t 和 c。如果 task1，则找到另一个*滑因子 s 的 t 和 c。必须先前使用相同数据集和 task=0 或 task=1 调用过。如果 task==-1，则为给定节点 t 找到加权最小二乘样条。
sfloat，可选
*滑条件。*滑度通过满足条件确定：sum((w * (y - g))**2,axis=0) <= s，其中 g(x) 是（x,y）的*滑插值。用户可以使用 s 控制拟合的紧密程度和*滑程度之间的权衡。较大的 s 表示更多*滑，而较小的 s 表示较少*滑。推荐的 s 值取决于权重 w。如果权重代表 y 的标准偏差的倒数，则好的 s 值应在范围 (m-sqrt(2*m),m+sqrt(2*m)) 内找到，其中 m 是 x、y 和 w 中的数据点数。
tarray，可选
所需的节点为 task=-1。至少需要 2*k+2 个节点。
full_outputint，可选
如果非零，则返回可选输出。
nestint，可选
样条的总节点数的过估计，以帮助确定存储空间。默认为 nest=m/2。nest 始终足够大，nest=m+k+1。
perint，可选
如果非零，则将数据点视为周期性，周期为 x[m-1] - x[0]，并返回*滑的周期样条*似。不使用 y[m-1] 和 w[m-1] 的值。
quietint，可选
非零以禁止消息输出。
返回：
tcktuple
包含结节向量、B 样条系数和样条度的元组(t,c,k)。
uarray
参数值数组。
fpfloat
样条逼*的加权残差*方和。
ierint
一个关于 splrep 成功的整数标志。如果 ier<=0 表示成功。如果 ier 在[1,2,3]范围内，表示发生错误但未引发异常。否则会引发错误。
msgstr
与整数标志 ier 对应的消息。
另见
splrep, splev, sproot, spalde, splint
bisplrep, bisplev
UnivariateSpline, BivariateSpline
BSpline
make_interp_spline
注释
查看splev以评估样条和其导数。维度数 N 必须小于 11。
数组c中的系数数为k+1，比节点数len(t)少。这与splrep相反，后者将系数数组用零填充至与节点数组相同的长度。这些额外的系数在评估过程中被忽略，即splev和BSpline。
参考文献
[1]
P. Dierckx，《使用周期性和参数样条*滑数据的算法，计算机图形学与图像处理》，20 (1982) 171-184。
[2]
P. Dierckx，《使用周期性和参数样条*滑数据的算法》，报告 tw55，计算机科学系，K.U.Leuven，1981 年。
[3]
P. Dierckx，《使用样条进行曲线和曲面拟合》，数值分析专著，牛津大学出版社，1993 年。
示例
在极坐标中生成蜗牛线曲线的离散化：
>>> import numpy as np
>>> phi = np.linspace(0, 2.*np.pi, 40)
>>> r = 0.5 + np.cos(phi) # polar coords
>>> x, y = r * np.cos(phi), r * np.sin(phi) # convert to cartesian
然后进行插值：
>>> from scipy.interpolate import splprep, splev
>>> tck, u = splprep([x, y], s=0)
>>> new_points = splev(u, tck)
注意到 (i) 我们通过使用 s=0 强制插值，(ii) 参数化 u 是自动生成的。现在绘制结果：
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots()
>>> ax.plot(x, y, 'ro')
>>> ax.plot(new_points[0], new_points[1], 'r-')
>>> plt.show()
scipy.interpolate.splev
scipy.interpolate.splev(x, tck, der=0, ext=0)
评估 B 样条或其导数。
给定 B 样条表示的节点和系数，评估*滑多项式及其导数的值。这是对 FITPACK 的 FORTRAN 例程 splev 和 splder 的包装。
参数：
x：array_like
要返回*滑样条或其导数的值的点的数组。如果tck是从splprep返回的，则应提供参数值u。
tck：3 元组或 BSpline 对象
如果是元组，则应该是由splrep或splprep返回的长度为 3 的序列，包含节点、系数和样条的阶数。（另见注释。）
der：int，可选
要计算的样条的导数的顺序（必须小于或等于样条的阶数 k）。
ext：int，可选
控制对由节点序列定义的间隔之外的x元素返回的值。
-
如果 ext=0，返回外推值。
-
如果 ext=1，返回 0
-
如果 ext=2，引发 ValueError
-
如果 ext=3，返回边界值。
默认值为 0。
返回：
y：ndarray 或 ndarrays 列表
一个值数组，表示在x点处评估的样条函数。如果tck是从splprep返回的，则这是表示 N 维空间中曲线的数组列表。
另见
splprep, splrep, sproot, spalde, splint
注释
不推荐直接操作tck元组。在新代码中，建议优先使用BSpline对象。
参考
[1]
C. de Boor，“关于计算 B 样条”，J.*似理论，6，p.50-62，1972 年。
[2]
M. G. Cox，《B 样条的数值评估》，《数学应用学会杂志》，10 期，页码 134-149，1972 年。
[3]
P. Dierckx，《样条曲线和曲面拟合》，《数值分析专著》，牛津大学出版社，1993 年。
例子
示例在 tutorial 中给出。
scipy.interpolate.splint
scipy.interpolate.splint(a, b, tck, full_output=0)
计算 B 样条在两个给定点之间的定积分。
参数：
a, bfloat
积分区间的端点。
tck元组或 BSpline 实例
如果是元组，则应为长度为 3 的序列，其中包含节点向量、B 样条系数和样条的次数（参见splev）。
full_outputint, 可选
非零以返回可选输出。
返回值：
integralfloat
得到的积分。
wrkndarray
包含在节点集上定义的归一化 B 样条的积分的数组。（仅在full_output非零时返回）
另请参阅
splprep, splrep, sproot, spalde, splev
bisplrep, bisplev
BSpline
注意
splint 默默地假设数据区间（a, b）之外的样条函数为零。
不建议直接操作 tck 元组。在新代码中，优先使用BSpline对象。
参考文献
[1]
P.W. Gaffney, “B 样条函数的不定积分计算”, J. Inst. Maths Applics, 17, p.37-41, 1976.
[2]
P. Dierckx, “曲线和曲面拟合的样条方法”, 数值分析专著, 牛津大学出版社, 1993.
示例
示例在教程中给出。
scipy.interpolate.sproot
scipy.interpolate.sproot(tck, mest=10)
查找三次 B-样条曲线的根。
给定一个至少包含 8 个结点和系数的三次 B-样条曲线，返回曲线的根。
参数：
tck 元组或 BSpline 对象
如果是一个元组，则应为长度为 3 的序列，其中包含结点向量、B-样条系数和样条的阶数。结点数必须大于等于 8，阶数必须为 3。结点必须是单调递增的序列。
mest 整数，可选的
零点的估计数量（默认为 10）。
返回：
zeros 数组
给出样条曲线的根的数组。
另请参阅
splprep，splrep，splint，spalde，splev
注意事项
直接操作 tck 元组不推荐。在新代码中，推荐使用 BSpline 对象。
参考文献
[1]
C. de Boor，《计算 B-样条曲线》，《逼*论杂志》，6，第 50-62 页，1972 年。
[2]
M. G. Cox，《B-样条曲线的数值评估》，《数学应用学会杂志》，10，第 134-149 页，1972 年。
[3]
P. Dierckx，《样条曲线与曲面拟合》，《数值分析专题》，牛津大学出版社，1993 年。
示例
对于某些数据，这种方法可能会错过一个根。当样条结点（FITPACK 自动放置）恰好与真实根重合时会发生这种情况。一个解决方法是转换为 PPoly，它使用不同的寻根算法。
例如，
>>> x = [1.96, 1.97, 1.98, 1.99, 2.00, 2.01, 2.02, 2.03, 2.04, 2.05]
>>> y = [-6.365470e-03, -4.790580e-03, -3.204320e-03, -1.607270e-03,
... 4.440892e-16, 1.616930e-03, 3.243000e-03, 4.877670e-03,
... 6.520430e-03, 8.170770e-03]
>>> from scipy.interpolate import splrep, sproot, PPoly
>>> tck = splrep(x, y, s=0)
>>> sproot(tck)
array([], dtype=float64)
将其转换为 PPoly 对象确实在 x=2 处找到了根：
>>> ppoly = PPoly.from_spline(tck)
>>> ppoly.roots(extrapolate=False)
array([2.])
更多示例请参见教程。
scipy.interpolate.spalde
scipy.interpolate.spalde(x, tck)
评估 B 样条的所有导数。
给定三次 B 样条的节点和系数，在点（或一组点）上计算所有直到 k 阶的导数。
参数：
xarray_like
一个点或一组点，在这些点上评估导数。注意对于每个x，必须满足 t(k) <= x <= t(n-k+1)。
tcktuple
元组 (t,c,k) 包含节点向量、B 样条系数和样条的阶数。
返回：
results
一个数组（或数组列表），每个点x包含所有直到 k 阶的导数。
参见
splprep, splrep, splint, sproot, splev, bisplrep, bisplev
UnivariateSpline, BivariateSpline
参考文献
[1]
de Boor C : 计算 B 样条，J. Approximation Theory 6 (1972) 50-62。
[2]
Cox M.G. : B 样条的数值评估，J. Inst. Maths applics 10 (1972) 134-149。
[3]
Dierckx P. : 用样条曲线和曲面拟合，牛津大学出版社，数值分析专著，1993 年。
scipy.interpolate.splder
scipy.interpolate.splder(tck, n=1)
计算给定样条导数的样条表示
参数：
tckBSpline 实例或元组 (t, c, k)
要计算其导数的样条
nint，可选
要评估的导数阶数。 默认值：1
返回：
BSpline 实例或元组
表示输入样条导数的阶数为 k2=k-n 的样条。 如果输入参数 tck 是元组，则返回元组，否则构造并返回 BSpline 对象。
另请参阅
注意
0.13.0 版新功能。
示例
这可用于查找曲线的极大值：
>>> from scipy.interpolate import splrep, splder, sproot
>>> import numpy as np
>>> x = np.linspace(0, 10, 70)
>>> y = np.sin(x)
>>> spl = splrep(x, y, k=4)
现在，对样条进行微分并找到导数的零点。 （注：sproot 仅适用于阶数为 3 的样条，因此我们拟合了一个阶数为 4 的样条）：
>>> dspl = splder(spl)
>>> sproot(dspl) / np.pi
array([ 0.50000001, 1.5 , 2.49999998])
这与 (\cos(x) = \sin'(x)) 的根 (\pi/2 + n\pi) 很符合。
scipy.interpolate.splantider
scipy.interpolate.splantider(tck, n=1)
计算给定样条函数的反导数（积分）的样条函数。
参数：
tckBSpline 实例或者 (t, c, k) 的元组
要计算其反导数的样条函数
nint, 可选
要评估的反导数的阶数。默认值：1
返回：
BSpline 实例或者 (t2, c2, k2) 的元组
表示输入样条函数的反导数的阶数为 k2=k+n 的样条函数。如果输入参数 tck 是一个元组，则返回一个元组；否则构建并返回一个 BSpline 对象。
另请参见
注释
splder 函数是这个函数的逆操作。即 splder(splantider(tck)) 与 tck 几乎相同，除了舍入误差。
自版本 0.13.0 起新增。
示例
>>> from scipy.interpolate import splrep, splder, splantider, splev
>>> import numpy as np
>>> x = np.linspace(0, np.pi/2, 70)
>>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2)
>>> spl = splrep(x, y)
导数是反导数的逆运算，尽管会累积一些浮点误差：
>>> splev(1.7, spl), splev(1.7, splder(splantider(spl)))
(array(2.1565429877197317), array(2.1565429877201865))
反导数可用于计算定积分：
>>> ispl = splantider(spl)
>>> splev(np.pi/2, ispl) - splev(0, ispl)
2.2572053588768486
这实际上是完整椭圆积分 (K(m) = \int_0^{\pi/2} [1 - m\sin² x]^{-1/2} dx) 的*似：
>>> from scipy.special import ellipk
>>> ellipk(0.8)
2.2572053268208538
scipy.interpolate.insert
Original text：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.insert.html#scipy.interpolate.insert
scipy.interpolate.insert(x, tck, m=1, per=0)
Insert knots into a B-spline.
Given the knots and coefficients of a B-spline representation, create a new B-spline with a knot inserted m times at point x. This is a wrapper around the FORTRAN routine insert of FITPACK.
Parameters:
x (u)array_like
A 1-D point at which to insert a new knot(s). If tck was returned from splprep, then the parameter values, u should be given.
tcka BSpline instance or a tuple
If tuple, then it is expected to be a tuple (t,c,k) containing the vector of knots, the B-spline coefficients, and the degree of the spline.
mint, optional
The number of times to insert the given knot (its multiplicity). Default is 1.
perint, optional
If non-zero, the input spline is considered periodic.
Returns:
BSpline instance or a tuple
A new B-spline with knots t, coefficients c, and degree k. t(k+1) <= x <= t(n-k), where k is the degree of the spline. In case of a periodic spline (per != 0) there must be either at least k interior knots t(j) satisfying t(k+1)<t(j)<=x or at least k interior knots t(j) satisfying x<=t(j)<t(n-k). A tuple is returned iff the input argument tck is a tuple, otherwise a BSpline object is constructed and returned.
Notes
Based on algorithms from [1] and [2].
Manipulating the tck-tuples directly is not recommended. In new code, prefer using the BSpline objects.
References
[1]
W. Boehm, “Inserting new knots into b-spline curves.”, Computer Aided Design, 12, p.199-201, 1980.
[2]
P. Dierckx, “Curve and surface fitting with splines, Monographs on Numerical Analysis”, Oxford University Press, 1993.
Examples
You can insert knots into a B-spline.
>>> from scipy.interpolate import splrep, insert
>>> import numpy as np
>>> x = np.linspace(0, 10, 5)
>>> y = np.sin(x)
>>> tck = splrep(x, y)
>>> tck[0]
array([ 0., 0., 0., 0., 5., 10., 10., 10., 10.])
A knot is inserted:
>>> tck_inserted = insert(3, tck)
>>> tck_inserted[0]
array([ 0., 0., 0., 0., 3., 5., 10., 10., 10., 10.])
Some knots are inserted:
>>> tck_inserted2 = insert(8, tck, m=3)
>>> tck_inserted2[0]
array([ 0., 0., 0., 0., 5., 8., 8., 8., 10., 10., 10., 10.])
scipy.interpolate.UnivariateSpline
class scipy.interpolate.UnivariateSpline(x, y, w=None, bbox=[None, None], k=3, s=None, ext=0, check_finite=False)
对给定数据点进行的 1-D *滑样条拟合。
将度为 k 的样条 y = spl(x) 拟合到提供的 x、y 数据。s 通过指定一个*滑条件来指定节点的数量。
参数：
x(N,) array_like
独立输入数据的 1-D 数组。必须是递增的；如果 s 为 0，则必须严格递增。
y(N,) array_like
与 x 长度相同的依赖输入数据的 1-D 数组。
w(N,) array_like, optional
样条拟合的权重。必须是正数。如果 w 为 None，则权重都是 1。默认为 None。
bbox(2,) array_like, optional
两个序列，指定逼*区间的边界。如果 bbox 为 None，则 bbox=[x[0], x[-1]]。默认为 None。
kint, optional
*滑样条的阶数。必须满足 1 <= k <= 5。k = 3 是三次样条。默认为 3。
sfloat or None, optional
用于选择结点数的正*滑因子。将增加结点数，直到满足*滑条件：
sum((w[i] * (y[i]-spl(x[i])))**2, axis=0) <= s
但是，由于数值问题，实际条件是：
abs(sum((w[i] * (y[i]-spl(x[i])))**2, axis=0) - s) < 0.001 * s
如果 s 为 None，则 s 将被设置为 len(w)，用于使用所有数据点的*滑样条。如果为 0，则样条将通过所有数据点进行插值。这相当于 InterpolatedUnivariateSpline。默认为 None。用户可以使用 s 来控制拟合的紧密度和*滑度之间的权衡。较大的 s 表示更多的*滑，而较小的值表示较少的*滑。推荐的 s 值取决于权重 w。如果权重代表 y 的标准偏差的倒数，则在范围 (m-sqrt(2m),m+sqrt(2m)) 内应该找到一个好的 s 值，其中 m 是 x、y 和 w 中的数据点数。这意味着如果 1/w[i] 是 y[i] 的标准偏差的估计值，则 s = len(w) 应该是一个很好的值。
extint or str, optional
控制了不在结点序列定义的区间内的外推模式。
-
如果 ext=0 或者 ‘extrapolate’，返回外推值。
-
如果 ext=1 或者 ‘zeros’，返回 0
-
如果 ext=2 或者 ‘raise’，引发 ValueError
-
如果 ext=3 或者 ‘const’，返回边界值。
默认为 0。
check_finitebool, optional
是否检查输入数组是否只包含有限数值。禁用可能会提高性能，但如果输入包含无穷大或 NaN，则可能会导致问题（崩溃、非终止或无意义的结果）。默认为 False。
参见
BivariateSpline
双变量样条的基类。
SmoothBivariateSpline
给定点的*滑双变量样条。
LSQBivariateSpline
使用加权最小二乘拟合的双变量样条。
RectSphereBivariateSpline
在球面上的矩形网格上的双变量样条。
SmoothSphereBivariateSpline
球面坐标中的*滑双变量样条。
LSQSphereBivariateSpline
使用加权最小二乘拟合的球面坐标中的*滑双变量样条。
RectBivariateSpline
矩形网格上的双变量样条。
InterpolatedUnivariateSpline
为给定数据点集插值的一维样条插值函数。
bisplrep
一个用于找到表面的双变量 B-样条表示的函数。
bisplev
评估双变量 B-样条及其导数的函数。
splrep
一维曲线 B-样条表示的函数。
splev
评估 B-样条或其导数的函数。
sproot
一个用于寻找三次 B-样条根的函数。
splint
在两个给定点之间评估 B-样条的定积分。
spalde
评估 B-样条的所有导数的函数。
注释
数据点的数量必须大于样条度数 k。
NaN 处理：如果输入数组包含nan值，则结果无用，因为底层的样条拟合程序无法处理nan。解决方法是对非数字数据点使用零权重：
>>> import numpy as np
>>> from scipy.interpolate import UnivariateSpline
>>> x, y = np.array([1, 2, 3, 4]), np.array([1, np.nan, 3, 4])
>>> w = np.isnan(y)
>>> y[w] = 0.
>>> spl = UnivariateSpline(x, y, w=~w)
注意，需要将nan替换为数值（精确数值不重要，只要相应的权重为零即可）。
References
[1]
P. Dierckx，“使用样条函数进行*滑、求导和积分的算法”，J.Comp.Appl.Maths 1 (1975) 165-184。
[2]
P. Dierckx，“在使用样条函数进行数据*滑的快速算法”，SIAM J.Numer.Anal. 19 (1982) 1286-1304。
[3]
P. Dierckx，“使用样条函数进行曲线拟合的改进算法”，报告 tw54，计算机科学系，库鲁文大学，1981 年。
[4]
P. Dierckx，“使用样条函数进行曲线和曲面拟合”，《数值分析专著》，牛津大学出版社，1993 年。
Examples
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.interpolate import UnivariateSpline
>>> rng = np.random.default_rng()
>>> x = np.linspace(-3, 3, 50)
>>> y = np.exp(-x**2) + 0.1 * rng.standard_normal(50)
>>> plt.plot(x, y, 'ro', ms=5)
使用默认值进行*滑参数：
>>> spl = UnivariateSpline(x, y)
>>> xs = np.linspace(-3, 3, 1000)
>>> plt.plot(xs, spl(xs), 'g', lw=3)
手动调整*滑量：
>>> spl.set_smoothing_factor(0.5)
>>> plt.plot(xs, spl(xs), 'b', lw=3)
>>> plt.show()
Methods
__call__(x[, nu, ext]) |
在位置 x 处评估样条函数（或其第 nu 阶导数）。 |
|---|---|
antiderivative([n]) |
构造表示该样条函数不定积分的新样条函数。 |
derivative([n]) |
构造表示该样条函数导数的新样条函数。 |
derivatives(x) |
返回样条函数在点 x 处的所有导数。 |
get_coeffs() |
返回样条函数的系数。 |
get_knots() |
返回样条函数内部结点的位置。 |
get_residual() |
返回样条逼*的加权残差*方和。 |
integral(a, b) |
返回样条函数在两个给定点之间的定积分。 |
roots() |
返回样条函数的零点。 |
set_smoothing_factor(s) |
使用给定的*滑系数 s 和上次调用时找到的节点继续计算样条函数。 |
| validate_input |
scipy.interpolate.InterpolatedUnivariateSpline
class scipy.interpolate.InterpolatedUnivariateSpline(x, y, w=None, bbox=[None, None], k=3, ext=0, check_finite=False)
给定数据点的 1-D 插值样条。
用于拟合给定 x, y 数据的 k 阶样条函数。样条函数通过所有给定点。等同于 UnivariateSpline，其中 s = 0。
参数：
x(N,) array_like
数据点的输入维度 - 必须严格递增
y(N,) array_like
数据点的输入维度
w(N,) array_like，可选
用于样条拟合的权重。必须为正数。如果为 None（默认值），则所有权重均为 1。
bbox(2,) array_like，可选
指定*似区间边界的 2 元序列。如果为 None（默认值），bbox=[x[0], x[-1]]。
kint, 可选
*滑样条的阶数。必须满足 1 <= k <= 5。默认为 k = 3，即三次样条。
extint 或 str，可选
控制不在由结点序列定义的区间内的外推模式。
-
若 ext=0 或 ‘extrapolate’，返回外推值。
-
若 ext=1 或 ‘zeros’，返回 0
-
若 ext=2 或 ‘raise’，则引发 ValueError
-
若 ext=3 或 ‘const’，返回边界值。
默认值为 0。
check_finitebool，可选
是否检查输入数组仅包含有限数值。禁用可能会提高性能，但如果输入包含无穷大或 NaN，则可能导致问题（崩溃、非终止或无意义的结果）。默认为 False。
参见
用于拟合给定数据点的*滑单变量样条曲线。
用户选择节点的样条
通过给定点的*滑双变量样条
使用加权最小二乘拟合的双变量样条
用于找到 1-D 曲线的 B 样条表示的函数
用于评估 B 样条或其导数的函数
一个查找三次 B 样条根的函数
评估给定两点之间 B 样条的定积分的函数
评估 B 样条的所有导数的函数
注意
数据点的数量必须大于样条度数 k。
示例
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.interpolate import InterpolatedUnivariateSpline
>>> rng = np.random.default_rng()
>>> x = np.linspace(-3, 3, 50)
>>> y = np.exp(-x**2) + 0.1 * rng.standard_normal(50)
>>> spl = InterpolatedUnivariateSpline(x, y)
>>> plt.plot(x, y, 'ro', ms=5)
>>> xs = np.linspace(-3, 3, 1000)
>>> plt.plot(xs, spl(xs), 'g', lw=3, alpha=0.7)
>>> plt.show()
注意 spl(x) 插值 y：
>>> spl.get_residual()
0.0
方法
__call__(x[, nu, ext]) |
在位置 x 处评估样条（或其第 nu 阶导数）。 |
|---|---|
antiderivative([n]) |
构造一个代表该样条的不定积分的新样条。 |
derivative([n]) |
构造一个代表该样条导数的新样条。 |
derivatives(x) |
返回样条在点 x 处的所有导数。 |
get_coeffs() |
返回样条系数。 |
get_knots() |
返回样条内部结点的位置。 |
get_residual() |
返回样条逼*的加权残差*方和。 |
integral(a, b) |
返回给定两点之间样条的定积分。 |
roots() |
返回样条函数的零点。 |
set_smoothing_factor(s) |
继续使用给定的*滑因子 s 和上次调用时找到的节点进行样条计算。 |
| validate_input |
scipy.interpolate.LSQUnivariateSpline
class scipy.interpolate.LSQUnivariateSpline(x, y, t, w=None, bbox=[None, None], k=3, ext=0, check_finite=False)
具有显式内部结点的一维样条。
将样条 y = spl(x) 拟合到提供的 x, y 数据。t 指定样条的内部结点
参数：
x(N,) array_like
数据点的输入维度 - 必须递增
y(N,) array_like
数据点的输入维度
t(M,) array_like
样条的内部结点。必须按升序排列，并且：
bbox[0] < t[0] < ... < t[-1] < bbox[-1]
w(N,) array_like，可选
用于样条拟合的权重。必须为正数。如果为 None（默认），所有权重均为 1。
bbox(2,) array_like，可选
指定逼*区间边界的 2 元组序列。如果为 None（默认），bbox = [x[0], x[-1]]。
kint，可选
*滑样条的阶数。必须满足 1 <= k <= 5。默认值为 k = 3，即三次样条。
extint 或者 str，可选
控制超出结点序列定义的区间的外推模式。
-
如果 ext=0 或者 ‘extrapolate’，返回外推值。
-
如果 ext=1 或者 ‘zeros’，返回 0
-
如果 ext=2 或者 ‘raise’，引发 ValueError
-
如果 ext=3 或者 ‘const’，返回边界值。
默认值为 0。
check_finitebool，可选
是否检查输入数组仅包含有限数。禁用可能会提高性能，但如果输入包含无穷大或 NaN，则可能会导致问题（崩溃、非终止或非意义结果）。默认值为 False。
引发：
ValueError
如果内部结点不满足 Schoenberg-Whitney 条件
另请参见
UnivariateSpline
用于拟合给定数据点集的*滑单变量样条。
InterpolatedUnivariateSpline
给定数据点的插值单变量样条。
splrep
一个用于找到一维曲线的 B-样条表示的函数
splev
一个用于评估 B-样条或其导数的函数
sproot
一个用于找到立方 B-样条根的函数
splint
一个用于计算 B-样条在给定两点之间的定积分的函数
spalde
一个用于评估 B-样条的所有导数的函数
注意
数据点数必须大于样条度数 k。
节点 t 必须满足 Schoenberg-Whitney 条件，即必须存在数据点 x[j] 的子集，使得 t[j] < x[j] < t[j+k+1]，对于 j=0, 1,...,n-k-2。
示例
>>> import numpy as np
>>> from scipy.interpolate import LSQUnivariateSpline, UnivariateSpline
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
>>> x = np.linspace(-3, 3, 50)
>>> y = np.exp(-x**2) + 0.1 * rng.standard_normal(50)
用预定义的内部节点拟合*滑样条：
>>> t = [-1, 0, 1]
>>> spl = LSQUnivariateSpline(x, y, t)
>>> xs = np.linspace(-3, 3, 1000)
>>> plt.plot(x, y, 'ro', ms=5)
>>> plt.plot(xs, spl(xs), 'g-', lw=3)
>>> plt.show()
检查节点向量：
>>> spl.get_knots()
array([-3., -1., 0., 1., 3.])
构造使用另一个样条的节点的 LSQ 样条：
>>> x = np.arange(10)
>>> s = UnivariateSpline(x, x, s=0)
>>> s.get_knots()
array([ 0., 2., 3., 4., 5., 6., 7., 9.])
>>> knt = s.get_knots()
>>> s1 = LSQUnivariateSpline(x, x, knt[1:-1]) # Chop 1st and last knot
>>> s1.get_knots()
array([ 0., 2., 3., 4., 5., 6., 7., 9.])
方法
__call__(x[, nu, ext]) |
在位置 x 处评估样条（或其第 nu 阶导数）。 |
|---|---|
antiderivative([n]) |
构造一个表示此样条的反导数的新样条。 |
derivative([n]) |
构造一个表示此样条导数的新样条。 |
derivatives(x) |
返回样条在点 x 处的所有导数。 |
get_coeffs() |
返回样条系数。 |
get_knots() |
返回样条内部节点的位置。 |
get_residual() |
返回样条逼*的加权残差*方和。 |
integral(a, b) |
返回样条在给定两点之间的定积分。 |
roots() |
返回样条的零点。 |
set_smoothing_factor(s) |
使用给定的*滑系数 s 和上次调用时找到的节点继续样条计算。 |
| validate_input |
浙公网安备 33010602011771号