SciPy-1-12-中文文档-六-

SciPy 1.12 中文文档（六）

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

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

`scipy.interpolate.RectSphereBivariateSpline`

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

class scipy.interpolate.RectSphereBivariateSpline(u, v, r, s=0.0, pole_continuity=False, pole_values=None, pole_exact=False, pole_flat=False)

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

可用于平滑数据。

新版本 0.11.0 中的功能。

参数：

uarray_like

严格升序的极角坐标系一维数组。坐标必须以弧度给出，并位于开区间(0, pi)内。

varray_like

严格升序的经度坐标系一维数组。坐标必须以弧度给出。第一个元素 (v[0]) 必须位于区间 [-pi, pi) 内。最后一个元素 (v[-1]) 必须满足 v[-1] <= v[0] + 2*pi。

rarray_like

形状为 (u.size, v.size) 的二维数据数组。

sfloat, optional

为估计条件定义的正平滑因子 (s=0 用于插值)。

pole_continuitybool or (bool, bool), optional

极点 u=0 (pole_continuity[0]) 和 u=pi (pole_continuity[1]) 处的连续性顺序。当为 True 或 False 时，极点的连续性顺序为 1 或 0。默认为 False。

pole_valuesfloat or (float, float), optional

极点 u=0 和 u=pi 处的数据值。可以是整个参数或每个单独的元素。默认为 None。

pole_exactbool or (bool, bool), optional

极点 u=0 和 u=pi 处的数据值精确性。如果为 True，则该值被视为正确的函数值，并将被精确拟合。如果为 False，则该值将被视为与其他数据值一样的数据值。默认为 False。

pole_flatbool or (bool, bool), optional

对于 u=0 和 u=pi 处的极点，指定近似是否具有消失导数。默认为 False。

另请参阅

BivariateSpline

用于双变量样条的基类。

UnivariateSpline

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

SmoothBivariateSpline

平滑拟合给定点的双变量样条

LSQBivariateSpline

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

SmoothSphereBivariateSpline

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

LSQSphereBivariateSpline

在球坐标系中使用加权最小二乘拟合的二元样条

RectBivariateSpline

一个在矩形网格上的二元样条。

bisplrep

一个函数来找到一个表面的二元 B 样条表示

bisplev

一个评估二元 B 样条及其导数的函数

注释

目前，仅支持平滑样条逼近（iopt[0] = 0和iopt[0] = 1在 FITPACK 例程中）。尚未实现精确的最小二乘样条逼近。

实际执行插值时，所请求的v值必须位于与原始v值选择相同长度的 2pi 间隔内。

欲了解更多信息，请参见关于此函数的FITPACK网站。

示例

假设我们有一个粗网格上的全局数据

>>> import numpy as np
>>> lats = np.linspace(10, 170, 9) * np.pi / 180.
>>> lons = np.linspace(0, 350, 18) * np.pi / 180.
>>> data = np.dot(np.atleast_2d(90. - np.linspace(-80., 80., 18)).T,
...               np.atleast_2d(180. - np.abs(np.linspace(0., 350., 9)))).T

我们想将其插值到全局一度网格上

>>> new_lats = np.linspace(1, 180, 180) * np.pi / 180
>>> new_lons = np.linspace(1, 360, 360) * np.pi / 180
>>> new_lats, new_lons = np.meshgrid(new_lats, new_lons)

我们需要设置插值器对象

>>> from scipy.interpolate import RectSphereBivariateSpline
>>> lut = RectSphereBivariateSpline(lats, lons, data)

最后，我们插值数据。 RectSphereBivariateSpline对象只接受 1-D 数组作为输入，因此我们需要进行一些重塑。

>>> data_interp = lut.ev(new_lats.ravel(),
...                      new_lons.ravel()).reshape((360, 180)).T

查看原始和插值数据，可以看到插值器非常好地复制了原始数据：

>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> ax1 = fig.add_subplot(211)
>>> ax1.imshow(data, interpolation='nearest')
>>> ax2 = fig.add_subplot(212)
>>> ax2.imshow(data_interp, interpolation='nearest')
>>> plt.show()

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

选择最优值s可能是一个微妙的任务。推荐的s值取决于数据值的准确性。如果用户对数据的统计误差有一个概念，她也可以找到一个合适的s的估计值。假设，如果她指定了正确的s，插值器将使用一个完全复制数据背后函数的样条f(u,v)，她可以评估sum((r(i,j)-s(u(i),v(j)))**2)以找到这个s的良好估计值。例如，如果她知道她的r(i,j)值的统计误差不大于 0.1，她可能期望一个好的s值不应大于u.size * v.size * (0.1)**2。

如果对于r(i,j)的统计误差一无所知，则s必须通过试探法确定。最好的方法是从一个非常大的值s开始（以确定最小二乘多项式和相应的上界fp0为s），然后逐渐减小s的值（比如一开始减小 10 倍，即s = fp0 / 10, fp0 / 100, ...，随着近似显示更多细节，操作更为谨慎）以获得更接近的拟合。

不同s值的插值结果为此过程提供了一些见解：

>>> fig2 = plt.figure()
>>> s = [3e9, 2e9, 1e9, 1e8]
>>> for idx, sval in enumerate(s, 1):
...     lut = RectSphereBivariateSpline(lats, lons, data, s=sval)
...     data_interp = lut.ev(new_lats.ravel(),
...                          new_lons.ravel()).reshape((360, 180)).T
...     ax = fig2.add_subplot(2, 2, idx)
...     ax.imshow(data_interp, interpolation='nearest')
...     ax.set_title(f"s = {sval:g}")
>>> plt.show()

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

方法

`__call__`(theta, phi[, dtheta, dphi, grid])	在给定位置评估样条或其导数。
`ev`(theta, phi[, dtheta, dphi])	在点上评估样条
`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)
`partial_derivative`(dx, dy)	构造代表此样条的偏导数的新样条。

`scipy.interpolate.BivariateSpline`

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

class scipy.interpolate.BivariateSpline

双变量样条的基类

这描述了在给定数据点(x, y, z)上从矩形[xb, xe] * [yb, ye]计算的kx和ky度数的样条s(x, y)。

这个类被设计成作为子类使用，不直接实例化。要构建这些样条，请调用SmoothBivariateSpline、LSQBivariateSpline 或 RectBivariateSpline。

另请参见

UnivariateSpline

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

SmoothBivariateSpline

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

LSQBivariateSpline

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

RectSphereBivariateSpline

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

SmoothSphereBivariateSpline

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

LSQSphereBivariateSpline

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

RectBivariateSpline

一个在矩形网格上的双变量样条

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.SmoothBivariateSpline`

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

class scipy.interpolate.SmoothBivariateSpline(x, y, z, w=None, bbox=[None, None, None, None], kx=3, ky=3, s=None, eps=1e-16)

平滑的二元样条逼近。

参数：

x, y, zarray_like

一维数据点的序列（顺序不重要）。

warray_like，可选

正的一维权重序列，与x、y和z的长度相同。

bboxarray_like，可选

长度为 4 的序列，指定矩形逼近域的边界。默认情况下，bbox=[min(x), max(x), min(y), max(y)]。

kx, ky整数，可选

二元样条的度数。默认为 3。

sfloat，可选

正的平滑因子，用于估计条件：sum((w[i]*(z[i]-s(x[i], y[i])))**2, axis=0) <= s 默认s=len(w)，如果1/w[i]是z[i]标准差的估计值，这应该是一个良好的值。

epsfloat，可选

用于确定过决定线性方程组有效秩的阈值。eps应在开区间(0, 1)内，默认为 1e-16。

另请参阅

BivariateSpline

二元样条的基类。

UnivariateSpline

用于拟合给定数据点的平滑一元样条。

LSQBivariateSpline

使用加权最小二乘法的二元样条

RectSphereBivariateSpline

球上矩形网格上的二元样条

SmoothSphereBivariateSpline

球坐标系中的平滑二元样条

LSQSphereBivariateSpline

使用加权最小二乘法在球坐标系中的平滑二元样条

RectBivariateSpline

矩形网格上的二元样条

bisplrep

找到曲面的二元 B 样条表示的函数

bisplev

评估双变量 B-样条及其导数的函数。

注意

x、y 和 z 的长度应至少为(kx+1) * (ky+1)。

如果输入数据的输入维度具有不兼容的单位并且差异很大，则插值可能会出现数值伪影。考虑在插值之前重新缩放数据。

此例程通过 FITPACK 算法自动构造样条结节向量。样条结节可能位于数据点之外。对于某些数据集，即使请求使用s=0参数构造插值样条，此例程可能也无法成功构造。在这种情况下，建议直接使用bisplrep / bisplev，如有需要，增加bisplrep的nxest和nyest参数的值。

对于线性插值，建议优先使用LinearNDInterpolator。参见此处进行讨论。

方法

`__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.SmoothSphereBivariateSpline`

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

class scipy.interpolate.SmoothSphereBivariateSpline(theta, phi, r, w=None, s=0.0, eps=1e-16)

在球坐标中的平滑双变量样条近似。

版本 0.11.0 中的新功能。

参数：

theta, phi, rarray_like

数据点的 1-D 序列（顺序不重要）。坐标必须用弧度给出。Theta 必须在区间[0, pi]内，phi 必须在区间[0, 2pi]内。

warray_like，可选

正 1-D 权重序列。

sfloat，可选

为估计条件定义的正平滑因子：sum((w(i)*(r(i) - s(theta(i), phi(i))))**2, axis=0) <= s 默认值s=len(w)，如果1/w[i]是r[i]标准差的估计值，这应该是一个很好的值。

epsfloat，可选

用于确定超定线性方程组有效秩的阈值。eps应该在开区间(0, 1)内，缺省值为 1e-16。

另请参阅

BivariateSpline

双变量样条的基类。

UnivariateSpline

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

SmoothBivariateSpline

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

LSQBivariateSpline

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

RectSphereBivariateSpline

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

LSQSphereBivariateSpline

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

RectBivariateSpline

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

bisplrep

找到表面的双变量 B 样条表示的函数

bisplev

评估双变量 B 样条及其导数的函数

注意事项

更多信息，请参阅关于此函数的FITPACK网站。

示例

假设我们有全局数据在粗网格上（输入数据不一定在网格上）：

>>> import numpy as np
>>> theta = np.linspace(0., np.pi, 7)
>>> phi = np.linspace(0., 2*np.pi, 9)
>>> data = np.empty((theta.shape[0], phi.shape[0]))
>>> data[:,0], data[0,:], data[-1,:] = 0., 0., 0.
>>> data[1:-1,1], data[1:-1,-1] = 1., 1.
>>> data[1,1:-1], data[-2,1:-1] = 1., 1.
>>> data[2:-2,2], data[2:-2,-2] = 2., 2.
>>> data[2,2:-2], data[-3,2:-2] = 2., 2.
>>> data[3,3:-2] = 3.
>>> data = np.roll(data, 4, 1)

我们需要设置插值器对象

>>> lats, lons = np.meshgrid(theta, phi)
>>> from scipy.interpolate import SmoothSphereBivariateSpline
>>> lut = SmoothSphereBivariateSpline(lats.ravel(), lons.ravel(),
...                                   data.T.ravel(), s=3.5)

作为第一个测试，我们将看到在输入坐标上运行时算法返回什么。

>>> data_orig = lut(theta, phi)

最后，我们将数据插值到更细的网格上

>>> fine_lats = np.linspace(0., np.pi, 70)
>>> fine_lons = np.linspace(0., 2 * np.pi, 90)

>>> data_smth = lut(fine_lats, fine_lons)

>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> ax1 = fig.add_subplot(131)
>>> ax1.imshow(data, interpolation='nearest')
>>> ax2 = fig.add_subplot(132)
>>> ax2.imshow(data_orig, interpolation='nearest')
>>> ax3 = fig.add_subplot(133)
>>> ax3.imshow(data_smth, interpolation='nearest')
>>> plt.show()

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

方法

`__call__`(theta, phi[, dtheta, dphi, grid])	评估给定位置的样条或其导数。
`ev`(theta, phi[, dtheta, dphi])	在指定点评估样条
`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)
`partial_derivative`(dx, dy)	构造表示此样条的偏导数的新样条。

`scipy.interpolate.LSQBivariateSpline`

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

class scipy.interpolate.LSQBivariateSpline(x, y, z, tx, ty, w=None, bbox=[None, None, None, None], kx=3, ky=3, eps=None)

加权最小二乘双变量样条逼近。

参数：

x, y, z数组类型

数据点的一维序列（顺序不重要）。

tx, ty数组类型

严格排序的一维结节坐标序列。

w数组类型，可选

正权重的 1-D 数组，与x, y 和 z 的长度相同。

bbox（4,）数组类型，可选

指定矩形逼近域边界的长度为 4 的序列。默认情况下，bbox=[min(x,tx),max(x,tx), min(y,ty),max(y,ty)]。

kx, ky整数，可选

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

eps浮点数，可选

用于确定过度确定的线性方程组的有效秩的阈值。eps 应该在开区间 (0, 1) 内取值，默认为 1e-16。

另请参阅

BivariateSpline

用于双变量样条的基类。

UnivariateSpline

平滑的一维样条以适应给定的数据点集。

SmoothBivariateSpline

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

RectSphereBivariateSpline

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

SmoothSphereBivariateSpline

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

LSQSphereBivariateSpline

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

RectBivariateSpline

矩形网格上的双变量样条。

bisplrep

用于找到表面的双变量 B 样条表示的函数

bisplev

评估双变量 B 样条及其导数的函数

注释

x, y 和 z 的长度至少应为 (kx+1) * (ky+1)。

如果输入数据的输入维度具有不相容的单位并且相差多个数量级，则插值可能具有数值人工。考虑在插值之前重新调整数据。

方法

`__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.LSQSphereBivariateSpline`

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

class scipy.interpolate.LSQSphereBivariateSpline(theta, phi, r, tt, tp, w=None, eps=1e-16)

在球坐标中使用加权最小二乘双变量样条逼近。

根据theta和phi方向上给定的一组结点确定平滑的双三次样条。

0.11.0 版本中新增。

参数：

theta, phi, rarray_like

数据点的 1-D 序列（顺序不重要）。坐标必须以弧度给出。Theta 必须位于区间[0, pi]内，phi 必须位于区间[0, 2pi]内。

tt, tparray_like

严格排序的结点坐标的 1-D 序列。坐标必须满足0 < tt[i] < pi，0 < tp[i] < 2*pi。

warray_like, optional

与theta、phi和r长度相同的正 1-D 权重序列。

epsfloat, optional

用于确定超定线性方程组的有效秩的阈值。eps的值应在开区间(0, 1)内，默认值为 1e-16。

另请参见

BivariateSpline

双变量样条的基类。

UnivariateSpline

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

SmoothBivariateSpline

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

LSQBivariateSpline

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

RectSphereBivariateSpline

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

SmoothSphereBivariateSpline

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

RectBivariateSpline

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

bisplrep

用于找到表面的双变量 B 样条表示的函数

bisplev

一个函数用于评估双变量 B 样条及其导数

注意事项

欲了解更多信息，请参阅关于该功能的FITPACK网站。

示例

假设我们有全局数据在粗网格上（输入数据不必在网格上）：

>>> from scipy.interpolate import LSQSphereBivariateSpline
>>> import numpy as np
>>> import matplotlib.pyplot as plt

>>> theta = np.linspace(0, np.pi, num=7)
>>> phi = np.linspace(0, 2*np.pi, num=9)
>>> data = np.empty((theta.shape[0], phi.shape[0]))
>>> data[:,0], data[0,:], data[-1,:] = 0., 0., 0.
>>> data[1:-1,1], data[1:-1,-1] = 1., 1.
>>> data[1,1:-1], data[-2,1:-1] = 1., 1.
>>> data[2:-2,2], data[2:-2,-2] = 2., 2.
>>> data[2,2:-2], data[-3,2:-2] = 2., 2.
>>> data[3,3:-2] = 3.
>>> data = np.roll(data, 4, 1)

我们需要设置插值器对象。在这里，我们还必须指定要使用的节点坐标。

>>> lats, lons = np.meshgrid(theta, phi)
>>> knotst, knotsp = theta.copy(), phi.copy()
>>> knotst[0] += .0001
>>> knotst[-1] -= .0001
>>> knotsp[0] += .0001
>>> knotsp[-1] -= .0001
>>> lut = LSQSphereBivariateSpline(lats.ravel(), lons.ravel(),
...                                data.T.ravel(), knotst, knotsp)

作为第一个测试，我们将查看算法在输入坐标上运行时返回的内容。

>>> data_orig = lut(theta, phi)

最后，我们对数据进行插值，得到更精细的网格。

>>> fine_lats = np.linspace(0., np.pi, 70)
>>> fine_lons = np.linspace(0., 2*np.pi, 90)
>>> data_lsq = lut(fine_lats, fine_lons)

>>> fig = plt.figure()
>>> ax1 = fig.add_subplot(131)
>>> ax1.imshow(data, interpolation='nearest')
>>> ax2 = fig.add_subplot(132)
>>> ax2.imshow(data_orig, interpolation='nearest')
>>> ax3 = fig.add_subplot(133)
>>> ax3.imshow(data_lsq, interpolation='nearest')
>>> plt.show()

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

方法

`__call__`(theta, phi[, dtheta, dphi, grid])	在给定位置评估样条或其导数。
`ev`(theta, phi[, dtheta, dphi])	在点处评估样条
`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)
`partial_derivative`(dx, dy)	构造表示此样条偏导数的新样条。

`scipy.interpolate.bisplrep`

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

scipy.interpolate.bisplrep(x, y, z, w=None, xb=None, xe=None, yb=None, ye=None, kx=3, ky=3, task=0, s=None, eps=1e-16, tx=None, ty=None, full_output=0, nxest=None, nyest=None, quiet=1)

查找表面的二元 B-样条表示。

给定表示表面 z=f(x,y) 的一组数据点 (x[i], y[i], z[i])，计算表面的 B-样条表示。基于 FITPACK 中的 SURFIT 程序。

