SciPy 1.12 中文文档（十二）

最新推荐文章于 2025-09-15 18:57:07 发布

原创最新推荐文章于 2025-09-15 18:57:07 发布 · 910 阅读

22 ·

CC 4.0 BY-SA版权

License CC BY-NC-SA 4.0 / 自豪地采用谷歌翻译

文章标签：

#scipy #python #算法

scipy 专栏收录该内容

81 篇文章

订阅专栏

原文：docs.scipy.org/doc/scipy-1.12.0/index.html

`scipy.interpolate.NdBSpline`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.NdBSpline.html#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。默认是外推。

另请参见

BSpline

一个一维 B 样条对象

NdPPoly

一个 N 维分段张量积多项式

属性：

tndarray 的元组

结节点向量。

cndarray

张量产品样条的系数。

k整数的元组

每个维度的度数。

extrapolate布尔值，可选

是否对超出范围的输入进行外推或返回 nan。默认为真。

方法

`__call__`(xi, *[, nu, extrapolate])	在`xi`处评估张量积 B 样条。

`scipy.interpolate.BSpline`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.BSpline.html#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()

../../_images/scipy-interpolate-BSpline-1.png

属性：

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`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.make_interp_spline.html#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()

../../_images/scipy-interpolate-make_interp_spline-1_00_00.png

构建一个具有 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()

../../_images/scipy-interpolate-make_interp_spline-1_01_00.png

`scipy.interpolate.make_lsq_spline`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.make_lsq_spline.html#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 样条

表示 B 样条对象的基类

make_interp_spline

一个类似的插值样条的工厂函数

LSQUnivariateSpline

一个基于 FITPACK 的样条拟合例程

splrep

一个基于 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()

../../_images/scipy-interpolate-make_lsq_spline-1_00_00.png

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`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.make_smoothing_spline.html#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()

../../_images/scipy-interpolate-make_smoothing_spline-1.png

`scipy.interpolate.splrep`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.splrep.html#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{1, 0, -1}，可选

如果 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

bisplrep，bisplev

BSpline

make_interp_spline

注意

查看 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]，[2]，[3] 和 [4] 中描述的算法：

[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()

../../_images/scipy-interpolate-splrep-1.png

`scipy.interpolate.splprep`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.splprep.html#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()

../../_images/scipy-interpolate-splprep-1.png

`scipy.interpolate.splev`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.splev.html#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

bisplrep, bisplev

BSpline

注释

不推荐直接操作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`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.splint.html#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`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.sproot.html#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

bisplrep，bisplev

BSpline

注意事项

直接操作 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`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.spalde.html#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{ndarray, list of ndarrays}

一个数组（或数组列表），每个点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`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.splder.html#scipy.interpolate.splder

scipy.interpolate.splder(tck, n=1)

计算给定样条导数的样条表示

参数：

tckBSpline 实例或元组 (t, c, k)

要计算其导数的样条

nint，可选

要评估的导数阶数。默认值：1

BSpline 实例或元组

表示输入样条导数的阶数为 k2=k-n 的样条。如果输入参数 tck 是元组，则返回元组，否则构造并返回 BSpline 对象。

另请参阅

splantider，splev，spalde

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`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.splantider.html#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, splev, spalde

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`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.UnivariateSpline.html#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]、[2]、[3]和[4]中描述的算法：

[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()

../../_images/scipy-interpolate-UnivariateSpline-1.png

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`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.InterpolatedUnivariateSpline.html#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。

参见

UnivariateSpline

用于拟合给定数据点的平滑单变量样条曲线。

LSQUnivariateSpline

用户选择节点的样条

SmoothBivariateSpline

通过给定点的平滑双变量样条

LSQBivariateSpline

使用加权最小二乘拟合的双变量样条

splrep

用于找到 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()

../../_images/scipy-interpolate-InterpolatedUnivariateSpline-1_00_00.png

注意 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`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.LSQUnivariateSpline.html#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()

../../_images/scipy-interpolate-LSQUnivariateSpline-1_00_00.png

检查节点向量：

>>> 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

`scipy.interpolate.RectBivariateSpline`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.interpolate.RectBivariateSpline.html#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整数，可选

双变量样条的度数。默认值为 3。

s浮点数，可选

正面的平滑因子定义为估计条件：sum((z[i]-f(x[i], y[i]))**2, axis=0) <= s，其中 f 是样条函数。默认值为s=0，适用于插值。

另请参见

双变量样条

双变量样条的基类。

单变量样条

用于拟合给定数据点的平滑单变量样条。

平滑双变量样条

通过给定点的平滑双变量样条

LSQ 矩形双变量样条

使用加权最小二乘拟合的双变量样条

矩形球面双变量样条

在球面上矩形网格上的双变量样条

球面平滑双变量样条

球面坐标中的平滑双变量样条

LSQ 球面双变量样条

使用加权最小二乘拟合的球面坐标中的双变量样条

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)	构造表示此样条的偏导数的新样条。
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)	构造表示此样条的偏导数的新样条。