SciPy 1.12 中文文档（十四）

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

`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{0, 1, 2, ‘N’, ‘T’, ‘C’}, 可选

要解决的系统类型：

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{int, inf, -inf, ‘fro’, ‘nuc’, None}，可选

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

axis{int, 2-tuple of ints, None}, 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{i,j} 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-1-12-中文文档-十四-

SciPy 1.12 中文文档（十四）

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