参数：

x, y, z 数组

数据点的一维数组。

w 数组，可选

权重的一维数组。默认情况下为 w=np.ones(len(x))。

xb, xe 浮点数，可选

x 轴逼近区间的端点。默认为 xb = x.min(), xe=x.max()。

yb, ye 浮点数，可选

y 轴逼近区间的端点。默认为 yb=y.min(), ye = y.max()。

kx, ky 整数，可选

样条的次数（1 <= kx, ky <= 5）。建议使用三阶（kx=ky=3）。

task 整数，可选

如果 task=0，则找到 x 和 y 的结点以及给定平滑因子 s 的系数。如果 task=1，则找到另一个平滑因子 s 的结点和系数。bisplrep 必须先前以 task=0 或 task=1 调用过。如果 task=-1，则找到给定结点 tx, ty 的系数。

s 浮点数，可选

非负平滑因子。如果权重对应于 z 中误差标准差的倒数，则应在范围内找到良好的 s 值 (m-sqrt(2*m),m+sqrt(2*m))，其中 m=len(x)。

eps 浮点数，可选

用于确定过度确定的线性方程组的有效秩的阈值 (0 < eps < 1)。eps 不太可能需要更改。

tx, ty 数组，可选

用于 task=-1 的样条结点的一维数组。

full_output 整数，可选

非零以返回可选输出。

nxest, nyest 整数，可选

对总节点数的过度估计。如果为 None，则nxest = max(kx+sqrt(m/2),2*kx+3), nyest = max(ky+sqrt(m/2),2*ky+3)。

quiet 整数，可选

非零以抑制消息的打印。

tck 类数组

包含结点 (tx, ty) 和系数 (c) 的二元 B-样条表示及样条度的列表 [tx, ty, c, kx, ky]。

fp 数组

样条逼近的加权平方残差和。

ier 整数

有关 splrep 成功的整数标志。如果 ier<=0，则表示成功。如果 ier 在 [1,2,3] 中，则表示发生错误但未引发错误。否则引发错误。

msg 字符串

与整数标志 ier 相对应的消息。

参见

splprep，splrep，splint，sproot，splev

UnivariateSpline，BivariateSpline

注释

见bisplev以评估其 tck 表示中的 B 样条的值。

如果输入数据的输入维度具有不相容的单位并且相差多个数量级，则插值可能会产生数值人工影响。在插值之前考虑重新缩放数据。

参考文献

[1]

Dierckx P.：用样条函数进行曲面拟合的算法 Ima J. Numer. Anal. 1 (1981) 267-283。

[2]

Dierckx P.：用样条函数进行曲面拟合的算法报告 tw50, Dept. Computer Science, K.U.Leuven, 1980。

[3]

Dierckx P.：用样条曲线和曲面拟合，数值分析专著，牛津大学出版社，1993 年。

示例

示例见教程。

`scipy.interpolate.bisplev`

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

scipy.interpolate.bisplev(x, y, tck, dx=0, dy=0)

评估双变量 B 样条及其导数。

返回一个样条函数值（或样条导数值）的二阶数组，在由一阶数组x和y的叉积给定的点处。在特殊情况下，如果x或y或两者都是浮点数，则返回一个数组或仅一个浮点数。基于 FITPACK 中的 BISPEV 和 PARDER。

参数：

x, yndarray

用于指定评估样条或其导数的域的一阶数组。

tcktuple

返回一个长度为 5 的序列，由bisplrep返回，包含结点位置、系数和样条的次数：[tx, ty, c, kx, ky]。

dx, dyint, optional

x和y分别的偏导数阶数。

valsndarray

在由x和y的叉积形成的集合上评估的 B 样条或其导数。

另请参阅

splprep, splrep, splint, sproot, splev

UnivariateSpline, BivariateSpline

注释

请参见bisplrep生成tck表示。

参考文献

[1]

Dierckx P.：用样条函数拟合曲面的算法，Ima J. Numer. Anal. 1 (1981) 267-283。

[2]

Dierckx P.：用样条函数拟合曲面的算法，报告 tw50，计算机科学系，K.U.Leuven，1980 年。

[3]

Dierckx P.：用样条拟合曲线和曲面，数值分析专著，牛津大学出版社，1993 年。

示例

示例见 tutorial。

`scipy.interpolate.lagrange`

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

scipy.interpolate.lagrange(x, w)

返回 Lagrange 插值多项式。

给定两个 1-D 数组x和w，返回通过点(x, w)的 Lagrange 插值多项式。

警告：此实现在数值上不稳定。即使选择了最佳点，也不要期望能够使用超过大约 20 个点。

参数：

xarray_like

x代表一组数据点的 x 坐标。

warray_like

w代表一组数据点的 y 坐标，即，f(x)。

lagrangenumpy.poly1d 实例

Lagrange 插值多项式。

示例

通过 3 个点插值(f(x) = x³)。

>>> import numpy as np
>>> from scipy.interpolate import lagrange
>>> x = np.array([0, 1, 2])
>>> y = x**3
>>> poly = lagrange(x, y)

由于只有 3 个点，Lagrange 多项式的次数为 2。具体地，它由以下公式给出：

[ $\begin{split}\begin{aligned} L(x) &= 1\times \frac{x (x - 2)}{-1} + 8\times \frac{x (x-1)}{2} \ &= x (-2 + 3x) \end{aligned}\end{split}$ ]

>>> from numpy.polynomial.polynomial import Polynomial
>>> Polynomial(poly.coef[::-1]).coef
array([ 0., -2.,  3.])

>>> import matplotlib.pyplot as plt
>>> x_new = np.arange(0, 2.1, 0.1)
>>> plt.scatter(x, y, label='data')
>>> plt.plot(x_new, Polynomial(poly.coef[::-1])(x_new), label='Polynomial')
>>> plt.plot(x_new, 3*x_new**2 - 2*x_new + 0*x_new,
...          label=r"$3 x² - 2 x$", linestyle='-.')
>>> plt.legend()
>>> plt.show()

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

`scipy.interpolate.approximate_taylor_polynomial`

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

scipy.interpolate.approximate_taylor_polynomial(f, x, degree, scale, order=None)

通过多项式拟合来估计在 x 处的 f 的泰勒多项式。

参数：

f callable

寻求其泰勒多项式的函数。应接受一个 x 值的向量。

x 标量

要评估多项式的点。

degree int

泰勒多项式的阶数。

scale 标量

要评估泰勒多项式的区间宽度。在此宽度范围内的函数值用于拟合多项式。必须谨慎选择。

order int 或 None，可选

用于拟合的多项式的阶数；f 将被评估 order+1 次。如果为 None，则使用 degree。

p poly1d 实例

泰勒多项式（转化为原点，例如 p(0)=f(x)）。

注意

“比例尺”的适当选择是一种权衡；如果太大，函数与其泰勒多项式的差异太大，无法得到良好的答案；如果太小，舍入误差将淹没高阶项。即使在理想情况下，使用的算法在阶数为 30 时也会变得数值不稳定。

选择比 degree 稍大的 order 可能会改善高阶项。

示例

我们可以计算不同阶数的 sin 函数的泰勒逼近多项式：

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.interpolate import approximate_taylor_polynomial
>>> x = np.linspace(-10.0, 10.0, num=100)
>>> plt.plot(x, np.sin(x), label="sin curve")
>>> for degree in np.arange(1, 15, step=2):
...     sin_taylor = approximate_taylor_polynomial(np.sin, 0, degree, 1,
...                                                order=degree + 2)
...     plt.plot(x, sin_taylor(x), label=f"degree={degree}")
>>> plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left',
...            borderaxespad=0.0, shadow=True)
>>> plt.tight_layout()
>>> plt.axis([-10, 10, -10, 10])
>>> plt.show()

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

`scipy.interpolate.pade`

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

scipy.interpolate.pade(an, m, n=None)

返回多项式的帕德逼近，作为两个多项式的比率。

参数：

an(N,) array_like

泰勒级数系数。

m整数

返回的逼近多项式 q 的顺序。

n整数，可选

返回的逼近多项式 p 的顺序。默认情况下，顺序是 len(an)-1-m。

返回值：

p, q多项式类

由 an 定义的多项式的帕德逼近为 p(x)/q(x)。

示例

>>> import numpy as np
>>> from scipy.interpolate import pade
>>> e_exp = [1.0, 1.0, 1.0/2.0, 1.0/6.0, 1.0/24.0, 1.0/120.0]
>>> p, q = pade(e_exp, 2)

>>> e_exp.reverse()
>>> e_poly = np.poly1d(e_exp)

比较 e_poly(x) 和帕德逼近 p(x)/q(x)。

>>> e_poly(1)
2.7166666666666668

>>> p(1)/q(1)
2.7179487179487181

输入输出（`scipy.io`）

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

SciPy 提供许多模块、类和函数，用于读取和写入多种文件格式的数据。

另请参阅

NumPy IO routines

MATLAB® 文件

`loadmat`(file_name[, mdict, appendmat])	加载 MATLAB 文件。
`savemat`(file_name, mdict[, appendmat, ...])	将名称和数组字典保存到 MATLAB 风格的 .mat 文件中。
`whosmat`(file_name[, appendmat])	列出 MATLAB 文件中的变量。

有关低级 MATLAB 读写实用程序，请参见 scipy.io.matlab。

IDL® 文件

`readsav`(file_name[, idict, python_dict, ...])	读取 IDL .sav 文件。

Matrix Market 文件

`mminfo`(source)	从类似 Matrix Market 文件的源返回大小和存储参数。
`mmread`(source)	将类似 Matrix Market 文件的 'source' 的内容读入矩阵中。
`mmwrite`(target, a[, comment, field, ...])	将稀疏或密集数组 a 写入类似 Matrix Market 文件的 target 中。

无格式的 Fortran 文件

`FortranFile`(filename[, mode, header_dtype])	用于从 Fortran 代码中读取无格式顺序文件的文件对象。
`FortranEOFError`	表示文件已正确结束。
`FortranFormattingError`	表示文件在记录中途结束。

Netcdf

`netcdf_file`(filename[, mode, mmap, version, ...])	用于 NetCDF 数据的文件对象。
`netcdf_variable`(data, typecode, size, shape, ...)	用于 netcdf 文件的数据对象。

Harwell-Boeing 文件

`hb_read`(path_or_open_file)	读取 HB 格式文件。
`hb_write`(path_or_open_file, m[, hb_info])	写入 HB 格式文件。

Wav 音频文件 (`scipy.io.wavfile`)

`read`(filename[, mmap])	打开一个 WAV 文件。
`write`(filename, rate, data)	将 NumPy 数组写入 WAV 文件。

| WavFileWarning | | ## Arff 文件 (scipy.io.arff)

`loadarff`(f)	读取一个 arff 文件。
`MetaData`(rel, attr)	小容器，用于保存 ARFF 数据集的有用信息。
`ArffError`
`ParseArffError`

`scipy.io.loadmat`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.loadmat.html#scipy.io.loadmat

scipy.io.loadmat(file_name, mdict=None, appendmat=True, **kwargs)

加载 MATLAB 文件。

参数：

file_namestr

mat 文件的名称（如果 appendmat==True，则不需要 .mat 扩展名）。也可以传递打开的文件对象。

mdictdict，可选

要插入 mat 文件变量的字典。

appendmatbool，可选

如果给定的文件名末尾没有 .mat 扩展名，则为 True 追加 .mat 扩展名。默认为 True。

byte_orderstr 或 None，可选

默认为 None，表示从 mat 文件中猜测字节顺序。否则可以是（‘native’, ‘=’, ‘little’, ‘<’, ‘BIG’, ‘>’）中的一个。

mat_dtypebool，可选

如果为 True，则返回与加载到 MATLAB 中相同的 dtype 的数组（而不是保存时的 dtype）。

squeeze_mebool，可选

是否要压缩单元矩阵的维度。

chars_as_stringsbool，可选

是否将 char 数组转换为字符串数组。

matlab_compatiblebool，可选

将矩阵返回为 MATLAB 将加载的格式（意味着 squeeze_me=False, chars_as_strings=False, mat_dtype=True, struct_as_record=True）。

struct_as_recordbool，可选

是否将 MATLAB 结构加载为 NumPy 记录数组，或者加载为旧式 NumPy 数组（dtype=object）。将此标志设置为 False 复制 scipy 版本 0.7.x 的行为（返回 NumPy 对象数组）。默认设置为 True，因为它允许更容易地往返加载和保存 MATLAB 文件。

verify_compressed_data_integritybool，可选

是否应检查 MATLAB 文件中压缩序列的长度，以确保其不超过我们预期的长度。建议启用此功能（默认值），因为 MATLAB 文件中的超长压缩序列通常表明文件已经遭受了某种损坏。

variable_namesNone 或序列

如果为 None（默认值）- 读取文件中的所有变量。否则，variable_names 应为字符串序列，指定要从文件中读取的 MATLAB 变量的名称。读取器将跳过不在此序列中的任何变量名称，可能会节省一些读取处理。

simplify_cellsFalse，可选

如果为 True，则返回简化的字典结构（如果 mat 文件包含单元数组，则这对于有用）。请注意，这仅影响结果的结构，而不影响其内容（两种输出结构的内容相同）。如果为 True，则自动将 struct_as_record 设置为 False 和 squeeze_me 设置为 True，这是简化单元的必要设置。

mat_dictdict

以变量名作为键，加载的矩阵作为值的字典。

注意

支持 v4（Level 1.0）、v6 和 v7 到 7.2 mat 文件。

您需要一个 HDF5 Python 库来读取 MATLAB 7.3 格式的 mat 文件。因为 SciPy 没有提供此功能，我们在此不实现 HDF5 / 7.3 接口。

示例

>>> from os.path import dirname, join as pjoin
>>> import scipy.io as sio

从 tests/data 目录获取示例 .mat 文件的文件名。

>>> data_dir = pjoin(dirname(sio.__file__), 'matlab', 'tests', 'data')
>>> mat_fname = pjoin(data_dir, 'testdouble_7.4_GLNX86.mat')

加载 .mat 文件的内容。

>>> mat_contents = sio.loadmat(mat_fname)

结果是一个字典，每个变量对应一个键值对：

>>> sorted(mat_contents.keys())
['__globals__', '__header__', '__version__', 'testdouble']
>>> mat_contents['testdouble']
array([[0\.        , 0.78539816, 1.57079633, 2.35619449, 3.14159265,
 3.92699082, 4.71238898, 5.49778714, 6.28318531]])

默认情况下，SciPy 将 MATLAB 结构体读取为结构化的 NumPy 数组，其中 dtype 字段为 object 类型，名称对应 MATLAB 结构体字段名称。可以通过设置可选参数 struct_as_record=False 来禁用此功能。

获取包含名为 teststruct 的 MATLAB 结构体的示例 .mat 文件的文件名并加载内容。

>>> matstruct_fname = pjoin(data_dir, 'teststruct_7.4_GLNX86.mat')
>>> matstruct_contents = sio.loadmat(matstruct_fname)
>>> teststruct = matstruct_contents['teststruct']
>>> teststruct.dtype
dtype([('stringfield', 'O'), ('doublefield', 'O'), ('complexfield', 'O')])

结构化数组的大小是 MATLAB 结构体的大小，而不是任何特定字段中元素的数量。除非设置可选参数 squeeze_me=True，否则形状默认为 2-D，此时将移除所有长度为 1 的维度。

>>> teststruct.size
1
>>> teststruct.shape
(1, 1)

获取 MATLAB 结构体中第一个元素的 'stringfield'。

>>> teststruct[0, 0]['stringfield']
array(['Rats live on no evil star.'],
 dtype='<U26')

获取 'doublefield' 的第一个元素。

>>> teststruct['doublefield'][0, 0]
array([[ 1.41421356,  2.71828183,  3.14159265]])

加载 MATLAB 结构体，压缩长度为 1 的维度，并获取 'complexfield' 的项。

>>> matstruct_squeezed = sio.loadmat(matstruct_fname, squeeze_me=True)
>>> matstruct_squeezed['teststruct'].shape
()
>>> matstruct_squeezed['teststruct']['complexfield'].shape
()
>>> matstruct_squeezed['teststruct']['complexfield'].item()
array([ 1.41421356+1.41421356j,  2.71828183+2.71828183j,
 3.14159265+3.14159265j])

`scipy.io.savemat`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.savemat.html#scipy.io.savemat

scipy.io.savemat(file_name, mdict, appendmat=True, format='5', long_field_names=False, do_compression=False, oned_as='row')

将名称和数组的字典保存到 MATLAB 格式的 .mat 文件中。

将给定字典中的数组对象保存到 MATLAB 格式的 .mat 文件中。

参数：

file_name 字符串或类似文件的对象

.mat 文件的名称（如果 appendmat == True，则不需要 .mat 扩展名）。也可以传递打开的类似文件的对象。

mdict 字典

要保存为 mat 文件变量的字典。

appendmat 布尔值，可选

True（默认值）表示如果文件名末尾没有.mat扩展名，则会将其附加到给定的文件名上。

format {‘5’, ‘4’}，字符串，可选

‘5’（默认值）适用于 MATLAB 5 及更高版本（至 7.2），‘4’ 适用于 MATLAB 4 .mat 文件。

long_field_names 布尔值，可选

False（默认值）- 结构体中字段名的最大长度为 31 个字符，这是记录的最大长度。True - 结构体中字段名的最大长度为 63 个字符，适用于 MATLAB 7.6+。

do_compression 布尔值，可选

写入时是否压缩矩阵。默认为 False。

oned_as {‘row’, ‘column’}，可选

如果为 ‘column’，将 1-D NumPy 数组写为列向量。如果为 ‘row’，将 1-D NumPy 数组写为行向量。

示例

>>> from scipy.io import savemat
>>> import numpy as np
>>> a = np.arange(20)
>>> mdic = {"a": a, "label": "experiment"}
>>> mdic
{'a': array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
 17, 18, 19]),
'label': 'experiment'}
>>> savemat("matlab_matrix.mat", mdic)

`scipy.io.whosmat`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.whosmat.html#scipy.io.whosmat

scipy.io.whosmat(file_name, appendmat=True, **kwargs)

列出 MATLAB 文件中的变量。

参数：

file_namestr

MAT 文件的名称（如果 appendmat==True，则不需要.mat 扩展名）。也可以传递打开的文件对象。

appendmatbool，可选

如果文件名末尾没有.mat 扩展名，则为 True，追加.mat 扩展名。默认为 True。

byte_orderstr 或 None，可选

默认情况下为 None，暗示从.mat 文件中猜测的字节顺序。否则可以是（'native'，'='，'little'，'<'，'BIG'，'>'）中的一个。

mat_dtypebool，可选

如果为 True，则返回与加载到 MATLAB 中的 dtype 相同的数组（而不是保存时的 dtype）。

squeeze_mebool，可选

是否压缩单位矩阵的维度。

chars_as_stringsbool，可选

是否将 char 数组转换为字符串数组。

matlab_compatiblebool，可选

返回矩阵，就像 MATLAB 加载的那样（意味着 squeeze_me=False，chars_as_strings=False，mat_dtype=True，struct_as_record=True）。

struct_as_recordbool，可选

是否将 MATLAB 结构加载为 NumPy 记录数组，或作为旧风格的 NumPy 数组（dtype=object）。将此标志设置为 False 可复制 SciPy 版本 0.7.x 的行为（返回 numpy 对象数组）。默认设置为 True，因为它允许更容易地往返加载和保存 MATLAB 文件。

variables元组列表

一个元组列表，每个元组包含矩阵名称（字符串）、其形状（整数元组）和其数据类（字符串）。可能的数据类有：int8、uint8、int16、uint16、int32、uint32、int64、uint64、single、double、cell、struct、object、char、sparse、function、opaque、logical、unknown。

注意

支持 v4（Level 1.0）、v6 和 v7 到 7.2 的 MAT 文件。

您将需要一个 HDF5 Python 库来读取 MATLAB 7.3 格式的.mat 文件（例如 h5py）。因为 SciPy 没有提供一个，所以我们在这里没有实现 HDF5 / 7.3 接口。

新增于版本 0.12.0。

示例

>>> from io import BytesIO
>>> import numpy as np
>>> from scipy.io import savemat, whosmat

创建一些数组，并使用savemat将它们写入BytesIO实例。

>>> a = np.array([[10, 20, 30], [11, 21, 31]], dtype=np.int32)
>>> b = np.geomspace(1, 10, 5)
>>> f = BytesIO()
>>> savemat(f, {'a': a, 'b': b})

使用whosmat来检查f。输出列表中的每个元组给出了f中数组的名称、形状和数据类型。

>>> whosmat(f)
[('a', (2, 3), 'int32'), ('b', (1, 5), 'double')]

`scipy.io.readsav`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.readsav.html#scipy.io.readsav

scipy.io.readsav(file_name, idict=None, python_dict=False, uncompressed_file_name=None, verbose=False)

读取一个 IDL .sav 文件。

参数：

file_namestr

IDL 保存文件的名称。

idictdict，可选

要插入.sav 文件变量的字典。

python_dictbool，可选

默认情况下，返回的对象不是一个 Python 字典，而是一个不区分大小写的字典，可以通过项目、属性和调用访问变量。要获得标准的 Python 字典，请将此选项设置为 True。

uncompressed_file_namestr，可选

此选项仅对使用/compress 选项编写的.sav 文件有效。如果指定了文件名，则压缩的.sav 文件将解压缩到该文件中。否则，readsav 将使用tempfile模块自动确定临时文件名，并在成功读取后删除临时文件。

verbosebool，可选

是否打印有关保存文件的信息，包括读取的记录和可用变量。

idl_dictAttrDict 或 dict

如果python_dict设置为 False（默认值），此函数将返回一个不区分大小写的字典，可以通过项目、属性和调用访问变量。如果python_dict设置为 True，则此函数将返回一个所有变量名称均为小写的 Python 字典。如果指定了idict，则将变量写入指定的字典，并返回更新后的字典。

示例

>>> from os.path import dirname, join as pjoin
>>> import scipy.io as sio
>>> from scipy.io import readsav

从 tests/data 目录中获取示例.sav 文件的文件名。

>>> data_dir = pjoin(dirname(sio.__file__), 'tests', 'data')
>>> sav_fname = pjoin(data_dir, 'array_float32_1d.sav')

加载.sav 文件内容。

>>> sav_data = readsav(sav_fname)

获取.sav 文件内容的键。

>>> print(sav_data.keys())
dict_keys(['array1d'])

使用键访问内容。

>>> print(sav_data['array1d'])
[0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0.
 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0.
 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0.
 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0.
 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0.
 0\. 0\. 0.]

`scipy.io.mminfo`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.mminfo.html#scipy.io.mminfo

scipy.io.mminfo(source)

从 Matrix Market 文件类似的 'source' 返回大小和存储参数。

参数：

sourcestr 或类文件对象

Matrix Market 文件名（扩展名 .mtx）或打开的类文件对象

rowsint

矩阵行数。

colsint

矩阵列数。

entriesint

稀疏矩阵的非零条目数或稠密矩阵的行数*列数。

formatstr

要么 'coordinate' 或 'array'。

fieldstr

要么 'real'、'complex'、'pattern' 或 'integer'。

symmetrystr

要么 'general'、'symmetric'、'skew-symmetric' 或 'hermitian'。

注意事项

1.12.0 版本更改：C++ 实现。

示例

>>> from io import StringIO
>>> from scipy.io import mminfo

>>> text = '''%%MatrixMarket matrix coordinate real general
...  5 5 7
...  2 3 1.0
...  3 4 2.0
...  3 5 3.0
...  4 1 4.0
...  4 2 5.0
...  4 3 6.0
...  4 4 7.0
... '''

mminfo(source) 返回源文件的行数、列数、格式、字段类型和对称属性。

>>> mminfo(StringIO(text))
(5, 5, 7, 'coordinate', 'real', 'general')

`scipy.io.mmread`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.mmread.html#scipy.io.mmread

scipy.io.mmread(source)

将 Matrix Market 文件类似的‘source’内容读入矩阵中。

参数：

source 字符串或类文件对象

Matrix Market 文件名（扩展名 .mtx, .mtz.gz）或打开的文件类对象。

a 数组或 coo_matrix

根据 Matrix Market 文件中的矩阵格式，返回密集或稀疏矩阵。

注意

在 1.12.0 版本中更改：采用 C++ 实现。

示例

>>> from io import StringIO
>>> from scipy.io import mmread

>>> text = '''%%MatrixMarket matrix coordinate real general
...  5 5 7
...  2 3 1.0
...  3 4 2.0
...  3 5 3.0
...  4 1 4.0
...  4 2 5.0
...  4 3 6.0
...  4 4 7.0
... '''

mmread(source) 返回 COO 格式的稀疏矩阵数据。

>>> m = mmread(StringIO(text))
>>> m
<5x5 sparse matrix of type '<class 'numpy.float64'>'
with 7 stored elements in COOrdinate format>
>>> m.A
array([[0., 0., 0., 0., 0.],
 [0., 0., 1., 0., 0.],
 [0., 0., 0., 2., 3.],
 [4., 5., 6., 7., 0.],
 [0., 0., 0., 0., 0.]])

此方法支持多线程。默认线程数等于系统中的 CPU 数量。使用 threadpoolctl 进行覆盖：

>>> import threadpoolctl
>>>
>>> with threadpoolctl.threadpool_limits(limits=2):
...     m = mmread(StringIO(text))

`scipy.io.mmwrite`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.mmwrite.html#scipy.io.mmwrite

scipy.io.mmwrite(target, a, comment=None, field=None, precision=None, symmetry='AUTO')

将稀疏或密集数组 a 写入类似 Matrix Market 文件的 target 中。

参数：

targetstr 或类文件对象

Matrix Market 文件名（扩展名为.mtx）或打开的类文件对象。

a类似数组

稀疏或密集的二维数组。

commentstr，可选

要添加到 Matrix Market 文件的注释。

fieldNone 或 str，可选

可选值为'real'、'complex'、'pattern'或'integer'。

precisionNone 或 int，可选

用于显示实数或复数值的位数。

symmetryNone 或 str，可选

可选值为'AUTO'、'general'、'symmetric'、'skew-symmetric'或'hermitian'。如果对称性为 None，则 'a' 的对称类型由其值确定。如果对称性为 'AUTO'，则 'a' 的对称类型将由mmwrite自行决定或设置为'general'。

None

注意事项

在版本 1.12.0 中更改：C++ 实现。

示例

>>> from io import BytesIO
>>> import numpy as np
>>> from scipy.sparse import coo_matrix
>>> from scipy.io import mmwrite

将小型 NumPy 数组写入 Matrix Market 文件。文件将以 'array' 格式写入。

>>> a = np.array([[1.0, 0, 0, 0], [0, 2.5, 0, 6.25]])
>>> target = BytesIO()
>>> mmwrite(target, a)
>>> print(target.getvalue().decode('latin1'))
%%MatrixMarket matrix array real general
%
2 4
1
0
0
2.5
0
0
0
6.25

向输出文件添加注释，并将精度设置为 3。

>>> target = BytesIO()
>>> mmwrite(target, a, comment='\n Some test data.\n', precision=3)
>>> print(target.getvalue().decode('latin1'))
%%MatrixMarket matrix array real general
%
% Some test data.
%
2 4
1.00e+00
0.00e+00
0.00e+00
2.50e+00
0.00e+00
0.00e+00
0.00e+00
6.25e+00

在调用mmwrite之前将其转换为稀疏矩阵。这将导致输出格式为'coordinate'而不是'array'。

>>> target = BytesIO()
>>> mmwrite(target, coo_matrix(a), precision=3)
>>> print(target.getvalue().decode('latin1'))
%%MatrixMarket matrix coordinate real general
%
2 4 3
1 1 1.00e+00
2 2 2.50e+00
2 4 6.25e+00

将复数 Hermite 数组写入 Matrix Market 文件。请注意，实际只有六个值写入文件；其余值由对称性隐含。

>>> z = np.array([[3, 1+2j, 4-3j], [1-2j, 1, -5j], [4+3j, 5j, 2.5]])
>>> z
array([[ 3\. +0.j,  1\. +2.j,  4\. -3.j],
 [ 1\. -2.j,  1\. +0.j, -0\. -5.j],
 [ 4\. +3.j,  0\. +5.j,  2.5+0.j]])

>>> target = BytesIO()
>>> mmwrite(target, z, precision=2)
>>> print(target.getvalue().decode('latin1'))
%%MatrixMarket matrix array complex hermitian
%
3 3
3.0e+00 0.0e+00
1.0e+00 -2.0e+00
4.0e+00 3.0e+00
1.0e+00 0.0e+00
0.0e+00 5.0e+00
2.5e+00 0.0e+00

此方法是线程化的。默认线程数等于系统中的 CPU 数量。使用threadpoolctl来覆盖：

>>> import threadpoolctl
>>>
>>> target = BytesIO()
>>> with threadpoolctl.threadpool_limits(limits=2):
...     mmwrite(target, a)

`scipy.io.FortranFile`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.FortranFile.html#scipy.io.FortranFile

class scipy.io.FortranFile(filename, mode='r', header_dtype=<class 'numpy.uint32'>)

用于从 Fortran 代码获取无格式顺序文件的文件对象。

参数：

filename文件或字符串

打开的文件对象或文件名。

mode，可选

读写模式，默认为‘r’。

header_dtypedtype，可选

头部的数据类型。大小和字节序必须与输入/输出文件匹配。

注意

这些文件被分解为未指定类型的记录。每个记录的大小在开始时给出（尽管此标题的大小不是标准的），并且数据以没有任何格式的方式写入磁盘。支持 BACKSPACE 语句的 Fortran 编译器将写入第二个大小的副本以便进行向后查找。

该类仅支持同时写入记录大小的文件。它还不支持 Intel 和 gfortran 编译器中用于大于 2GB 的记录的子记录，这些记录具有 4 字节头部。

在 Fortran 中，无格式的顺序文件的示例将会写为：

OPEN(1, FILE=myfilename, FORM='unformatted')

WRITE(1) myvariable

由于这是一种非标准的文件格式，其内容取决于编译器和机器的字节序，因此建议小心。已知适用于 x86_64 上的 gfortran 4.8.0 和 gfortran 4.1.2 生成的文件。

考虑使用 Fortran 直接访问文件或来自新 Stream I/O 的文件，这些文件可以轻松地被numpy.fromfile读取。

示例

要创建一个无格式的顺序 Fortran 文件：

>>> from scipy.io import FortranFile
>>> import numpy as np
>>> f = FortranFile('test.unf', 'w')
>>> f.write_record(np.array([1,2,3,4,5], dtype=np.int32))
>>> f.write_record(np.linspace(0,1,20).reshape((5,4)).T)
>>> f.close()

要读取此文件：

>>> f = FortranFile('test.unf', 'r')
>>> print(f.read_ints(np.int32))
[1 2 3 4 5]
>>> print(f.read_reals(float).reshape((5,4), order="F"))
[[0\.         0.05263158 0.10526316 0.15789474]
 [0.21052632 0.26315789 0.31578947 0.36842105]
 [0.42105263 0.47368421 0.52631579 0.57894737]
 [0.63157895 0.68421053 0.73684211 0.78947368]
 [0.84210526 0.89473684 0.94736842 1\.        ]]
>>> f.close()

或者，在 Fortran 中：

integer :: a(5), i
double precision :: b(5,4)
open(1, file='test.unf', form='unformatted')
read(1) a
read(1) b
close(1)
write(*,*) a
do i = 1, 5
    write(*,*) b(i,:)
end do

方法

`close`()	关闭文件。
`read_ints`([dtype])	从文件中读取给定类型的记录，默认为整数类型（Fortran 中的 `INTEGER*4`）。
`read_reals`([dtype])	从文件中读取给定类型的记录，默认为浮点数（Fortran 中的 `real*8`）。
`read_record`(dtypes, *kwargs)	从文件中读取给定类型的记录。
`write_record`(*items)	向文件中写入记录（包括大小）。

`scipy.io.FortranEOFError`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.FortranEOFError.html#scipy.io.FortranEOFError

exception scipy.io.FortranEOFError

表示文件已经正确结束。

这个错误源自于 TypeError，因为代码用于引发 TypeError（这是唯一的方法来知道文件已经结束），所以用户可能会有except TypeError:。

errno

POSIX 异常代码

filename

异常的文件名

filename2

第二个异常的文件名

strerror

异常 strerror

with_traceback()

Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。

`scipy.io.FortranFormattingError`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.FortranFormattingError.html#scipy.io.FortranFormattingError

exception scipy.io.FortranFormattingError

表明文件在记录中途结束。

派生自 TypeError 以保持向后兼容性。

errno

POSIX 异常代码

filename

异常 filename

filename2

第二个异常 filename

strerror

异常 strerror

with_traceback()

Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。

`scipy.io.netcdf_file`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.netcdf_file.html#scipy.io.netcdf_file

class scipy.io.netcdf_file(filename, mode='r', mmap=None, version=1, maskandscale=False)

用于 NetCDF 数据的文件对象。

netcdf_file对象具有两个标准属性：dimensions和variables。两者的值都是字典，将维度名称映射到其相关长度和将变量名称映射到变量。

所有其他属性对应于 NetCDF 文件中定义的全局属性。全局文件属性是通过将netcdf_file对象的属性赋值而创建的。

参数：

文件名字符串或类文件

字符串 -> 文件名

模式，可选

读写追加模式，默认为‘r’

内存映射无或布尔值，可选

是否在读取时将文件名进行内存映射。当文件名是文件名时，默认为 True，当文件名是类文件对象时，默认为 False。请注意，当使用内存映射时，返回的数据数组直接引用磁盘上的 mmapped 数据，并且只要存在对它的引用，文件就不能关闭。

版本，可选

NetCDF 版本读取/写入，其中 1 表示经典格式，2 表示64 位偏移格式。默认为 1。详细信息请参阅此处。

掩码和缩放布尔值，可选

是否根据属性自动缩放和/或掩码数据。默认值为 False。

注意事项

该模块相对于其他模块的主要优势在于，它不需要代码链接到 NetCDF 库。该模块源自pupynere。

NetCDF 文件是一种自描述的二进制数据格式。该文件包含描述文件中维度和变量的元数据。关于 NetCDF 文件的更多细节可以在这里找到。NetCDF 数据结构有三个主要部分：

尺寸
变量
属性

尺寸部分记录了每个变量使用的每个维度的名称和长度。然后，变量将指示它使用的维度以及诸如数据单位的任何属性，同时包含变量的数据值。包含与轴的变量相同名称的变量是一个好的实践，以提供该轴的值。最后，属性部分将包含额外的信息，例如文件创建者的名称或用于收集数据的仪器。

在向 NetCDF 文件写入数据时，通常需要指定“记录维度”。记录维度是变量的无界维度。例如，温度变量可能具有纬度、经度和时间的维度。如果想要在时间推移时向 NetCDF 文件添加更多温度数据，则应将时间维度标记为记录维度。

此外，NetCDF 文件头包含文件中数据的位置，因此可以在不将不必要的数据加载到内存中的情况下有效访问。它使用mmap模块将 Numpy 数组映射到磁盘上的数据，以实现相同的目的。

注意，当使用netcdf_file以 mmap=True（只读模式的默认值）打开文件时，由其返回的数组直接引用磁盘上的数据。文件不应关闭，并且如果这些数组仍在使用，则无法在请求时完全关闭。如果需要在文件关闭后处理这些数组，则可能需要复制从内存映射 Netcdf 文件获取的数据数组，请参见下面的示例。

示例

创建 NetCDF 文件：

>>> from scipy.io import netcdf_file
>>> import numpy as np
>>> f = netcdf_file('simple.nc', 'w')
>>> f.history = 'Created for a test'
>>> f.createDimension('time', 10)
>>> time = f.createVariable('time', 'i', ('time',))
>>> time[:] = np.arange(10)
>>> time.units = 'days since 2008-01-01'
>>> f.close()

注意将arange(10)赋给time[:]。暴露时间变量的切片允许在对象中设置数据，而不是让arange(10)覆盖time变量。

读取刚创建的 NetCDF 文件：

>>> from scipy.io import netcdf_file
>>> f = netcdf_file('simple.nc', 'r')
>>> print(f.history)
b'Created for a test'
>>> time = f.variables['time']
>>> print(time.units)
b'days since 2008-01-01'
>>> print(time.shape)
(10,)
>>> print(time[-1])
9

当以只读方式打开 NetCDF 文件时，返回的数组直接引用磁盘上内存映射的数据：

>>> data = time[:]

如果需要在文件关闭后处理数据，则需要将其复制到主内存中：

>>> data = time[:].copy()
>>> del time
>>> f.close()
>>> data.mean()
4.5

NetCDF 文件也可以用作上下文管理器：

>>> from scipy.io import netcdf_file
>>> with netcdf_file('simple.nc', 'r') as f:
...     print(f.history)
b'Created for a test'

方法

`close`()	关闭 NetCDF 文件。
`createDimension`(name, length)	将一个维度添加到 NetCDF 数据结构的 Dimension 部分。
`createVariable`(name, type, dimensions)	为`netcdf_file`对象创建一个空变量，指定其数据类型和使用的维度。
`flush`()	如果`netcdf_file`对象处于写入模式，则执行同步到磁盘的刷新操作。
`sync`()	如果`netcdf_file`对象处于写入模式，则执行同步到磁盘的刷新操作。

`scipy.io.netcdf_variable`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.netcdf_variable.html#scipy.io.netcdf_variable

class scipy.io.netcdf_variable(data, typecode, size, shape, dimensions, attributes=None, maskandscale=False)

一个用于 netcdf 文件的数据对象。

netcdf_variable 对象是通过调用 netcdf_file.createVariable 方法在 netcdf_file 对象上构造的。netcdf_variable 对象的行为类似于 numpy 中定义的数组对象，不同之处在于它们的数据存储在文件中。通过索引读取数据，并通过分配给索引子集来写入数据；可以通过索引 [:] 访问整个数组，或者（对于标量）使用 getValue 和 assignValue 方法。netcdf_variable 对象还具有名为 shape 的属性，其含义与数组相同，但形状不可修改。还有一个只读属性 dimensions，其值是维度名称的元组，顺序与给定的 shape 中的长度相同。

所有其他属性对应于在 NetCDF 文件中定义的变量属性。通过将属性赋给 netcdf_variable 对象的属性来创建变量属性。

参数：

data 类似数组

保存变量值的数据数组。通常情况下，这是空初始化的，但具有适当的形状。

typecode dtype 字符代码

数据数组的期望数据类型。

size 整数

数据数组的期望元素大小。

shape 一组整数

数组的形状，应与变量维度的长度匹配。

dimensions 一组字符串

变量使用的维度名称。必须与 shape 中给出的维度长度的顺序相同。

attributes 字典，可选

属性值（任何类型），由字符串名称键入。这些属性成为 netcdf_variable 对象的属性。

maskandscale 布尔值，可选

根据属性自动缩放和/或屏蔽数据的选项。默认为 False。

参见

isrec, shape

属性:

dimensionslist of str

变量对象使用的维度名称列表。

isrec, shape

属性

方法

`assignValue`(value)	给长度为一的`netcdf_variable`分配标量值。
`getValue`()	从长度为一的`netcdf_variable`中检索标量值。
`itemsize`()	返回变量的项目大小。
`typecode`()	返回变量的类型代码。
getitem

`scipy.io.hb_read`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.hb_read.html#scipy.io.hb_read

scipy.io.hb_read(path_or_open_file)

读取 HB 格式文件。

参数：

path_or_open_file路径或打开的文件

如果是文件样式对象，则直接使用。否则，在读取之前将其打开。

datascipy.sparse.csc_matrix 实例

从 HB 文件中读取的稀疏矩阵数据。

注释

目前不支持完整的 Harwell-Boeing 格式。支持的功能包括：

组装的、非对称的、实数矩阵

指针/索引的整数

浮点数值的指数格式和整数格式

示例

我们可以读取和写入 Harwell-Boeing 格式文件：

>>> from scipy.io import hb_read, hb_write
>>> from scipy.sparse import csr_matrix, eye
>>> data = csr_matrix(eye(3))  # create a sparse matrix
>>> hb_write("data.hb", data)  # write a hb file
>>> print(hb_read("data.hb"))  # read a hb file
 (0, 0)    1.0
 (1, 1)    1.0
 (2, 2)    1.0

`scipy.io.hb_write`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.hb_write.html#scipy.io.hb_write

scipy.io.hb_write(path_or_open_file, m, hb_info=None)

写入 HB 格式文件。

参数：

path_or_open_file路径或类似文件

如果是类似文件的对象，则使用原样。否则，在写入前打开。

m稀疏矩阵

要写入的稀疏矩阵

hb_infoHBInfo

包含写入元数据

None

注意事项

目前不支持完整的 Harwell-Boeing 格式。支持的特性包括：

组装的、非对称的、实数矩阵

指针/索引的整数

浮点值的指数格式和整数格式

示例

我们可以读取和写入 Harwell-Boeing 格式文件：

>>> from scipy.io import hb_read, hb_write
>>> from scipy.sparse import csr_matrix, eye
>>> data = csr_matrix(eye(3))  # create a sparse matrix
>>> hb_write("data.hb", data)  # write a hb file
>>> print(hb_read("data.hb"))  # read a hb file
 (0, 0)    1.0
 (1, 1)    1.0
 (2, 2)    1.0

`scipy.io.wavfile.read`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.wavfile.read.html#scipy.io.wavfile.read

scipy.io.wavfile.read(filename, mmap=False)

打开一个 WAV 文件。

返回 LPCM WAV 文件的采样率（以样本/秒为单位）和数据。

参数：

filename字符串或打开的文件句柄

输入 WAV 文件。

mmapbool，可选

是否将数据读取为内存映射（默认值：False）。与某些位深度不兼容；请参阅注释。仅适用于真实文件。

0.12.0 版本中的新功能。

rateint

WAV 文件的采样率。

datanumpy 数组

从 WAV 文件读取的数据。数据类型由文件确定；请参阅注释。对于 1 通道 WAV，数据为 1-D，否则为形状为 (Nsamples, Nchannels) 的 2-D。如果传递了类似文件的输入而没有类似 C 的文件描述符（例如 io.BytesIO)，则此数据不可写。

注释

常见数据类型：[1]

WAV 格式	最小值	最大值	NumPy 数据类型
32 位浮点数	-1.0	+1.0	float32
32 位整数 PCM	-2147483648	+2147483647	int32
24 位整数 PCM	-2147483648	+2147483392	int32
16 位整数 PCM	-32768	+32767	int16
8 位整数 PCM	0	255	uint8

WAV 文件可以指定任意位深度，并且此函数支持从 1 到 64 位的任何整数 PCM 深度的读取。数据以最小兼容的 numpy int 类型返回，左对齐格式。8 位及以下为无符号，9 位及以上为有符号。

例如，24 位数据将以 int32 存储，其中 24 位数据的 MSB 存储在 int32 的 MSB 处，通常最不重要的字节为 0x00. （但是，如果文件实际包含超出指定位深度的数据，这些位也将被读取和输出。[2]）

此位对齐和符号匹配 WAV 的本机内部格式，允许内存映射使用每个样本 1、2、4 或 8 字节（因此 24 位文件不能进行内存映射，但 32 位可以）。

支持的 IEEE 浮点 PCM 格式为 32 位或 64 位，带有或不带有 mmap。超出 [-1, +1] 范围的值不会被剪切。

不支持非线性 PCM（mu-law, A-law）。

参考资料

[1]

IBM Corporation 和 Microsoft Corporation，“多媒体编程接口和数据规范 1.0”，第“样本数据格式”章节，1991 年 8 月 www.tactilemedia.com/info/MCI_Control_Info.html

[2]

Adobe Systems Incorporated，“Adobe Audition 3 用户指南”，第“音频文件格式：24 位打包整数（类型 1, 20 位）”章节，2007 年

示例

>>> from os.path import dirname, join as pjoin
>>> from scipy.io import wavfile
>>> import scipy.io

从 tests/data 目录中获取一个示例 .wav 文件的文件名。

>>> data_dir = pjoin(dirname(scipy.io.__file__), 'tests', 'data')
>>> wav_fname = pjoin(data_dir, 'test-44100Hz-2ch-32bit-float-be.wav')

加载 .wav 文件内容。

>>> samplerate, data = wavfile.read(wav_fname)
>>> print(f"number of channels = {data.shape[1]}")
number of channels = 2
>>> length = data.shape[0] / samplerate
>>> print(f"length = {length}s")
length = 0.01s

绘制波形。

>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> time = np.linspace(0., length, data.shape[0])
>>> plt.plot(time, data[:, 0], label="Left channel")
>>> plt.plot(time, data[:, 1], label="Right channel")
>>> plt.legend()
>>> plt.xlabel("Time [s]")
>>> plt.ylabel("Amplitude")
>>> plt.show()

../../_images/scipy-io-wavfile-read-1.png

`scipy.io.wavfile.write`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.wavfile.write.html#scipy.io.wavfile.write

scipy.io.wavfile.write(filename, rate, data)

将 NumPy 数组写入 WAV 文件。

参数：

filenamestring 或打开的文件句柄

输出 wav 文件。

rateint

采样率（每秒样本数）。

datandarray

一个一维或二维的 NumPy 数组，可以是整数或浮点数数据类型。

注意事项

写入一个简单的未压缩 WAV 文件。
若要写入多声道数据，请使用形状为 (Nsamples, Nchannels) 的二维数组。
位深和 PCM/浮点数将由数据类型确定。

常见数据类型：[1]

WAV 格式	最小值	最大值	NumPy 数据类型
32 位浮点数	-1.0	+1.0	float32
32 位 PCM	-2147483648	+2147483647	int32
16 位 PCM	-32768	+32767	int16
8 位 PCM	0	255	uint8

请注意，8 位 PCM 是无符号的。

参考文献

[1]

IBM 公司和微软公司，“多媒体编程接口和数据规范 1.0”，章节“样本的数据格式”，1991 年 8 月 www.tactilemedia.com/info/MCI_Control_Info.html

示例

创建一个 100Hz 正弦波，采样率为 44100Hz。写入 16 位 PCM，单声道。

>>> from scipy.io.wavfile import write
>>> import numpy as np
>>> samplerate = 44100; fs = 100
>>> t = np.linspace(0., 1., samplerate)
>>> amplitude = np.iinfo(np.int16).max
>>> data = amplitude * np.sin(2. * np.pi * fs * t)
>>> write("example.wav", samplerate, data.astype(np.int16))

`scipy.io.wavfile.WavFileWarning`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.wavfile.WavFileWarning.html#scipy.io.wavfile.WavFileWarning

exception scipy.io.wavfile.WavFileWarning

with_traceback()

Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。

`scipy.io.arff.loadarff`

原始文档：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.arff.loadarff.html#scipy.io.arff.loadarff

scipy.io.arff.loadarff(f)

读取 ARFF 文件。

数据以记录数组的形式返回，可以像 NumPy 数组的字典一样访问。例如，如果其中一个属性称为“pressure”，则可以从 data 记录数组中访问其前 10 个数据点，如此：data['pressure'][0:10]

参数：

f 类似文件或字符串

用于读取的类文件对象或要打开的文件名。

data 记录数组

ARFF 文件的数据可通过属性名访问。

meta MetaData

包含 ARFF 文件的信息，如属性的名称和类型，关系（数据集的名称），等等。

引发：

ParseArffError

如果给定文件不符合 ARFF 格式，则会引发此错误。

NotImplementedError

ARFF 文件包含一个尚不支持的属性。

注意事项

此函数应能读取大多数 ARFF 文件。未实现的功能包括：

日期类型的属性
字符串类型的属性

它可以读取具有数值和名义属性的文件。但无法读取稀疏数据的文件（文件中的{}）。然而，此函数可以读取文件中具有缺失数据（文件中的?），将数据点表示为 NaN。

示例

>>> from scipy.io import arff
>>> from io import StringIO
>>> content = """
... @relation foo
... @attribute width  numeric
... @attribute height numeric
... @attribute color  {red,green,blue,yellow,black}
... @data
... 5.0,3.25,blue
... 4.5,3.75,green
... 3.0,4.00,red
... """
>>> f = StringIO(content)
>>> data, meta = arff.loadarff(f)
>>> data
array([(5.0, 3.25, 'blue'), (4.5, 3.75, 'green'), (3.0, 4.0, 'red')],
 dtype=[('width', '<f8'), ('height', '<f8'), ('color', '|S6')])
>>> meta
Dataset: foo
 width's type is numeric
 height's type is numeric
 color's type is nominal, range is ('red', 'green', 'blue', 'yellow', 'black')

`scipy.io.arff.MetaData`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.arff.MetaData.html#scipy.io.arff.MetaData

class scipy.io.arff.MetaData(rel, attr)

一个小容器，用于保存 ARFF 数据集的有用信息。

知道属性的名称和类型。

笔记

也维护属性列表的顺序，即对于 meta 中的每个 i，其中 meta 是 MetaData 的一个实例，将按定义顺序返回不同的属性名。

示例

data, meta = loadarff('iris.arff')
# This will print the attributes names of the iris.arff dataset
for i in meta:
    print(i)
# This works too
meta.names()
# Getting attribute type
types = meta.types()

方法

`names`()	返回属性名的列表。
`types`()	返回属性类型的列表。

`scipy.io.arff.ArffError`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.arff.ArffError.html#scipy.io.arff.ArffError

exception scipy.io.arff.ArffError

errno

POSIX 异常代码

filename

异常文件名

filename2

第二个异常文件名

strerror

异常错误描述

with_traceback()

Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self.

`scipy.io.arff.ParseArffError`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.io.arff.ParseArffError.html#scipy.io.arff.ParseArffError

exception scipy.io.arff.ParseArffError

errno

POSIX 异常代码

filename

异常文件名

filename2

第二异常文件名

strerror

异常 strerror

with_traceback()

Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。

线性代数（`scipy.linalg`）

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

线性代数函数。

另请参见：

numpy.linalg，获取更多线性代数函数。请注意，虽然scipy.linalg导入了大部分函数，但scipy.linalg中的同名函数可能提供更多或稍有不同的功能。

基础

`inv`(a[, overwrite_a, check_finite])	计算矩阵的逆。
`solve`(a, b[, lower, overwrite_a, ...])	解线性方程组 `a @ x == b`，求未知数`x`，其中 a 为方阵。
`solve_banded`(l_and_u, ab, b[, overwrite_ab, ...])	解方程 a x = b，假设 a 为带状矩阵。
`solveh_banded`(ab, b[, overwrite_ab, ...])	解方程 a x = b。
`solve_circulant`(c, b[, singular, tol, ...])	解 C x = b，其中 C 为循环矩阵。
`solve_triangular`(a, b[, trans, lower, ...])	解方程a x = b，假设 a 是上（或下）三角矩阵。
`solve_toeplitz`(c_or_cr, b[, check_finite])	使用 Levinson 递归解 Toeplitz 系统。
`matmul_toeplitz`(c_or_cr, x[, check_finite, ...])	使用 FFT 高效计算 Toeplitz 矩阵乘法
`det`(a[, overwrite_a, check_finite])	计算矩阵的行列式。
`norm`(a[, ord, axis, keepdims, check_finite])	矩阵或向量范数。
`lstsq`(a, b[, cond, overwrite_a, ...])	计算方程 Ax = b 的最小二乘解。
`pinv`(a, *[, atol, rtol, return_rank, ...])	计算矩阵的（Moore-Penrose）伪逆。
`pinvh`(a[, atol, rtol, lower, return_rank, ...])	计算 Hermitian 矩阵的（Moore-Penrose）伪逆。
`kron`(a, b)	克罗内克积。
`khatri_rao`(a, b)	Khatri-Rao 积。
`tril`(m[, k])

自版本 1.11.0 起已弃用。

`triu`(m[, k])

自版本 1.11.0 起已弃用。

`orthogonal_procrustes`(A, B[, check_finite])	计算正交 Procrustes 问题的矩阵解。
`matrix_balance`(A[, permute, scale, ...])	计算用于行/列平衡的对角相似性变换。
`subspace_angles`(A, B)	计算两个矩阵之间的子空间角。
`bandwidth`(a)	返回 2D 数值数组的下界和上界带宽。
`issymmetric`(a[, atol, rtol])	检查方形 2D 数组是否对称。
`ishermitian`(a[, atol, rtol])	检查方形 2D 数组是否 Hermitian。
`LinAlgError`	由 linalg 函数引发的通用 Python 异常派生对象。
`LinAlgWarning`	在线性代数相关操作接近失败条件或预计丢失精度时发出的警告。

特征值问题

`eig`(a[, b, left, right, overwrite_a, ...])	解决方形矩阵的普通或广义特征值问题。
`eigvals`(a[, b, overwrite_a, check_finite, ...])	计算普通或广义特征值问题的特征值。
`eigh`(a[, b, lower, eigvals_only, ...])	解决复 Hermitian 或实对称矩阵的标准或广义特征值问题。
`eigvalsh`(a[, b, lower, overwrite_a, ...])	解决复埃尔米特或实对称矩阵的标准或广义特征值问题。
`eig_banded`(a_band[, lower, eigvals_only, ...])	解决实对称或复共轭埃尔米特带状矩阵的特征值问题。
`eigvals_banded`(a_band[, lower, ...])	解决实对称或复共轭埃尔米特带状矩阵的特征值问题。
`eigh_tridiagonal`(d, e[, eigvals_only, ...])	解决实对称三对角矩阵的特征值问题。
`eigvalsh_tridiagonal`(d, e[, select, ...])	解决实对称三对角矩阵的特征值问题。

Decompositions

`lu`(a[, permute_l, overwrite_a, ...])	计算带部分选点的矩阵的 LU 分解。
`lu_factor`(a[, overwrite_a, check_finite])	计算矩阵的带有置换的 LU 分解。
`lu_solve`(lu_and_piv, b[, trans, ...])	给定矩阵的 LU 分解，解方程系统 a x = b。
`svd`(a[, full_matrices, compute_uv, ...])	奇异值分解。
`svdvals`(a[, overwrite_a, check_finite])	计算矩阵的奇异值。
`diagsvd`(s, M, N)	根据奇异值和大小 M，N 构造 SVD 中的 sigma 矩阵。
`orth`(A[, rcond])	使用 SVD 构造矩阵 A 的范围的标准正交基
`null_space`(A[, rcond])	使用 SVD 构造矩阵 A 的零空间的标准正交基
`ldl`(A[, lower, hermitian, overwrite_a, ...])	计算对称/埃尔米特矩阵的 LDLt 或 Bunch-Kaufman 分解。
`cholesky`(a[, lower, overwrite_a, check_finite])	计算矩阵的 Cholesky 分解。
`cholesky_banded`(ab[, overwrite_ab, lower, ...])	Cholesky 分解带状埃尔米特正定矩阵。
`cho_factor`(a[, lower, overwrite_a, check_finite])	计算矩阵的 Cholesky 分解，用于 cho_solve。
`cho_solve`(c_and_lower, b[, overwrite_b, ...])	给定矩阵 A 的 Cholesky 分解，解线性方程 `A x = b`。
`cho_solve_banded`(cb_and_lower, b[, ...])	给定带状埃尔米特矩阵 A 的 Cholesky 分解，解线性方程 `A x = b`。
`polar`(a[, side])	计算极分解。
`qr`(a[, overwrite_a, lwork, mode, pivoting, ...])	计算矩阵的 QR 分解。
`qr_multiply`(a, c[, mode, pivoting, ...])	计算 QR 分解并将 Q 与矩阵相乘。
`qr_update`(Q, R, u, v[, overwrite_qruv, ...])	Rank-k QR 更新。
`qr_delete`(Q, R, k, int p=1[, which, ...])	在行或列删除上进行 QR 降级。
`qr_insert`(Q, R, u, k[, which, rcond, ...])	在行或列插入上进行 QR 更新。
`rq`(a[, overwrite_a, lwork, mode, check_finite])	计算矩阵的 RQ 分解。
`qz`(A, B[, output, lwork, sort, overwrite_a, ...])	对一对矩阵进行广义特征值的 QZ 分解。
`ordqz`(A, B[, sort, output, overwrite_a, ...])	对一对矩阵进行重新排序的 QZ 分解。
`schur`(a[, output, lwork, overwrite_a, sort, ...])	计算矩阵的 Schur 分解。
`rsf2csf`(T, Z[, check_finite])	将实 Schur 形式转换为复数 Schur 形式。
`hessenberg`(a[, calc_q, overwrite_a, ...])	计算矩阵的 Hessenberg 形式。
`cdf2rdf`(w, v)	将复特征值`w`和特征向量`v`转换为块对角形式中的实特征值`wr`和相应的实特征向量`vr`，使得。
`cossin`(X[, p, q, separate, swap_sign, ...])	计算正交/酉矩阵的余弦-正弦（CS）分解。

另请参阅

scipy.linalg.interpolative – 插值矩阵分解

矩阵函数

`expm`(A)	计算数组的矩阵指数。
`logm`(A[, disp])	计算矩阵的对数。
`cosm`(A)	计算矩阵的余弦。
`sinm`(A)	计算矩阵的正弦。
`tanm`(A)	计算矩阵的正切。
`coshm`(A)	计算矩阵的双曲余弦。
`sinhm`(A)	计算矩阵的双曲正弦。
`tanhm`(A)	计算矩阵的双曲正切。
`signm`(A[, disp])	矩阵的符号函数。
`sqrtm`(A[, disp, blocksize])	矩阵的平方根。
`funm`(A, func[, disp])	评估由可调用函数指定的矩阵函数。
`expm_frechet`(A, E[, method, compute_expm, ...])	A 在方向 E 上的矩阵指数的 Frechet 导数。
`expm_cond`(A[, check_finite])	矩阵指数在 Frobenius 范数下的相对条件数。
`fractional_matrix_power`(A, t)	计算矩阵的分数幂。

矩阵方程求解器

`solve_sylvester`(a, b, q)	计算 Sylvester 方程(AX + XB = Q)的解（X）。
`solve_continuous_are`(a, b, q, r[, e, s, ...])	解决连续时间代数 Riccati 方程（CARE）。
`solve_discrete_are`(a, b, q, r[, e, s, balanced])	解决离散时间代数 Riccati 方程（DARE）。
`solve_continuous_lyapunov`(a, q)	解决连续 Lyapunov 方程(AX + XA^H = Q)。
`solve_discrete_lyapunov`(a, q[, method])	解决离散 Lyapunov 方程(AXA^H - X + Q = 0)。

草图和随机投影

`clarkson_woodruff_transform`(input_matrix, ...)	对输入矩阵应用 Clarkson-Woodruff 变换/草图。

特殊矩阵

`block_diag`(*arrs)	从提供的数组创建一个分块对角矩阵。
`circulant`(c)	构造循环矩阵。
`companion`(a)	创建一个伴随矩阵。
`convolution_matrix`(a, n[, mode])	构造一个卷积矩阵。
`dft`(n[, scale])	离散傅里叶变换矩阵。
`fiedler`(a)	返回一个对称的 Fiedler 矩阵
`fiedler_companion`(a)	返回一个 Fiedler 伴随矩阵
`hadamard`(n[, dtype])	构造一个 Hadamard 矩阵。
`hankel`(c[, r])	构造 Hankel 矩阵。
`helmert`(n[, full])	创建阶数为n的 Helmert 矩阵。
`hilbert`(n)	创建阶为 n 的 Hilbert 矩阵。
`invhilbert`(n[, exact])	计算阶为 n 的 Hilbert 矩阵的逆矩阵。
`leslie`(f, s)	创建 Leslie 矩阵。
`pascal`(n[, kind, exact])	返回 n x n Pascal 矩阵。
`invpascal`(n[, kind, exact])	返回 n x n Pascal 矩阵的逆矩阵。
`toeplitz`(c[, r])	构造一个 Toeplitz 矩阵。
`tri`(N[, M, k, dtype])	构造一个三角矩阵。

自版本 1.11.0 起不推荐使用。

低级例程

`get_blas_funcs`(names[, arrays, dtype, ilp64])	返回指定名称的可用 BLAS 函数对象。
`get_lapack_funcs`(names[, arrays, dtype, ilp64])	返回指定名称的可用 LAPACK 函数对象。
`find_best_blas_type`([arrays, dtype])	查找最佳匹配的 BLAS/LAPACK 类型。

另请参阅

scipy.linalg.blas – 低级 BLAS 函数

scipy.linalg.lapack – 低级 LAPACK 函数

scipy.linalg.cython_blas – 用于 Cython 的低级 BLAS 函数

scipy.linalg.cython_lapack – 用于 Cython 的低级 LAPACK 函数

`scipy.linalg.inv`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.inv.html#scipy.linalg.inv

scipy.linalg.inv(a, overwrite_a=False, check_finite=True)

计算矩阵的逆。

参数：

aarray_like

要求逆的方阵。

overwrite_abool，可选

丢弃a中的数据（可能提高性能）。默认为 False。

check_finitebool，可选

是否检查输入矩阵是否仅包含有限数。禁用可能会提高性能，但如果输入包含无穷大或 NaN，可能会导致问题（崩溃、非终止）。

ainvndarray

矩阵a的逆。

抛出异常：

LinAlgError

如果a是奇异的。

ValueError

如果a不是方阵，或不是 2D。

示例

>>> import numpy as np
>>> from scipy import linalg
>>> a = np.array([[1., 2.], [3., 4.]])
>>> linalg.inv(a)
array([[-2\. ,  1\. ],
 [ 1.5, -0.5]])
>>> np.dot(a, linalg.inv(a))
array([[ 1.,  0.],
 [ 0.,  1.]])

`scipy.linalg.solve`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.solve.html#scipy.linalg.solve

scipy.linalg.solve(a, b, lower=False, overwrite_a=False, overwrite_b=False, check_finite=True, assume_a='gen', transposed=False)

解决方程组 a @ x == b 中未知数 x 的方形 a 矩阵。

如果数据矩阵已知为特定类型，则将相应的字符串供应给 assume_a 键选择专用求解器。可用选项为

通用矩阵	‘gen’
对称	‘sym’
共轭转置	‘her’
正定	‘pos’

如果省略，'gen' 是默认结构。

数组的数据类型定义了调用哪个求解器，而不考虑值。换句话说，即使复数数组条目具有精确的零虚部，也将基于数组的数据类型调用复数求解器。

参数：

a(N, N) 数组型

方形输入数据

b(N, NRHS) 数组型

右侧的输入数据。

lowerbool，默认值：假

如果 assume_a == 'gen'（默认）。如果为真，则计算仅使用 a 的下三角数据；忽略对角线上方的条目。如果为假（默认），则计算仅使用 a 的上三角数据；忽略对角线以下的条目。

overwrite_abool，默认值：假

允许覆盖 a 中的数据（可能提升性能）。

overwrite_bbool，默认值：假

允许覆盖 b 中的数据（可能提升性能）。

check_finitebool，默认值：真

是否检查输入矩阵仅包含有限数字。禁用可能会带来性能增益，但如果输入确实包含无穷大或 NaN，则可能会导致问题（崩溃、非终止）。

assume_astr，{‘gen’，‘sym’，‘her’，‘pos’}

有效条目如上所述。

transposedbool，默认值：假

如果为真，解决 a.T @ x == b。对复数 a 抛出 NotImplementedError。

x(N, NRHS) ndarray

解决方案数组。

引发：

值错误

如果检测到大小不匹配或输入 a 不是方形的。

LinAlgError

如果矩阵是奇异的。

LinAlgWarning

如果检测到病态输入的 a。

未实现错误

如果 transposed 为真且输入的 a 是复数矩阵。

注意事项

如果输入 b 矩阵是具有 N 个元素的 1-D 数组，并且与一个 NxN 输入的 a 一起提供，则尽管明显大小不匹配，但被假定为有效的列向量。这与 numpy.dot() 的行为兼容，返回的结果仍然是 1-D 数组。

通过调用 LAPACK 的 ?GESV、?SYSV、?HESV 和 ?POSV 程序获得通用、对称、共轭和正定解。

示例

给定 a 和 b，解 x：

>>> import numpy as np
>>> a = np.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]])
>>> b = np.array([2, 4, -1])
>>> from scipy import linalg
>>> x = linalg.solve(a, b)
>>> x
array([ 2., -2.,  9.])
>>> np.dot(a, x) == b
array([ True,  True,  True], dtype=bool)

`scipy.linalg.solve_banded`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.solve_banded.html#scipy.linalg.solve_banded

scipy.linalg.solve_banded(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, check_finite=True)

解方程 a x = b 以 x 为假设，假设 a 是带状矩阵。

矩阵a以矩阵对角线有序形式存储在ab中：

ab[u + i - j, j] == a[i,j]

ab的示例（a 的形状为(6,6)，u =1，l =2）：

*    a01  a12  a23  a34  a45
a00  a11  a22  a33  a44  a55
a10  a21  a32  a43  a54   *
a20  a31  a42  a53   *    *

参数：

(l, u)（整数，整数）

非零下、上对角线数量

ab(l + u + 1, M)数组样本

带状矩阵

b(M,)或(M, K)数组样本

右侧

overwrite_abbool，可选

丢弃ab中的数据（可能增强性能）

overwrite_bbool，可选

丢弃b中的数据（可能增强性能）

check_finitebool，可选

是否检查输入矩阵只包含有限数。禁用可能带来性能提升，但如果输入确实包含无穷大或 NaN，可能会导致问题（崩溃、非终止）。

x(M,)或(M, K)数组样本

系统方程 a x = b 的解。返回形状取决于b的形状。

示例

解决带状系统 a x = b，其中：

 [5  2 -1  0  0]       [0]
    [1  4  2 -1  0]       [1]
a = [0  1  3  2 -1]   b = [2]
    [0  0  1  2  2]       [2]
    [0  0  0  1  1]       [3]

主对角线下有一个非零对角线（l = 1），上有两个（u = 2）。该矩阵的带状形式为：

 [*  * -1 -1 -1]
ab = [*  2  2  2  2]
     [5  4  3  2  1]
     [1  1  1  1  *]

>>> import numpy as np
>>> from scipy.linalg import solve_banded
>>> ab = np.array([[0,  0, -1, -1, -1],
...                [0,  2,  2,  2,  2],
...                [5,  4,  3,  2,  1],
...                [1,  1,  1,  1,  0]])
>>> b = np.array([0, 1, 2, 2, 3])
>>> x = solve_banded((1, 2), ab, b)
>>> x
array([-2.37288136,  3.93220339, -4\.        ,  4.3559322 , -1.3559322 ])

`scipy.linalg.solveh_banded`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.solveh_banded.html#scipy.linalg.solveh_banded

scipy.linalg.solveh_banded(ab, b, overwrite_ab=False, overwrite_b=False, lower=False, check_finite=True)

解方程 a x = b。a 是 Hermitian 正定带状矩阵。

使用 Thomas 算法，比标准 LU 分解更高效，但仅适用于 Hermitian 正定矩阵。

矩阵 a 存储在 ab 中，可以是下对角线或者上对角线排序形式：

如果是上三角形式，则 ab[u + i - j, j] == a[i,j]（i <= j）；如果是下三角形式，则 ab[i - j, j] == a[i,j]（i >= j）

ab 示例（a 的形状为 (6, 6)，上对角线数量 u = 2）：

upper form:
*   *   a02 a13 a24 a35
*   a01 a12 a23 a34 a45
a00 a11 a22 a33 a44 a55

lower form:
a00 a11 a22 a33 a44 a55
a10 a21 a32 a43 a54 *
a20 a31 a42 a53 *   *

未使用标记为 * 的单元格。

参数：

ab(u + 1, M) 类似数组

带状矩阵

b(M,) 或 (M, K) 类似数组

右侧

overwrite_abbool, optional

丢弃 ab 中的数据（可能提升性能）

overwrite_bbool, optional

丢弃 b 中的数据（可能提升性能）

lowerbool, optional

矩阵是否处于下三角形式（默认为上三角形式）

check_finitebool, optional

是否检查输入矩阵仅包含有限数字。禁用此选项可能提升性能，但如果输入包含无穷大或 NaN，则可能导致问题（崩溃、无法终止）。

x(M,) 或 (M, K) 数组

解决系统 a x = b。返回形状与 b 相匹配。

注意事项

对于非正定矩阵 a，可以使用求解器 solve_banded。

示例

解决带状系统 A x = b，其中：

 [ 4  2 -1  0  0  0]       [1]
    [ 2  5  2 -1  0  0]       [2]
A = [-1  2  6  2 -1  0]   b = [2]
    [ 0 -1  2  7  2 -1]       [3]
    [ 0  0 -1  2  8  2]       [3]
    [ 0  0  0 -1  2  9]       [3]

>>> import numpy as np
>>> from scipy.linalg import solveh_banded

ab 包含主对角线和主对角线下方的非零对角线。也就是说，我们使用下三角形式：

>>> ab = np.array([[ 4,  5,  6,  7, 8, 9],
...                [ 2,  2,  2,  2, 2, 0],
...                [-1, -1, -1, -1, 0, 0]])
>>> b = np.array([1, 2, 2, 3, 3, 3])
>>> x = solveh_banded(ab, b, lower=True)
>>> x
array([ 0.03431373,  0.45938375,  0.05602241,  0.47759104,  0.17577031,
 0.34733894])

解决 Hermitian 带状系统 H x = b，其中：

 [ 8   2-1j   0     0  ]        [ 1  ]
H = [2+1j  5     1j    0  ]    b = [1+1j]
    [ 0   -1j    9   -2-1j]        [1-2j]
    [ 0    0   -2+1j   6  ]        [ 0  ]

在这个例子中，我们将上对角线放在数组 hb 中：

>>> hb = np.array([[0, 2-1j, 1j, -2-1j],
...                [8,  5,    9,   6  ]])
>>> b = np.array([1, 1+1j, 1-2j, 0])
>>> x = solveh_banded(hb, b)
>>> x
array([ 0.07318536-0.02939412j,  0.11877624+0.17696461j,
 0.10077984-0.23035393j, -0.00479904-0.09358128j])

`scipy.linalg.solve_circulant`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.solve_circulant.html#scipy.linalg.solve_circulant

scipy.linalg.solve_circulant(c, b, singular='raise', tol=None, caxis=-1, baxis=0, outaxis=0)

解决 C x = b，其中 C 是循环矩阵。

C是与向量c相关联的循环矩阵。

通过在 Fourier 空间进行除法来解决系统。计算方法如下：

x = ifft(fft(b) / fft(c))

其中fft和ifft分别是快速傅里叶变换及其逆变换。对于一个大向量c，这比使用完整的循环矩阵解系统要快得多。

参数：

c类似数组

循环矩阵的系数。

b类似数组

a x = b中的右手边矩阵。

singular字符串，可选

此参数控制如何处理接近奇异的循环矩阵。如果singular为“raise”且循环矩阵接近奇异，则会引发LinAlgError。如果singular为“lstsq”，则返回最小二乘解。默认为“raise”。

tol浮点数，可选

如果循环矩阵的任何特征值的绝对值小于或等于tol，则矩阵被视为接近奇异。如果未给出，tol被设置为：

tol = abs_eigs.max() * abs_eigs.size * np.finfo(np.float64).eps

其中abs_eigs是循环矩阵特征值的绝对值数组。

caxis整数

当c的维度大于 1 时，它被视为循环向量的集合。在这种情况下，caxis是保持循环系数向量的c的轴。

baxis整数

当b的维度大于 1 时，它被视为向量的集合。在这种情况下，baxis是保持右侧向量的b的轴。

outaxis整数

当c或b是多维的时，由solve_circulant返回的值也是多维的。在这种情况下，outaxis是结果中保存解向量的轴。

x数组

解决系统C x = b。

引发：

线性代数错误

如果与c相关联的循环矩阵接近奇异。

另请参见

circulant

循环矩阵

注释

对于长度为m的一维向量c，和形状为(m, ...)的数组b，

solve_circulant(c, b)

返回与相同的结果

solve(circulant(c), b)

其中solve和circulant来自scipy.linalg。

版本 0.16.0 中的新功能。

示例

>>> import numpy as np
>>> from scipy.linalg import solve_circulant, solve, circulant, lstsq

>>> c = np.array([2, 2, 4])
>>> b = np.array([1, 2, 3])
>>> solve_circulant(c, b)
array([ 0.75, -0.25,  0.25])

将该结果与使用scipy.linalg.solve解决系统进行比较：

>>> solve(circulant(c), b)
array([ 0.75, -0.25,  0.25])

一个奇异的例子：

>>> c = np.array([1, 1, 0, 0])
>>> b = np.array([1, 2, 3, 4])

调用 solve_circulant(c, b) 将引发 LinAlgError。对于最小二乘解法，请使用选项 singular='lstsq'：

>>> solve_circulant(c, b, singular='lstsq')
array([ 0.25,  1.25,  2.25,  1.25])

与 scipy.linalg.lstsq 进行比较：

>>> x, resid, rnk, s = lstsq(circulant(c), b)
>>> x
array([ 0.25,  1.25,  2.25,  1.25])

广播示例：

假设我们有存储在形状为（2，5）的数组中的两个循环矩阵的向量，并且存储在形状为（3，5）的数组中的三个b向量。例如，

>>> c = np.array([[1.5, 2, 3, 0, 0], [1, 1, 4, 3, 2]])
>>> b = np.arange(15).reshape(-1, 5)

我们希望解决所有循环矩阵和b向量的组合，并将结果存储在形状为（2，3，5）的数组中。当我们忽略保存系数向量的c和b轴时，集合的形状分别为（2，）和（3，），这两者在广播时不兼容。为了获得形状为（2，3）的广播结果，我们向c添加一个无关紧要的维度：c[:, np.newaxis, :] 的形状为（2，1，5）。最后一个维度保存循环矩阵的系数，因此当我们调用 solve_circulant 时，可以使用默认的 caxis=-1。b向量的系数位于数组b的最后一个维度中，因此我们使用 baxis=-1。如果使用默认的 outaxis，则结果将具有形状（5，2，3），因此我们将使用 outaxis=-1 将解向量放在最后一个维度中。

>>> x = solve_circulant(c[:, np.newaxis, :], b, baxis=-1, outaxis=-1)
>>> x.shape
(2, 3, 5)
>>> np.set_printoptions(precision=3)  # For compact output of numbers.
>>> x
array([[[-0.118,  0.22 ,  1.277, -0.142,  0.302],
 [ 0.651,  0.989,  2.046,  0.627,  1.072],
 [ 1.42 ,  1.758,  2.816,  1.396,  1.841]],
 [[ 0.401,  0.304,  0.694, -0.867,  0.377],
 [ 0.856,  0.758,  1.149, -0.412,  0.831],
 [ 1.31 ,  1.213,  1.603,  0.042,  1.286]]])

通过解决一对c和b向量来检查（参见 x[1, 1, :]）：

>>> solve_circulant(c[1], b[1, :])
array([ 0.856,  0.758,  1.149, -0.412,  0.831])

`scipy.linalg.solve_triangular`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.solve_triangular.html#scipy.linalg.solve_triangular

scipy.linalg.solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, check_finite=True)

解方程a x = b以求解x，假设a为三角矩阵。

参数：

a(M, M) 的 array_like

一个三角形矩阵

b(M,) 或 (M, N) 的 array_like

a x = b中的右手边矩阵

lowerbool, 可选

仅使用a的下三角中的数据。默认使用上三角。

trans, 可选

要解决的系统类型：

trans	system
0 或 ‘N’	a x = b
1 或 ‘T’	a^T x = b
2 或 ‘C’	a^H x = b

unit_diagonalbool, 可选

如果为 True，则假定a的对角线元素为 1 且不会被引用。

overwrite_bbool, 可选

允许覆盖b中的数据（可能提高性能）

check_finitebool, 可选

是否检查输入矩阵仅包含有限数值。禁用此项可能会提高性能，但如果输入包含无穷大或 NaN，可能会导致问题（崩溃、非终止）。

x(M,) 或 (M, N) 的 ndarray

a x = b 系统的解。返回形状与b相匹配。

异常：

LinAlgError

如果a是奇异的

注意事项

0.9.0 版本中的新功能。

示例

解下三角系统a x = b，其中：

 [3  0  0  0]       [4]
a =  [2  1  0  0]   b = [2]
     [1  0  1  0]       [4]
     [1  1  1  1]       [2]

>>> import numpy as np
>>> from scipy.linalg import solve_triangular
>>> a = np.array([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]])
>>> b = np.array([4, 2, 4, 2])
>>> x = solve_triangular(a, b, lower=True)
>>> x
array([ 1.33333333, -0.66666667,  2.66666667, -1.33333333])
>>> a.dot(x)  # Check the result
array([ 4.,  2.,  4.,  2.])

`scipy.linalg.solve_toeplitz`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.solve_toeplitz.html#scipy.linalg.solve_toeplitz

scipy.linalg.solve_toeplitz(c_or_cr, b, check_finite=True)

使用 Levinson 递归解 Toeplitz 系统

Toeplitz 矩阵具有常对角线，以 c 作为其第一列，r 作为其第一行。如果未提供 r，则假定r == conjugate(c)。

参数：

c_or_cr array_like 或 (array_like, array_like) 元组

向量c或数组元组(c, r)。无论c的实际形状如何，都将转换为 1-D 数组。如果未提供，则假定r = conjugate(c)；在这种情况下，如果 c[0]是实数，则 Toeplitz 矩阵是 Hermitian 的。忽略 r[0]；Toeplitz 矩阵的第一行是[c[0], r[1:]]。无论r的实际形状如何，都将转换为 1-D 数组。

b(M,) 或 (M, K) 的 array_like

右侧的T x = b。

check_finite bool，可选

是否检查输入矩阵只包含有限数字。禁用可能会提高性能，但如果输入确实包含无穷大或 NaN，则可能会导致问题（结果完全为 NaN）。

x(M,) 或 (M, K) 的 ndarray

系统T x = b的解。返回形状与b的形状相匹配。

另请参见

toeplitz

Toeplitz 矩阵

注意事项

使用 Levinson-Durbin 递归计算解，比通用的最小二乘法更快，但数值稳定性较差。

示例

解决 Toeplitz 系统 T x = b，其中：

 [ 1 -1 -2 -3]       [1]
T = [ 3  1 -1 -2]   b = [2]
    [ 6  3  1 -1]       [2]
    [10  6  3  1]       [5]

要指定 Toeplitz 矩阵，只需要第一列和第一行。

>>> import numpy as np
>>> c = np.array([1, 3, 6, 10])    # First column of T
>>> r = np.array([1, -1, -2, -3])  # First row of T
>>> b = np.array([1, 2, 2, 5])

>>> from scipy.linalg import solve_toeplitz, toeplitz
>>> x = solve_toeplitz((c, r), b)
>>> x
array([ 1.66666667, -1\.        , -2.66666667,  2.33333333])

通过创建完整的 Toeplitz 矩阵并将其与x相乘来检查结果。我们应该得到b。

>>> T = toeplitz(c, r)
>>> T.dot(x)
array([ 1.,  2.,  2.,  5.])

`scipy.linalg.matmul_toeplitz`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.matmul_toeplitz.html#scipy.linalg.matmul_toeplitz

scipy.linalg.matmul_toeplitz(c_or_cr, x, check_finite=False, workers=None)

使用 FFT 高效计算 Toeplitz 矩阵乘积

此函数返回 Toeplitz 矩阵与密集矩阵的矩阵乘积。

Toeplitz 矩阵具有恒定的对角线，以 c 作为其第一列，以 r 作为其第一行。如果未给出 r，则假定 r == conjugate(c)。

参数：

c_or_crarray_like 或 (array_like, array_like) 元组

向量 c，或数组元组 (c, r)。无论 c 的实际形状如何，都将转换为 1-D 数组。如果未提供，则假定 r = conjugate(c)；在这种情况下，如果 c[0] 是实数，则 Toeplitz 矩阵是 Hermitian 的。r[0] 将被忽略；Toeplitz 矩阵的第一行是 [c[0], r[1:]]。无论 r 的实际形状如何，都将转换为 1-D 数组。

x(M,) 或 (M, K) array_like

用于相乘的矩阵。

check_finitebool，可选

是否检查输入矩阵是否仅包含有限数字。禁用可能会提高性能，但如果输入包含无穷大或 NaN，则可能会出现问题（结果完全为 NaN）。

workersint，可选

传递给 scipy.fft.fft 和 ifft。用于并行计算的最大工作人数。如果为负数，则该值从 os.cpu_count() 循环。有关更多详细信息，请参阅 scipy.fft.fft。

T @ x(M,) 或 (M, K) ndarray

矩阵乘积 T @ x 的结果。返回的形状与 x 的形状相匹配。

另请参阅

toeplitz

Toeplitz 矩阵

solve_toeplitz

使用 Levinson 递归解决 Toeplitz 系统

注意

Toeplitz 矩阵嵌入在循环矩阵中，并使用 FFT 高效计算矩阵乘积。

由于计算基于 FFT，整数输入将产生浮点输出。这与 NumPy 的 matmul 不同，后者保留输入的数据类型。

这部分基于可以在 [1] 找到的实现，根据 MIT 许可证授权。有关该方法的更多信息，请参考参考文献 [2]。参考文献 [3] 和 [4] 中有更多 Python 的参考实现。

版本 1.6.0 中的新功能。

参考文献

[1]

Jacob R Gardner，Geoff Pleiss，David Bindel，Kilian Q Weinberger，Andrew Gordon Wilson，“GPyTorch：带 GPU 加速的黑盒矩阵-矩阵高斯过程推断”，Max Balandat 和 Ruihan Wu 有贡献。在线可用：github.com/cornellius-gp/gpytorch

[2]

J. Demmel, P. Koev, 和 X. Li, “直接线性求解器简要概述”. 在 Z. Bai, J. Demmel, J. Dongarra, A. Ruhe, 和 H. van der Vorst 编辑的书籍《代数特征值问题解法模板：实用指南》中. SIAM, 费城, 2000. 可在：www.netlib.org/utk/people/JackDongarra/etemplates/node384.html 获得。

[3]

R. Scheibler, E. Bezzam, I. Dokmanic, Pyroomacoustics：用于音频房间模拟和阵列处理算法的 Python 包, IEEE ICASSP 会议论文集, 加拿大卡尔加里, 2018. github.com/LCAV/pyroomacoustics/blob/pypi-release/ pyroomacoustics/adaptive/util.py

[4]

Marano S, Edwards B, Ferrari G 和 Fah D (2017), “拟合地震谱：有色噪声和不完整数据”, 美国地震学会通报.，2017 年 1 月，第 107 卷(1)，第 276-291 页。

示例

将 Toeplitz 矩阵 T 与矩阵 x 相乘：

 [ 1 -1 -2 -3]       [1 10]
T = [ 3  1 -1 -2]   x = [2 11]
    [ 6  3  1 -1]       [2 11]
    [10  6  3  1]       [5 19]

要指定 Toeplitz 矩阵，只需第一列和第一行即可。

>>> import numpy as np
>>> c = np.array([1, 3, 6, 10])    # First column of T
>>> r = np.array([1, -1, -2, -3])  # First row of T
>>> x = np.array([[1, 10], [2, 11], [2, 11], [5, 19]])

>>> from scipy.linalg import toeplitz, matmul_toeplitz
>>> matmul_toeplitz((c, r), x)
array([[-20., -80.],
 [ -7.,  -8.],
 [  9.,  85.],
 [ 33., 218.]])

通过创建完整的 Toeplitz 矩阵并将其与x相乘来检查结果。

>>> toeplitz(c, r) @ x
array([[-20, -80],
 [ -7,  -8],
 [  9,  85],
 [ 33, 218]])

完整矩阵从未显式形成，因此这一例程适用于非常大的 Toeplitz 矩阵。

>>> n = 1000000
>>> matmul_toeplitz([1] + [0]*(n-1), np.ones(n))
array([1., 1., 1., ..., 1., 1., 1.])

`scipy.linalg.det`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.det.html#scipy.linalg.det

scipy.linalg.det(a, overwrite_a=False, check_finite=True)

计算矩阵的行列式。

行列式是与相关方阵系数相关的标量。对于奇异矩阵，行列式值为零。

参数：

a(…, M, M) array_like

用于计算行列式的输入数组。

overwrite_abool, optional

允许在 a 中覆盖数据(可能会增强性能)。

check_finitebool, optional

是否检查输入矩阵仅包含有限数字。禁用此选项可能会带来性能提升，但如果输入确实包含无穷大或 NaN，可能会导致问题(崩溃、非终止)。

det(…) float or complex

a的行列式。对于堆叠数组，对输入的最后两个维度中的每个(m, m)切片返回一个标量。例如，形状为(p, q, m, m)的输入将产生形状为(p, q)的结果。如果所有维度都是 1，则无论 ndim 如何，都返回一个标量。

注意：

行列式通过使用 LAPACK 例程‘getrf’对输入执行 LU 分解，然后计算 U 因子的对角线条目的乘积。

即使输入数组是单精度(float32 或 complex64)，结果也将以双精度(float64 或 complex128)返回，以防止溢出。

示例：

>>> import numpy as np
>>> from scipy import linalg
>>> a = np.array([[1,2,3], [4,5,6], [7,8,9]])  # A singular matrix
>>> linalg.det(a)
0.0
>>> b = np.array([[0,2,3], [4,5,6], [7,8,9]])
>>> linalg.det(b)
3.0
>>> # An array with the shape (3, 2, 2, 2)
>>> c = np.array([[[[1., 2.], [3., 4.]],
...                [[5., 6.], [7., 8.]]],
...               [[[9., 10.], [11., 12.]],
...                [[13., 14.], [15., 16.]]],
...               [[[17., 18.], [19., 20.]],
...                [[21., 22.], [23., 24.]]]])
>>> linalg.det(c)  # The resulting shape is (3, 2)
array([[-2., -2.],
 [-2., -2.],
 [-2., -2.]])
>>> linalg.det(c[0, 0])  # Confirm the (0, 0) slice, [[1, 2], [3, 4]]
-2.0

`scipy.linalg.norm`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.norm.html#scipy.linalg.norm

scipy.linalg.norm(a, ord=None, axis=None, keepdims=False, check_finite=True)

矩阵或向量的范数。

该函数能够返回八种不同的矩阵范数或无穷多种向量范数（如下所述），具体取决于ord参数的值。对于秩不同于 1 或 2 的张量，仅支持ord=None。

参数：

aarray_like

输入数组。如果axis为 None，则a必须为 1-D 或 2-D，除非ord为 None。如果axis和ord都为 None，则将返回a.ravel的 2-范数。

ord，可选

范数的顺序（见Notes表）。inf 表示 NumPy 的inf对象。

axis, optional

如果axis是一个整数，则指定要沿着a的轴计算向量范数。如果axis是一个 2 元组，则指定保持 2-D 矩阵的轴，并计算这些矩阵的矩阵范数。如果axis为 None，则在a为 1-D 时返回向量范数，在a为 2-D 时返回矩阵范数。

keepdimsbool, optional

如果设置为 True，则规范化的轴将保留在结果中作为大小为一的维度。使用此选项，结果将正确地对原始a广播。

check_finitebool, optional

是否检查输入矩阵仅包含有限数。禁用可能会提高性能，但如果输入确实包含无穷大或 NaN，则可能会导致问题（崩溃、非终止）。

nfloat 或 ndarray

矩阵或向量的范数。

注记

对于ord <= 0的值，严格来说，结果并不是数学上的‘范数’，但在各种数值目的中仍可能有用。

可以计算以下范数：

ord	矩阵的范数	向量的范数
None	弗罗贝尼乌斯范数	2-范数
‘fro’	弗罗贝尼乌斯范数	–
‘nuc’	核范数	–
inf	最大(sum(abs(a), axis=1))	max(abs(a))
-inf	min(sum(abs(a), axis=1))	min(abs(a))
0	–	sum(a != 0)
1	最大(sum(abs(a), axis=0))	如下
-1	最小(sum(abs(a), axis=0))	如下
2	2-范数（最大奇异值）	如下
-2	最小奇异值	如下
other	–	sum(abs(a)ord)(1./ord)

弗罗贝尼乌斯范数由[1]给出：

(||A||F = [\sum abs(a_{i,j})²]^{1/2})

核范数是奇异值的总和。

弗罗贝尼乌斯和核范数的顺序仅适用于矩阵。

参考文献

[1]

G. H. Golub 和 C. F. Van Loan，《Matrix Computations》，Baltimore, MD, Johns Hopkins University Press, 1985，第 15 页

示例

>>> import numpy as np
>>> from scipy.linalg import norm
>>> a = np.arange(9) - 4.0
>>> a
array([-4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
>>> b = a.reshape((3, 3))
>>> b
array([[-4., -3., -2.],
 [-1.,  0.,  1.],
 [ 2.,  3.,  4.]])

>>> norm(a)
7.745966692414834
>>> norm(b)
7.745966692414834
>>> norm(b, 'fro')
7.745966692414834
>>> norm(a, np.inf)
4
>>> norm(b, np.inf)
9
>>> norm(a, -np.inf)
0
>>> norm(b, -np.inf)
2

>>> norm(a, 1)
20
>>> norm(b, 1)
7
>>> norm(a, -1)
-4.6566128774142013e-010
>>> norm(b, -1)
6
>>> norm(a, 2)
7.745966692414834
>>> norm(b, 2)
7.3484692283495345

>>> norm(a, -2)
0
>>> norm(b, -2)
1.8570331885190563e-016
>>> norm(a, 3)
5.8480354764257312
>>> norm(a, -3)
0

`scipy.linalg.lstsq`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.lstsq.html#scipy.linalg.lstsq

scipy.linalg.lstsq(a, b, cond=None, overwrite_a=False, overwrite_b=False, check_finite=True, lapack_driver=None)

计算方程 Ax = b 的最小二乘解。

计算向量 x，使得二范数 |b - A x| 最小化。

参数：

a(M, N) array_like

左手边数组

b(M,) or (M, K) array_like

右手边数组

condfloat, optional

用于确定 a 的有效秩的‘小’奇异值的截断值。小于 cond * largest_singular_value 的奇异值被视为零。

overwrite_abool, optional

丢弃 a 中的数据（可能增强性能）。默认为 False。

overwrite_bbool, optional

丢弃 b 中的数据（可能增强性能）。默认为 False。

check_finitebool, optional

是否检查输入矩阵仅包含有限数值。禁用可能会带来性能提升，但如果输入包含无穷大或 NaN，则可能会导致问题（崩溃，非终止）。

lapack_driverstr, optional

用于解决最小二乘问题的 LAPACK 驱动程序。选项有 'gelsd', 'gelsy', 'gelss'。默认 ('gelsd') 是一个很好的选择。但在许多问题上，'gelsy' 可能略快。'gelss' 曾被历史性地使用。它通常速度较慢但使用的内存较少。

新版本 0.17.0 中的新功能。

x(N,) or (N, K) ndarray

最小二乘解。

residues(K,) ndarray or float

对于 M > N 且 ndim(A) == n 中 b - a x 每列的二范数的平方（如果 b 是一维则返回标量）。否则返回形状为 (0,) 的数组。

rankint

a 的有效秩。

s(min(M, N),) ndarray or None

a 的奇异值。a 的条件数是 s[0] / s[-1]。

引发：

LinAlgError

如果计算不收敛。

ValueError

当参数不兼容时。

另请参阅

scipy.optimize.nnls

具有非负约束的线性最小二乘

注释

当使用 'gelsy' 作为驱动程序时，residues 被设置为形状为 (0,) 的数组，s 总是 None。

示例

>>> import numpy as np
>>> from scipy.linalg import lstsq
>>> import matplotlib.pyplot as plt

假设我们有以下数据：

>>> x = np.array([1, 2.5, 3.5, 4, 5, 7, 8.5])
>>> y = np.array([0.3, 1.1, 1.5, 2.0, 3.2, 6.6, 8.6])

我们希望拟合一个二次多项式 y = a + b*x**2 到这些数据上。我们首先形成“设计矩阵” M，其中包含一个全为 1 的常数列和一个包含 x**2 的列：

>>> M = x[:, np.newaxis]**[0, 2]
>>> M
array([[  1\.  ,   1\.  ],
 [  1\.  ,   6.25],
 [  1\.  ,  12.25],
 [  1\.  ,  16\.  ],
 [  1\.  ,  25\.  ],
 [  1\.  ,  49\.  ],
 [  1\.  ,  72.25]])

我们希望找到最小二乘解来满足 M.dot(p) = y，其中 p 是一个长度为 2 的向量，包含参数 a 和 b。

>>> p, res, rnk, s = lstsq(M, y)
>>> p
array([ 0.20925829,  0.12013861])

绘制数据和拟合曲线。

>>> plt.plot(x, y, 'o', label='data')
>>> xx = np.linspace(0, 9, 101)
>>> yy = p[0] + p[1]*xx**2
>>> plt.plot(xx, yy, label='least squares fit, $y = a + bx²$')
>>> plt.xlabel('x')
>>> plt.ylabel('y')
>>> plt.legend(framealpha=1, shadow=True)
>>> plt.grid(alpha=0.25)
>>> plt.show()

../../_images/scipy-linalg-lstsq-1.png

`scipy.linalg.pinv`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.pinv.html#scipy.linalg.pinv

scipy.linalg.pinv(a, *, atol=None, rtol=None, return_rank=False, check_finite=True, cond=<object object>, rcond=<object object>)

计算矩阵的（摩尔-彭罗斯）伪逆。

使用奇异值分解的经济模式 U @ S @ V 计算矩阵的广义逆，并仅选择与显著奇异值相关联的列/行。

如果 s 是 a 的最大奇异值，则显著性截止值由 atol + rtol * s 决定。任何低于此值的奇异值被认为是不显著的。

参数：

a(M, N) 数组类型

要伪逆的矩阵。

atolfloat, optional

绝对阈值项，默认值为 0。

从版本 1.7.0 新增。

rtolfloat, optional

相对阈值项，默认值为 max(M, N) * eps，其中 eps 是 a 数据类型的机器精度值。

从版本 1.7.0 新增。

return_rankbool, optional

如果为 True，则返回矩阵的有效秩。

check_finitebool, optional

是否检查输入矩阵仅包含有限数。禁用可能会带来性能提升，但如果输入确实包含无穷大或 NaN，则可能导致问题（崩溃、非终止）。

cond, rcondfloat, optional

在旧版本中，这些值被用作 atol 和 rtol=0。如果两者都给定，则 rcond 会覆盖 cond，因此代码是不正确的。因此，强烈建议使用上述的公差。

自版本 1.7.0 起弃用：建议使用上述的 rtol 和 atol 参数，因此不再支持这些旧版本。事实上，如果提供了 atol 和 rtol，则这些关键字将优先于这些。

在版本 1.3.0 中更改：先前的默认截止值只是 eps*f，其中 f 是单精度为 1e3，双精度为 1e6。

B(N, M) ndarray

矩阵 a 的伪逆。

rankint

矩阵的有效秩。如果 return_rank 为 True，则返回。

Raises：

LinAlgError

如果 SVD 计算不收敛。

另请参阅

pinvh

Hermitian 矩阵的摩尔-彭罗斯伪逆。

注意事项

如果 A 可逆，则摩尔-彭罗斯伪逆恰好是 A 的逆 [1]。如果 A 不可逆，则摩尔-彭罗斯伪逆计算满足 Ax = b 且使 ||Ax - b|| 最小化的 x 解 [1]。

参考文献

[1] (1,2,3)

Penrose, R. (1956). On best approximate solutions of linear matrix equations. Mathematical Proceedings of the Cambridge Philosophical Society, 52(1), 17-19. doi:10.1017/S0305004100030929

示例

给定一个 m x n 矩阵 A 和一个 n x m 矩阵 B，四个摩尔-彭罗斯条件是：

ABA = A (B 是 A 的广义逆），
BAB = B (A 是 B 的广义逆)，
(AB)* = AB (AB 是埃尔米特矩阵)，
(BA)* = BA (BA 是埃尔米特矩阵) [1].

这里，A* 表示共轭转置。摩尔-彭罗斯伪逆 B 满足所有这四个条件，并且对于任意的 A 都存在。需要注意的是，与标准矩阵逆不同的是，A 并不必是方阵或具有线性独立的列/行。

举例来说，我们可以计算一个随机的非方阵的摩尔-彭罗斯伪逆，并验证它满足这四个条件。

>>> import numpy as np
>>> from scipy import linalg
>>> rng = np.random.default_rng()
>>> A = rng.standard_normal((9, 6))
>>> B = linalg.pinv(A)
>>> np.allclose(A @ B @ A, A)  # Condition 1
True
>>> np.allclose(B @ A @ B, B)  # Condition 2
True
>>> np.allclose((A @ B).conj().T, A @ B)  # Condition 3
True
>>> np.allclose((B @ A).conj().T, B @ A)  # Condition 4
True

`scipy.linalg.pinvh`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.pinvh.html#scipy.linalg.pinvh

scipy.linalg.pinvh(a, atol=None, rtol=None, lower=True, return_rank=False, check_finite=True)

计算（摩尔-彭罗斯）矩阵的伪逆。

使用复数埃尔米特/实对称矩阵的特征值分解计算广义逆，并包括所有具有“大”绝对值的特征值。

参数：

a(N, N) 类似数组

要伪逆的实对称或复数埃尔米特矩阵

atol浮点数，可选项

绝对阈值项，默认值为 0。

新版本为 1.7.0。

rtol浮点数，可选项

相对阈值项，默认值为N * eps，其中eps为a数据类型的机器精度值。

新版本为 1.7.0。

lower布尔值，可选项

指定是否从a的下三角或上三角获取相关数组数据。（默认值：下三角）

return_rank布尔值，可选项

如果为 True，返回矩阵的有效秩。

check_finite布尔值，可选项

是否检查输入矩阵仅包含有限数。禁用可能会提高性能，但如果输入确实包含无穷大或 NaN，则可能导致问题（崩溃、非终止）。

B(N, N) ndarray

矩阵a的伪逆。

rank整数

矩阵的有效秩。如果return_rank为 True，则返回。

引发：

LinAlgError

如果特征值算法不收敛。

另请参见

pinv

矩阵的摩尔-彭罗斯伪逆。

示例

有关更详细的示例，请参见pinv。

>>> import numpy as np
>>> from scipy.linalg import pinvh
>>> rng = np.random.default_rng()
>>> a = rng.standard_normal((9, 6))
>>> a = np.dot(a, a.T)
>>> B = pinvh(a)
>>> np.allclose(a, a @ B @ a)
True
>>> np.allclose(B, B @ a @ B)
True

`scipy.linalg.kron`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.kron.html#scipy.linalg.kron

scipy.linalg.kron(a, b)

克罗内克积。

结果是块状矩阵：

a[0,0]*b    a[0,1]*b  ... a[0,-1]*b
a[1,0]*b    a[1,1]*b  ... a[1,-1]*b
...
a[-1,0]*b   a[-1,1]*b ... a[-1,-1]*b

参数：

a(M, N) ndarray

输入数组

b(P, Q) ndarray

输入数组

A(MP, NQ) ndarray

a 和 b 的克罗内克积。

示例

>>> from numpy import array
>>> from scipy.linalg import kron
>>> kron(array([[1,2],[3,4]]), array([[1,1,1]]))
array([[1, 1, 1, 2, 2, 2],
 [3, 3, 3, 4, 4, 4]])

`scipy.linalg.khatri_rao`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.khatri_rao.html#scipy.linalg.khatri_rao

scipy.linalg.khatri_rao(a, b)

Khatri-Rao 乘积

两个矩阵的列向 Kronecker 乘积

参数：

a(n, k) 数组型

输入数组

b(m, k) 数组型

输入数组

c: (n*m, k) ndarray

a 和 b 的 Khatri-Rao 乘积。

另见

kron

Kronecker 乘积

注意

Khatri-Rao 乘积的数学定义如下：

[(A_{ij} \bigotimes B_{ij})_{ij}]

即 A 和 B 的每列的 Kronecker 乘积，例如：

c = np.vstack([np.kron(a[:, k], b[:, k]) for k in range(b.shape[1])]).T

示例

>>> import numpy as np
>>> from scipy import linalg
>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>> b = np.array([[3, 4, 5], [6, 7, 8], [2, 3, 9]])
>>> linalg.khatri_rao(a, b)
array([[ 3,  8, 15],
 [ 6, 14, 24],
 [ 2,  6, 27],
 [12, 20, 30],
 [24, 35, 48],
 [ 8, 15, 54]])

`scipy.linalg.tril`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.tril.html#scipy.linalg.tril

scipy.linalg.tril(m, k=0)

自 1.11.0 版本起已弃用：tril 已被numpy.tril 取代，将在 SciPy 1.13.0 中移除。

复制矩阵，并将第 k 个对角线以上的元素置零。

参数：

marray_like

要返回其元素的矩阵

kint，可选

对角线上方要置零的元素。k == 0 是主对角线，k < 0 是次对角线，k > 0 是超对角线。

返回值：

trilndarray

返回值与m相同的形状和类型。

示例

>>> from scipy.linalg import tril
>>> tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
array([[ 0,  0,  0],
 [ 4,  0,  0],
 [ 7,  8,  0],
 [10, 11, 12]])

`scipy.linalg.triu`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.triu.html#scipy.linalg.triu

scipy.linalg.triu(m, k=0)

自版本 1.11.0 起已弃用：tril 已弃用，推荐使用 numpy.triu，并且将在 SciPy 1.13.0 中移除。

复制一个矩阵，使得第 k 条对角线以下的元素为零。

参数:

m array_like

要返回其元素的矩阵

k 整数，可选

需要将元素置零的对角线下标。k == 0 是主对角线，k < 0 是次对角线，k > 0 是超对角线。

triu 数组

返回一个矩阵，该矩阵的第 k 条对角线以下的元素为零，并且与m具有相同的形状和类型。

示例

>>> from scipy.linalg import triu
>>> triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
array([[ 1,  2,  3],
 [ 4,  5,  6],
 [ 0,  8,  9],
 [ 0,  0, 12]])

`scipy.linalg.orthogonal_procrustes`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.orthogonal_procrustes.html#scipy.linalg.orthogonal_procrustes

scipy.linalg.orthogonal_procrustes(A, B, check_finite=True)

计算正交 Procrustes 问题的矩阵解。

给定形状相同的矩阵 A 和 B，使用给定的算法找到一个最接近将 A 映射到 B 的正交矩阵 R，详见 [1]。

参数：

A(M, N) array_like

要映射的矩阵。

B(M, N) array_like

目标矩阵。

check_finitebool，可选

是否检查输入矩阵是否只包含有限数字。禁用可能会提高性能，但如果输入包含无穷大或 NaN，则可能导致问题（崩溃、非终止）。

R(N, N) ndarray

正交 Procrustes 问题的矩阵解。最小化 (A @ R) - B 的 Frobenius 范数，满足 R.T @ R = I。

scalefloat

A.T @ B的奇异值之和。

抛出异常：

ValueError

如果输入数组的形状不匹配，或者如果 check_finite 为 True 并且数组包含 Inf 或 NaN。

注释

注意，与空间数据的高级 Procrustes 分析不同，此函数仅使用正交变换如旋转和反射，不使用缩放或平移。

自版本 0.15.0 新增。

参考文献

[1]

Peter H. Schonemann，“正交 Procrustes 问题的广义解”，Psychometrica – Vol. 31，No. 1，March，1966。DOI:10.1007/BF02289451

示例

>>> import numpy as np
>>> from scipy.linalg import orthogonal_procrustes
>>> A = np.array([[ 2,  0,  1], [-2,  0,  0]])

翻转列的顺序并检查反对角线映射

>>> R, sca = orthogonal_procrustes(A, np.fliplr(A))
>>> R
array([[-5.34384992e-17,  0.00000000e+00,  1.00000000e+00],
 [ 0.00000000e+00,  1.00000000e+00,  0.00000000e+00],
 [ 1.00000000e+00,  0.00000000e+00, -7.85941422e-17]])
>>> sca
9.0

`scipy.linalg.matrix_balance`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.matrix_balance.html#scipy.linalg.matrix_balance

scipy.linalg.matrix_balance(A, permute=True, scale=True, separate=False, overwrite_a=False)

计算行/列平衡的对角相似变换。

平衡试图通过应用相似变换来使行和列的 1-范数相等，以反映矩阵条目的幅度变化到缩放矩阵中。

此外，如果启用，矩阵首先被置换以隔离矩阵的上三角部分，再次如果启用缩放，则仅对剩余的子块进行缩放。

平衡矩阵满足以下等式

[B = T^{-1} A T]

缩放系数被近似为最接近的 2 的幂，以避免舍入误差。

参数：

A(n, n) 类似数组

平衡的方阵数据。

permute布尔型，可选

选择器，用于定义在缩放之前是否对 A 进行置换。

scale布尔型，可选

选择器，用于打开和关闭缩放。如果为 False，则矩阵不会被缩放。

separate布尔型，可选

这会从返回变换的完整矩阵切换为两个独立的 1 维置换和缩放数组的元组。

overwrite_a布尔型，可选

这直接传递给 xGEBAL。本质上，它覆盖了数据的结果。它可能会提高空间效率。有关详细信息，请参阅 LAPACK 手册。默认为 False。

B(n, n) ndarray

平衡后的矩阵

T(n, n) ndarray

可能经过置换的对角矩阵，其非零元素为 2 的整数幂，以避免数值截断误差。

scale, perm(n,) ndarray

如果 separate 关键字设置为 True，则不使用上述数组 T，而是将缩放和置换向量分别给出为一个元组，而不分配完整的数组 T。

注意事项

这种算法在特征值和矩阵分解中特别有用，并且在许多情况下已经由各种 LAPACK 例程调用。

该算法基于众所周知的技术[1]，并已修改以考虑特殊情况。参见[2]以了解自 LAPACK v3.5.0 以来已实施的细节。在此版本之前，有些特例情况下，平衡实际上可能会恶化条件。参见[3]了解此类示例。

此代码是对 LAPACK 的 xGEBAL 程序包围器，用于矩阵平衡。

从版本 0.19.0 开始新增。

参考文献

[1]

B.N. Parlett 和 C. Reinsch，“平衡矩阵以计算特征值和特征向量”，Numerische Mathematik，Vol.13(4)，1969 年，DOI:10.1007/BF02165404

[2]

R. James, J. Langou, B.R. Lowery，“矩阵平衡和特征向量计算”，2014 年，arXiv:1401.5766

[3]

D.S. Watkins. 平衡有害的案例。电子。数值分析交易，第 23 卷，2006 年。

例子

>>> import numpy as np
>>> from scipy import linalg
>>> x = np.array([[1,2,0], [9,1,0.01], [1,2,10*np.pi]])

>>> y, permscale = linalg.matrix_balance(x)
>>> np.abs(x).sum(axis=0) / np.abs(x).sum(axis=1)
array([ 3.66666667,  0.4995005 ,  0.91312162])

>>> np.abs(y).sum(axis=0) / np.abs(y).sum(axis=1)
array([ 1.2       ,  1.27041742,  0.92658316])  # may vary

>>> permscale  # only powers of 2 (0.5 == 2^(-1))
array([[  0.5,   0\. ,  0\. ],  # may vary
 [  0\. ,   1\. ,  0\. ],
 [  0\. ,   0\. ,  1\. ]])

`scipy.linalg.subspace_angles`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.subspace_angles.html#scipy.linalg.subspace_angles

scipy.linalg.subspace_angles(A, B)

计算两个矩阵之间的子空间角度。

参数：

A(M, N) array_like

第一个输入数组。

B(M, K) array_like

第二个输入数组。

anglesndarray，形状为(min(N, K),)

A和B的列空间之间的子空间角度按降序排列。

参见

orth

svd

注意事项

根据提供在[1]中的公式计算子空间角度。为了与 MATLAB 和 Octave 行为等效，请使用angles[0]。

自 1.0 版本开始新增。

参考

[1]

Knyazev A, Argentati M (2002) Principal Angles between Subspaces in an A-Based Scalar Product: Algorithms and Perturbation Estimates. SIAM J. Sci. Comput. 23:2008-2040.

示例

一个哈达玛矩阵，其具有正交列，因此我们期望子空间角为 (\frac{\pi}{2})：

>>> import numpy as np
>>> from scipy.linalg import hadamard, subspace_angles
>>> rng = np.random.default_rng()
>>> H = hadamard(4)
>>> print(H)
[[ 1  1  1  1]
 [ 1 -1  1 -1]
 [ 1  1 -1 -1]
 [ 1 -1 -1  1]]
>>> np.rad2deg(subspace_angles(H[:, :2], H[:, 2:]))
array([ 90.,  90.])

并且矩阵到自身的子空间角应为零：

>>> subspace_angles(H[:, :2], H[:, :2]) <= 2 * np.finfo(float).eps
array([ True,  True], dtype=bool)

非正交子空间之间的角度处于这些极端之间：

>>> x = rng.standard_normal((4, 3))
>>> np.rad2deg(subspace_angles(x[:, :2], x[:, [2]]))
array([ 55.832])  # random

`scipy.linalg.bandwidth`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.bandwidth.html#scipy.linalg.bandwidth

scipy.linalg.bandwidth(a)

返回一个二维数值数组的下界和上界带宽。

参数：

ndarray（数组）

输入大小为（N，M）的数组

lu元组

2-tuple of ints indicating the lower and upper bandwidth. A zero denotes no sub- or super-diagonal on that side (triangular), and, say for N rows (N-1) means that side is full. Same example applies to the upper triangular part with (M-1).

Raises:

TypeError

如果数组的 dtype 不受支持，特别是 NumPy 的 float16，float128 和 complex256 dtypes。

Notes

这个辅助函数简单地遍历数组，查找非零条目，无论数组中是否存在带状结构。因此，性能取决于非零条目的密度和内存布局。Fortran 或 C 连续数组处理最佳，否则会遭受额外的随机内存访问成本。

策略是分别查找上三角部分和下三角部分中仅未测试的带元素；根据内存布局，我们可以逐行或逐列扫描。此外，例如我们正在扫描行，并且在第 6 行，第 4 个条目不为零，则在后续行中，仅在该带条目处进行水平搜索，因为我们知道该带已被占用。因此，完全密集矩阵扫描的成本是按照 n 的顺序。

Examples

>>> import numpy as np
>>> from scipy.linalg import bandwidth
>>> A = np.array([[3., 0., 0., 0., 0.],
...               [0., 4., 0., 0., 0.],
...               [0., 0., 5., 1., 0.],
...               [8., 0., 0., 6., 2.],
...               [0., 9., 0., 0., 7.]])
>>> bandwidth(A)
(3, 1)

`scipy.linalg.issymmetric`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.issymmetric.html#scipy.linalg.issymmetric

scipy.linalg.issymmetric(a, atol=None, rtol=None)

检查方阵是否对称。

参数：

andarray

尺寸为 (N, N) 的输入数组。

atol 浮点数，可选

绝对误差界限

rtol 浮点数，可选

相对误差界限

symbool

如果数组对称，则返回 True。

引发：

类型错误

如果数组的 dtype 不受支持，特别是 NumPy 中的 float16、float128 和 complex256 dtypes 用于精确比较。

另请参见

ishermitian

检查方阵是否是 Hermitean

注：

对于空方阵，按照约定返回 True 的结果。复数值数组测试对称性而不是 Hermitean（参见示例）

不扫描数组的对角线。因此，如果对角线上存在无限大、NaN 或类似的问题条目，则将被忽略。然而，numpy.inf 将被视为一个数字，也就是说 [[1, inf], [inf, 2]] 将返回 True。另一方面，numpy.nan 永远不是对称的，例如，[[1, nan], [nan, 2]] 将返回 False。

当 atol 和/或 rtol 被设置为，那么比较将由 numpy.allclose 执行，并且容差值将传递给它。否则，内部函数将执行针对零的精确比较。因此，性能可能会因数组的大小和 dtype 而改善或恶化。如果给定了 atol 或 rtol 中的一个，则另一个自动设置为零。

示例

>>> import numpy as np
>>> from scipy.linalg import issymmetric
>>> A = np.arange(9).reshape(3, 3)
>>> A = A + A.T
>>> issymmetric(A)
True
>>> Ac = np.array([[1. + 1.j, 3.j], [3.j, 2.]])
>>> issymmetric(Ac)  # not Hermitian but symmetric
True

`scipy.linalg.ishermitian`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.ishermitian.html#scipy.linalg.ishermitian

scipy.linalg.ishermitian(a, atol=None, rtol=None)

检查方形 2D 数组是否为 Hermite 矩阵。

参数：

andarray

输入大小为(N, N)的数组

atolfloat，可选

绝对误差界限

rtolfloat，可选

相对误差界限

herbool

如果数组是 Hermite 矩阵，则返回 True。

抛出：

类型错误

如果数组的 dtype 不受支持，特别是 NumPy 的 float16、float128 和 complex256 dtypes。

另请参阅

issymmetric

检查方形 2D 数组是否对称

注意

对于方形空数组，按照惯例结果返回 True。

numpy.inf将被视为数字，也就是说[[1, inf], [inf, 2]]将返回True。另一方面，numpy.nan从不对称，例如[[1, nan], [nan, 2]]将返回False。

当设置了atol和/或rtol时，则通过numpy.allclose进行比较，并将容差值传递给它。否则，内部函数执行针对零的精确比较。因此，性能根据数组的大小和 dtype 可能会提高或降低。如果给定atol或rtol中的一个，则另一个自动设置为零。

示例

>>> import numpy as np
>>> from scipy.linalg import ishermitian
>>> A = np.arange(9).reshape(3, 3)
>>> A = A + A.T
>>> ishermitian(A)
True
>>> A = np.array([[1., 2. + 3.j], [2. - 3.j, 4.]])
>>> ishermitian(A)
True
>>> Ac = np.array([[1. + 1.j, 3.j], [3.j, 2.]])
>>> ishermitian(Ac)  # not Hermitian but symmetric
False
>>> Af = np.array([[0, 1 + 1j], [1 - (1+1e-12)*1j, 0]])
>>> ishermitian(Af)
False
>>> ishermitian(Af, atol=5e-11) # almost hermitian with atol
True

`scipy.linalg.LinAlgError`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.LinAlgError.html#scipy.linalg.LinAlgError

exception scipy.linalg.LinAlgError

由 linalg 函数引发的基本 Python 异常对象。

通用目的的异常类，派生自 Python 的 ValueError 类，在 linalg 函数中以编程方式引发，当线性代数相关条件会阻止函数进一步正确执行时。

Parameters:

None

Examples

>>> from numpy import linalg as LA
>>> LA.inv(np.zeros((2,2)))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
 File "...linalg.py", line 350,
 in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
 File "...linalg.py", line 249,
 in solve
 raise LinAlgError('Singular matrix')
numpy.linalg.LinAlgError: Singular matrix

with_traceback()

Exception.with_traceback(tb) – 将 self.traceback 设置为 tb 并返回 self。

`scipy.linalg.LinAlgWarning`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.LinAlgWarning.html#scipy.linalg.LinAlgWarning

exception scipy.linalg.LinAlgWarning

当线性代数相关操作接近算法失效条件或预计精度损失时发出警告。

with_traceback()

Exception.with_traceback(tb) – 将 self.traceback 设置为 tb 并返回 self。

`scipy.linalg.eig`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.eig.html#scipy.linalg.eig

scipy.linalg.eig(a, b=None, left=False, right=True, overwrite_a=False, overwrite_b=False, check_finite=True, homogeneous_eigvals=False)

解一个方阵的普通或广义特征值问题。

寻找一般矩阵的特征值 w 和右特征向量或左特征向量：

a   vr[:,i] = w[i]        b   vr[:,i]
a.H vl[:,i] = w[i].conj() b.H vl[:,i]

其中.H是共轭转置。

参数：

a(M, M) array_like

将计算其特征值和特征向量的复数或实数矩阵。

b(M, M) array_like, optional

广义特征值问题中的右手边矩阵。默认为 None，假定为单位矩阵。

leftbool, optional

是否计算并返回左特征向量。默认为 False。

rightbool, optional

是否计算并返回右特征向量。默认为 True。

overwrite_abool, optional

是否覆盖a；可能会提高性能。默认为 False。

overwrite_bbool, optional

是否覆盖b；可能会提高性能。默认为 False。

check_finitebool, optional

是否检查输入矩阵只包含有限数字。禁用可能会提高性能，但如果输入包含无穷大或 NaN，可能会导致问题（崩溃、非终止）。

homogeneous_eigvalsbool, optional

如果为 True，则以齐次坐标返回特征值。在这种情况下，w是一个(2, M)的数组，使得：

w[1,i] a vr[:,i] = w[0,i] b vr[:,i]

默认为 False。

w(M,)或(2, M)的双精度或复数 ndarray

每个特征值根据其重数重复。形状为(M,)，除非homogeneous_eigvals=True。

vl(M, M)的双精度或复数 ndarray

与特征值w[i]对应的左特征向量是列vl[:,i]。仅在left=True时返回。左特征向量未归一化。

vr(M, M)的双精度或复数 ndarray

与特征值w[i]对应的归一化右特征向量是列vr[:,i]。仅在right=True时返回。

Raises:

LinAlgError

如果特征值计算未收敛。

另请参阅

eigvals

一般数组的特征值

eigh

对称/Hermitian 数组的特征值和右特征向量。

eig_banded

对称/Hermitian 带状矩阵的特征值和右特征向量

eigh_tridiagonal

对称/Hermitian 三对角矩阵的特征值和右特征向量

示例

>>> import numpy as np
>>> from scipy import linalg
>>> a = np.array([[0., -1.], [1., 0.]])
>>> linalg.eigvals(a)
array([0.+1.j, 0.-1.j])

>>> b = np.array([[0., 1.], [1., 1.]])
>>> linalg.eigvals(a, b)
array([ 1.+0.j, -1.+0.j])

>>> a = np.array([[3., 0., 0.], [0., 8., 0.], [0., 0., 7.]])
>>> linalg.eigvals(a, homogeneous_eigvals=True)
array([[3.+0.j, 8.+0.j, 7.+0.j],
 [1.+0.j, 1.+0.j, 1.+0.j]])

>>> a = np.array([[0., -1.], [1., 0.]])
>>> linalg.eigvals(a) == linalg.eig(a)[0]
array([ True,  True])
>>> linalg.eig(a, left=True, right=False)[1] # normalized left eigenvector
array([[-0.70710678+0.j        , -0.70710678-0.j        ],
 [-0\.        +0.70710678j, -0\.        -0.70710678j]])
>>> linalg.eig(a, left=False, right=True)[1] # normalized right eigenvector
array([[0.70710678+0.j        , 0.70710678-0.j        ],
 [0\.        -0.70710678j, 0\.        +0.70710678j]])

posted @ 2024-06-27 17:07 绝不原创的飞龙阅读(33) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· SciPy-1-12-中文文档-五-

· SciPy-1-12-中文文档-七-

· numpy学习笔记1

· 最后一次大作业-4-numpy、scipy、pandas、matplotlib的读书报告

· Python——第6章 Numpy库的使用

阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· 记一次.NET内存居高不下排查解决与启示
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！

公告

Github：@wizardforcel

简书：@布客飞龙

微博：@布客飞龙

赞助我：

昵称：绝不原创的飞龙
园龄： 5年2个月
粉丝： 66
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

掠夺·扩张·投机·博弈

SciPy 1.12 中文文档（六）

scipy.interpolate.RectBivariateSpline

scipy.interpolate.RectSphereBivariateSpline

scipy.interpolate.BivariateSpline

scipy.interpolate.SmoothBivariateSpline

scipy.interpolate.SmoothSphereBivariateSpline

scipy.interpolate.LSQBivariateSpline

scipy.interpolate.LSQSphereBivariateSpline

scipy.interpolate.bisplrep

scipy.interpolate.bisplev

scipy.interpolate.lagrange

scipy.interpolate.approximate_taylor_polynomial

scipy.interpolate.pade

输入输出（scipy.io）

MATLAB® 文件

IDL® 文件

Matrix Market 文件

无格式的 Fortran 文件

Netcdf

Harwell-Boeing 文件

Wav 音频文件 (scipy.io.wavfile)

scipy.io.loadmat

scipy.io.savemat

scipy.io.whosmat

scipy.io.readsav

scipy.io.mminfo

scipy.io.mmread

scipy.io.mmwrite

scipy.io.FortranFile

scipy.io.FortranEOFError

scipy.io.FortranFormattingError

scipy.io.netcdf_file

scipy.io.netcdf_variable

scipy.io.hb_read

scipy.io.hb_write

scipy.io.wavfile.read

scipy.io.wavfile.write

scipy.io.wavfile.WavFileWarning

scipy.io.arff.loadarff

scipy.io.arff.MetaData

scipy.io.arff.ArffError

scipy.io.arff.ParseArffError

线性代数（scipy.linalg）

基础

特征值问题

Decompositions

矩阵函数

矩阵方程求解器

草图和随机投影

特殊矩阵

低级例程

scipy.linalg.inv

scipy.linalg.solve

scipy.linalg.solve_banded

scipy.linalg.solveh_banded

scipy.linalg.solve_circulant

scipy.linalg.solve_triangular

scipy.linalg.solve_toeplitz

scipy.linalg.matmul_toeplitz

scipy.linalg.det

scipy.linalg.norm

scipy.linalg.lstsq

scipy.linalg.pinv

scipy.linalg.pinvh

scipy.linalg.kron

scipy.linalg.khatri_rao

scipy.linalg.tril

scipy.linalg.triu

scipy.linalg.orthogonal_procrustes

scipy.linalg.matrix_balance

scipy.linalg.subspace_angles

scipy.linalg.bandwidth

scipy.linalg.issymmetric

scipy.linalg.ishermitian

scipy.linalg.LinAlgError

scipy.linalg.LinAlgWarning

scipy.linalg.eig

公告

搜索

`scipy.interpolate.RectBivariateSpline`

`scipy.interpolate.RectSphereBivariateSpline`

`scipy.interpolate.BivariateSpline`

`scipy.interpolate.SmoothBivariateSpline`

`scipy.interpolate.SmoothSphereBivariateSpline`

`scipy.interpolate.LSQBivariateSpline`

`scipy.interpolate.LSQSphereBivariateSpline`

`scipy.interpolate.bisplrep`

`scipy.interpolate.bisplev`

`scipy.interpolate.lagrange`

`scipy.interpolate.approximate_taylor_polynomial`

`scipy.interpolate.pade`

输入输出（`scipy.io`）

Wav 音频文件 (`scipy.io.wavfile`)

`scipy.io.loadmat`

`scipy.io.savemat`

`scipy.io.whosmat`

`scipy.io.readsav`

`scipy.io.mminfo`

`scipy.io.mmread`

`scipy.io.mmwrite`

`scipy.io.FortranFile`

`scipy.io.FortranEOFError`

`scipy.io.FortranFormattingError`

`scipy.io.netcdf_file`

`scipy.io.netcdf_variable`

`scipy.io.hb_read`

`scipy.io.hb_write`

`scipy.io.wavfile.read`

`scipy.io.wavfile.write`

`scipy.io.wavfile.WavFileWarning`

`scipy.io.arff.loadarff`

`scipy.io.arff.MetaData`

`scipy.io.arff.ArffError`

`scipy.io.arff.ParseArffError`

线性代数（`scipy.linalg`）

`scipy.linalg.inv`

`scipy.linalg.solve`

`scipy.linalg.solve_banded`

`scipy.linalg.solveh_banded`

`scipy.linalg.solve_circulant`

`scipy.linalg.solve_triangular`

`scipy.linalg.solve_toeplitz`

`scipy.linalg.matmul_toeplitz`

`scipy.linalg.det`

`scipy.linalg.norm`

`scipy.linalg.lstsq`

`scipy.linalg.pinv`

`scipy.linalg.pinvh`

`scipy.linalg.kron`

`scipy.linalg.khatri_rao`

`scipy.linalg.tril`

`scipy.linalg.triu`

`scipy.linalg.orthogonal_procrustes`

`scipy.linalg.matrix_balance`

`scipy.linalg.subspace_angles`

`scipy.linalg.bandwidth`

`scipy.linalg.issymmetric`

`scipy.linalg.ishermitian`

`scipy.linalg.LinAlgError`

`scipy.linalg.LinAlgWarning`

`scipy.linalg.eig`