SciPy 1.12 中文文档（十五）

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

`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]])

`scipy.linalg.eigvals`

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

scipy.linalg.eigvals(a, b=None, overwrite_a=False, check_finite=True, homogeneous_eigvals=False)

从普通或广义特征值问题计算特征值。

查找一般矩阵的特征值：

a   vr[:,i] = w[i]        b   vr[:,i]

参数：

a(M, M) array_like

将计算其特征值和特征向量的复数或实数矩阵。

b(M, M) array_like，可选

广义特征值问题中的右手边矩阵。如果省略，则假定为单位矩阵。

overwrite_a布尔型，可选

是否覆盖 a 中的数据（可能会提高性能）

check_finite布尔型，可选

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

homogeneous_eigvals布尔型，可选

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

引发：

LinAlgError

如果特征值计算不收敛

另请参见

eig

一般数组的特征值和右特征向量。

eigvalsh

对称或厄米矩阵的特征值

eigvals_banded

对称/厄米带状矩阵的特征值

eigvalsh_tridiagonal

对称/厄米三对角矩阵的特征值

示例

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

`scipy.linalg.eigh`

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

scipy.linalg.eigh(a, b=None, *, lower=True, eigvals_only=False, overwrite_a=False, overwrite_b=False, turbo=<object object>, eigvals=<object object>, type=1, check_finite=True, subset_by_index=None, subset_by_value=None, driver=None)

求解复共轭厄米特或实对称矩阵的标准或广义特征值问题。

寻找数组a的特征值数组w，并可选地找到数组v的特征向量，其中b是正定的，以便对每个特征值λ（w 的第 i 个条目）及其特征向量vi（v 的第 i 列）满足以下条件：

 a @ vi = λ * b @ vi
vi.conj().T @ a @ vi = λ
vi.conj().T @ b @ vi = 1

在标准问题中，假定b是单位矩阵。

参数：

a(M, M) array_like

将计算其特征值和特征向量的复共轭厄米特或实对称矩阵。

b(M, M) array_like, optional

一个复共轭厄米特或实对称明确正定矩阵。如果省略，则假定单位矩阵。

lowerbool, optional

是否从a和（如果适用）b的下三角或上三角中取相关数组数据。（默认：下三角）

eigvals_onlybool, optional

是否仅计算特征值而不计算特征向量。（默认：两者都计算）

subset_by_indexiterable, optional

如果提供，则这个两元素迭代器定义了所需特征值的起始和结束索引（升序且从 0 开始计数）。要返回第二小到第五小的特征值，使用[1, 4]。[n-3, n-1]返回最大的三个。仅在“evr”、“evx”和“gvx”驱动器中可用。通过int()直接转换为整数。

subset_by_valueiterable, optional

如果提供，则这个两元素迭代器定义了半开区间(a, b]，仅返回这些值之间的特征值。仅在“evr”、“evx”和“gvx”驱动器中可用。使用np.inf表示无约束的端点。

driverstr, optional

定义应使用哪个 LAPACK 驱动程序。标准问题的有效选项为“ev”、“evd”、“evr”、“evx”，广义问题的有效选项为“gv”、“gvd”、“gvx”。请参阅备注部分。标准问题的默认值为“evr”。对于广义问题，使用“gvd”进行完整设置，“gvx”进行请求的子集案例。

typeint, optional

对于广义问题，此关键字指定要为w和v解决的问题类型（只接受 1、2、3 作为可能的输入）：

1 =>     a @ v = w @ b @ v
2 => a @ b @ v = w @ v
3 => b @ a @ v = w @ v

对于标准问题，此关键字被忽略。

overwrite_abool, optional

是否覆盖a中的数据（可能提高性能）。默认为 False。

overwrite_bbool, optional

是否覆盖b中的数据（可能提高性能）。默认为 False。

check_finitebool, optional

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

turbobool, optional, deprecated

自版本 1.5.0 起不建议使用：eigh 关键字参数 turbo 已被 driver=gvd 关键字取代，并将在 SciPy 1.14.0 中删除。

eigvalstuple (lo, hi)，可选，已废弃

自版本 1.5.0 起不建议使用：eigh 关键字参数 eigvals 已被 subset_by_index 关键字取代，并将在 SciPy 1.14.0 中删除。

Returns:

w(N,) ndarray

选择的 N (N<=M) 个特征值，按升序排列，根据其重复次数重复。

v(M, N) ndarray

对称/Hermitian 三对角矩阵的归一化特征向量对应于特征值 w[i] 的列 v[:,i]。仅当 eigvals_only=False 时返回。

Raises:

LinAlgError

如果特征值计算不收敛，发生错误或 b 矩阵不是正定的。请注意，如果输入矩阵不对称或 Hermitian，则不会报告错误，但结果将是错误的。

`scipy.linalg.eigvalsh`

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

scipy.linalg.eigvalsh(a, b=None, *, lower=True, overwrite_a=False, overwrite_b=False, turbo=<object object>, eigvals=<object object>, type=1, check_finite=True, subset_by_index=None, subset_by_value=None, driver=None)

解决复共轭厄米特或实对称矩阵的标准或广义特征值问题。

查找数组 a 的特征值数组 w，其中 b 是正定的，使得每个特征值λ（w 的第 i 个条目）及其特征向量 vi（v 的第 i 列）满足：

 a @ vi = λ * b @ vi
vi.conj().T @ a @ vi = λ
vi.conj().T @ b @ vi = 1

在标准问题中，假定 b 为单位矩阵。

参数：

a(M, M)数组类型

将计算其特征值的复共轭厄米特或实对称矩阵。

b(M, M)数组类型，可选

复共轭厄米特或实对称正定矩阵 a。如果省略，则假定为单位矩阵。

lowerbool, optional

是否从 a 和（如果适用）b 的下三角形或上三角形获取相关数组数据。（默认值：lower）

overwrite_abool，可选

是否覆盖 a 中的数据（可能会提高性能）。默认为 False。

overwrite_bbool，可选

是否覆盖 b 中的数据（可能会提高性能）。默认为 False。

typeint, optional

对于广义问题，此关键字指定要为 w 和 v 解决的问题类型（只接受 1、2、3 作为可能的输入）：

1 =>     a @ v = w @ b @ v
2 => a @ b @ v = w @ v
3 => b @ a @ v = w @ v

此关键字在标准问题中被忽略。

check_finitebool，可选

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

subset_by_indexiterable, optional

如果提供，此两元素可迭代对象定义所需特征值的起始和结束索引（升序和从 0 开始索引）。例如，返回第二小到第五小的特征值，使用[1, 4]。返回最大的三个特征值使用[n-3, n-1]。仅适用于“evr”、“evx”和“gvx”驱动程序。这些条目通过int()直接转换为整数。

subset_by_value可迭代对象，可选

如果提供，此两元素可迭代对象定义半开区间‘（a, b]’，如果有的话，仅返回介于这些值之间的特征值。仅适用于“evr”、“evx”和“gvx”驱动程序。使用np.inf表示无约束端点。

driver字符串，可选

定义应使用哪个 LAPACK 驱动程序。有效选项为“ev”、“evd”、“evr”、“evx”（标准问题）和“gv”、“gvd”、“gvx”（广义问题，其中 b 不为 None）。参见scipy.linalg.eigh的注释部分。

turbobool，可选，已弃用

自 1.5.0 版本起已弃用：‘eigvalsh’关键字参数turbo已弃用，推荐使用driver=gvd选项，并将在 SciPy 1.14.0 中移除。

eigvals元组（lo，hi），可选

自版本 1.5.0 起不推荐使用：‘eigvalsh’关键字参数eigvals已被废弃，建议使用subset_by_index选项，将在 SciPy 1.14.0 中移除。

返回结果:

w(N,) ndarray

N（N<=M）个选定特征值，按升序排列，每个特征值根据其重复次数重复。

引发：

LinAlgError

如果特征值计算不收敛，发生错误或 b 矩阵不是正定的。请注意，如果输入矩阵不对称或不是厄米矩阵，不会报告错误，但结果将是错误的。

另请参阅

eigh

对称/厄米矩阵的特征值和右特征向量

eigvals

一般数组的特征值

eigvals_banded

对称/厄米带状矩阵的特征值

eigvalsh_tridiagonal

对称/厄米三对角矩阵的特征值

注意事项

为了允许表示仅具有其上/下三角部分的数组，此函数不会检查输入数组是否为厄米矩阵/对称矩阵。

这个函数作为scipy.linalg.eigh的一个一行缩写，选项eigvals_only=True用于获取特征值而不是特征向量。这里保留它作为一个传统便利功能。使用主函数可以有更多的控制，并且更符合 Python 风格。

示例

更多示例请参见scipy.linalg.eigh。

>>> import numpy as np
>>> from scipy.linalg import eigvalsh
>>> A = np.array([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]])
>>> w = eigvalsh(A)
>>> w
array([-3.74637491, -0.76263923,  6.08502336, 12.42399079])

`scipy.linalg.eig_banded`

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

scipy.linalg.eig_banded(a_band, lower=False, eigvals_only=False, overwrite_a_band=False, select='a', select_range=None, max_ev=0, check_finite=True)

求解实对称或复共轭厄米特带矩阵的特征值问题。

找到矩阵 a 的特征值 w 和可选的右特征向量 v：

a v[:,i] = w[i] v[:,i]
v.H v    = identity

矩阵 a 以下带或上带排序形式存储在 a_band 中：

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

u 是对角线上方的波段数量。

例如 a_band（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 *   *

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

参数：

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

MxM 矩阵 a 的波段。

lowerbool, optional

矩阵是否以下带形式存储（默认为上带形式）。

eigvals_onlybool, optional

仅计算特征值而不计算特征向量。（默认：也计算特征向量）

overwrite_a_bandbool, optional

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

select{‘a’, ‘v’, ‘i’}，可选

计算哪些特征值

select	计算
‘a’	所有特征值
‘v’	区间(min, max]内的特征值
‘i’	索引 min <= i <= max 的特征值

select_range(min, max)，可选

选择的特征值范围。

max_evint, optional

对于 select==’v’，预期最大特征值数。对于 select 的其他值，无意义。

如果有疑问，请不要改动此参数。

check_finitebool, optional

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

w(M,) ndarray

特征值按升序排列，每个按其重复次数重复。

v(M, M) float or complex ndarray

对应于特征值 w[i]的归一化特征向量是列 v[:,i]。仅当eigvals_only=False时才返回。

引发：

LinAlgError

如果特征值计算不收敛。

参见

对称/厄米特带矩阵的特征值。

一般数组的特征值和右特征向量。

对称/厄米特阵列的特征值和右特征向量。

对称/厄米特三对角矩阵的特征值和右特征向量。

示例

>>> import numpy as np
>>> from scipy.linalg import eig_banded
>>> A = np.array([[1, 5, 2, 0], [5, 2, 5, 2], [2, 5, 3, 5], [0, 2, 5, 4]])
>>> Ab = np.array([[1, 2, 3, 4], [5, 5, 5, 0], [2, 2, 0, 0]])
>>> w, v = eig_banded(Ab, lower=True)
>>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
True
>>> w = eig_banded(Ab, lower=True, eigvals_only=True)
>>> w
array([-4.26200532, -2.22987175,  3.95222349, 12.53965359])

仅请求介于[-3, 4]之间的特征值。

>>> w, v = eig_banded(Ab, lower=True, select='v', select_range=[-3, 4])
>>> w
array([-2.22987175,  3.95222349])

`scipy.linalg.eigvals_banded`

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

scipy.linalg.eigvals_banded(a_band, lower=False, overwrite_a_band=False, select='a', select_range=None, check_finite=True)

解决实对称或复厄米特带矩阵特征值问题。

查找矩阵 a 的特征值 w：

a v[:,i] = w[i] v[:,i]
v.H v    = identity

矩阵 a 存储在 a_band 中，可以是下三角或上三角顺序：

a_band[u + i - j, j] == a[i,j]（如果为上三角形式；i <= j） a_band[ i - j, j] == a[i,j]（如果为下三角形式；i >= j）

其中 u 是对角线上方带的数量。

a_band 的示例（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 *   *

标有 * 的单元格未被使用。

参数：

a_band(u+1, M) array_like

M × M 矩阵 a 的带。

lowerbool, 可选

矩阵是下三角形式。（默认为上三角形式）

overwrite_a_bandbool, 可选

丢弃 a_band 中的数据（可能提高性能）

select{‘a’, ‘v’, ‘i’}, 可选

要计算的特征值

select	计算
‘a’	所有特征值
‘v’	特征值在区间 (min, max] 内
‘i’	特征值在 min <= i <= max 的索引处

select_range(min, max), 可选

选择特征值的范围

check_finitebool, 可选

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

w(M,) ndarray

特征值，按升序排列，每个按其重数重复。

异常：

LinAlgError

如果特征值计算不收敛。

另请参阅

eig_banded

对称/厄米特带矩阵的特征值和右特征向量

eigvalsh_tridiagonal

对称/厄米特三对角矩阵的特征值

eigvals

一般数组的特征值

eigh

对称/厄米特数组的特征值和右特征向量

eig

非对称数组的特征值和右特征向量

示例

>>> import numpy as np
>>> from scipy.linalg import eigvals_banded
>>> A = np.array([[1, 5, 2, 0], [5, 2, 5, 2], [2, 5, 3, 5], [0, 2, 5, 4]])
>>> Ab = np.array([[1, 2, 3, 4], [5, 5, 5, 0], [2, 2, 0, 0]])
>>> w = eigvals_banded(Ab, lower=True)
>>> w
array([-4.26200532, -2.22987175,  3.95222349, 12.53965359])

`scipy.linalg.eigh_tridiagonal`

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

scipy.linalg.eigh_tridiagonal(d, e, eigvals_only=False, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')

求解实对称三对角矩阵的特征值问题。

查找矩阵a的特征值w和可选的右特征向量v：

a v[:,i] = w[i] v[:,i]
v.H v    = identity

对于具有对角元素d和非对角元素e的实对称矩阵a。

参数：

dndarray，形状（ndim，）

数组的对角元素。

endarray，形状（ndim-1，）

数组的非对角元素。

eigvals_onlybool，可选

仅计算特征值，不计算特征向量。（默认：同时计算特征向量）

select{‘a’，‘v’，‘i’}，可选

要计算的特征值

select	计算
‘a’	所有特征值
‘v’	特征值在区间(min, max]内
‘i’	特征值满足 min <= i <= max 的条件

select_range(最小值, 最大值), 可选

选择的特征值范围

check_finitebool，可选

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

tolfloat

每个特征值所需的绝对容差（仅在‘stebz’为LAPACK 驱动器时使用）。如果 <= 0.（默认），则使用机器精度 eps 乘以矩阵a的 1-范数，其中 eps 是机器精度，|a|是矩阵a的 1-范数。

lapack_driverstr

LAPACK 函数的使用，可以是‘auto’，‘stemr’，‘stebz’，‘sterf’或‘stev’。当‘auto’（默认）时，如果select='a'，则使用‘stemr’，否则使用‘stebz’来找特征值。当使用‘stebz’来找特征值且eigvals_only=False时，会调用第二次 LAPACK 函数（?STEIN）来找对应的特征向量。只有当eigvals_only=True且select='a'时才能使用‘sterf’。只有当select='a'时才能使用‘stev’。

w(M,) 数组

特征值按升序排列，每个根据其重复次数重复。

v(M, M) 数组

与特征值w[i]对应的归一化特征向量是列v[:,i]。仅当eigvals_only=False时返回。

Raises:

LinAlgError

如果特征值计算不收敛。

另见

eigvalsh_tridiagonal

对称/Hermitian 三对角矩阵的特征值

eig

非对称数组的特征值和右特征向量

eigh

对称/Hermitian 数组的特征值和右特征向量

eig_banded

对称/Hermitian 带状矩阵的特征值和右特征向量

注意事项

此函数利用了 LAPACK S/DSTEMR 例程。

示例

>>> import numpy as np
>>> from scipy.linalg import eigh_tridiagonal
>>> d = 3*np.ones(4)
>>> e = -1*np.ones(3)
>>> w, v = eigh_tridiagonal(d, e)
>>> A = np.diag(d) + np.diag(e, k=1) + np.diag(e, k=-1)
>>> np.allclose(A @ v - v @ np.diag(w), np.zeros((4, 4)))
True

`scipy.linalg.eigvalsh_tridiagonal`

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

scipy.linalg.eigvalsh_tridiagonal(d, e, select='a', select_range=None, check_finite=True, tol=0.0, lapack_driver='auto')

解实对称三对角矩阵的特征值问题。

计算 a 的特征值 w：

a v[:,i] = w[i] v[:,i]
v.H v    = identity

对于实对称矩阵 a，其对角元素为 d，非对角元素为 e。

参数：

dndarray，形状为 (ndim,)

数组的对角元素。

endarray，形状为 (ndim-1,)

数组的非对角元素。

select{‘a’, ‘v’, ‘i’}，可选

要计算的特征值

select	计算的
‘a’	所有特征值
‘v’	区间 (min, max] 中的特征值
‘i’	具有指数 `min <= i <= max` 的特征值

select_range(min, max)，可选

选择的特征值范围

check_finitebool，可选

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

tolfloat

每个特征值所需的绝对容差（仅在 lapack_driver='stebz' 时使用）。如果一个特征值（或簇）位于此宽度的区间内，则认为其已收敛。如果 <= 0（默认），则使用 eps*|a| 的值，其中 eps 是机器精度，而 |a| 是矩阵 a 的 1-范数。

lapack_driverstr

要使用的 LAPACK 函数，可以是 ‘auto’、‘stemr’、‘stebz’、‘sterf’ 或 ‘stev’。当 select='a' 时，默认使用 ‘stemr’，否则使用 ‘stebz’。只有当 select='a' 时才能使用 ‘sterf’ 和 ‘stev’。

w(M,) ndarray

按升序排列的特征值，每个根据其重数重复。

引发：

LinAlgError

如果特征值计算不收敛。

另请参见

eigh_tridiagonal

对称/Hermitian 三对角矩阵的特征值和右特征向量

示例

>>> import numpy as np
>>> from scipy.linalg import eigvalsh_tridiagonal, eigvalsh
>>> d = 3*np.ones(4)
>>> e = -1*np.ones(3)
>>> w = eigvalsh_tridiagonal(d, e)
>>> A = np.diag(d) + np.diag(e, k=1) + np.diag(e, k=-1)
>>> w2 = eigvalsh(A)  # Verify with other eigenvalue routines
>>> np.allclose(w - w2, np.zeros(4))
True

`scipy.linalg.lu`

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

scipy.linalg.lu(a, permute_l=False, overwrite_a=False, check_finite=True, p_indices=False)

计算带有部分枢轴的矩阵的 LU 分解。

分解满足：

A = P @ L @ U

其中P是一个排列矩阵，L是具有单位对角线元素的下三角矩阵，U是上三角矩阵。如果将permute_l设置为True，则L已排列并且满足A = L @ U。

参数：

a(M, N) array_like

要分解的数组

permute_lbool，可选

执行乘法 P*L（默认情况下不排列）

overwrite_abool，可选

是否覆盖数据中的数据（可能提高性能）

check_finitebool，可选

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

p_indicesbool，可选

如果为True，则返回排列信息作为行索引。出于向后兼容性的原因，默认为False。

(如果 permute_l 是 False)

p(…, M, M) ndarray

取决于p_indices的排列数组或向量

l(…, M, K) ndarray

具有单位对角线的下三角或梯形数组。K = min(M, N)

u(…, K, N) ndarray

上三角或梯形数组

(如果 permute_l 是 True)

pl(…, M, K) ndarray

排列后的 L 矩阵。K = min(M, N)

u(…, K, N) ndarray

上三角或梯形数组

注释

排列矩阵成本高昂，因为它们只是L的行重新排序，因此强烈建议使用索引，如果需要排列。在 2D 情况下，关系简单地变成A = L[P, :] @ U。在更高维度中，最好使用permute_l以避免复杂的索引技巧。

在 2D 情况下，如果出于某种原因需要索引，则仍然需要排列矩阵，可以通过np.eye(M)[P, :]构造。

示例

>>> import numpy as np
>>> from scipy.linalg import lu
>>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
>>> p, l, u = lu(A)
>>> np.allclose(A, p @ l @ u)
True
>>> p  # Permutation matrix
array([[0., 1., 0., 0.],  # Row index 1
 [0., 0., 0., 1.],  # Row index 3
 [1., 0., 0., 0.],  # Row index 0
 [0., 0., 1., 0.]]) # Row index 2
>>> p, _, _ = lu(A, p_indices=True)
>>> p
array([1, 3, 0, 2])  # as given by row indices above
>>> np.allclose(A, l[p, :] @ u)
True

我们也可以使用 nd 数组，例如，一个 4D 数组的演示：

>>> rng = np.random.default_rng()
>>> A = rng.uniform(low=-4, high=4, size=[3, 2, 4, 8])
>>> p, l, u = lu(A)
>>> p.shape, l.shape, u.shape
((3, 2, 4, 4), (3, 2, 4, 4), (3, 2, 4, 8))
>>> np.allclose(A, p @ l @ u)
True
>>> PL, U = lu(A, permute_l=True)
>>> np.allclose(A, PL @ U)
True

`scipy.linalg.lu_factor`

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

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

计算矩阵的置换 LU 分解。

分解是：

A = P L U

当 P 是一个置换矩阵时，L 是单位对角元的下三角矩阵，而 U 是上三角矩阵。

参数：

a(M, N) 数组样式

要分解的矩阵

overwrite_a布尔型，可选

是否覆盖 A 中的数据（可能提高性能）

check_finite布尔型，可选

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

lu(M, N) ndarray

包含 U 在其上三角形中，L 在其下三角形中的矩阵。L 的单位对角线元素未存储。

piv(K,) ndarray

表示置换矩阵 P 的枢轴索引：矩阵的第 i 行与行 piv[i]互换。形状为(K,)，其中K = min(M, N)。

另请参见

lu

提供更用户友好的 LU 因子分解格式

lu_solve

使用矩阵的 LU 分解解方程系统

注意事项

这是来自 LAPACK 的*GETRF例程的包装器。与lu不同，它将 L 和 U 因子输出到单个数组中，并返回枢轴索引而不是置换矩阵。

虽然底层的*GETRF例程返回基于 1 的枢轴索引，但lu_factor返回的piv数组包含基于 0 的索引。

示例

>>> import numpy as np
>>> from scipy.linalg import lu_factor
>>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
>>> lu, piv = lu_factor(A)
>>> piv
array([2, 2, 3, 3], dtype=int32)

将 LAPACK 的piv数组转换为 NumPy 索引并测试置换。

>>> def pivot_to_permutation(piv):
...     perm = np.arange(len(piv))
...     for i in range(len(piv)):
...         perm[i], perm[piv[i]] = perm[piv[i]], perm[i]
...     return perm
...
>>> p_inv = pivot_to_permutation(piv)
>>> p_inv
array([2, 0, 3, 1])
>>> L, U = np.tril(lu, k=-1) + np.eye(4), np.triu(lu)
>>> np.allclose(A[p_inv] - L @ U, np.zeros((4, 4)))
True

P L U 中的 P 矩阵由逆置换定义，并且可以使用 argsort 恢复：

>>> p = np.argsort(p_inv)
>>> p
array([1, 3, 0, 2])
>>> np.allclose(A - L[p] @ U, np.zeros((4, 4)))
True

或者：

>>> P = np.eye(4)[p]
>>> np.allclose(A - P @ L @ U, np.zeros((4, 4)))
True

`scipy.linalg.lu_solve`

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

scipy.linalg.lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True)

解方程系统 a x = b，给定矩阵 a 的 LU 分解

参数：

(lu, piv)

系数矩阵 a 的因式分解，由 lu_factor 给出。特别是 piv 是从 0 开始的枢轴索引。

b数组

右手边

trans{0, 1, 2}，可选

要解决的系统类型：

trans	system
0	a x = b
1	a^T x = b
2	a^H x = b

overwrite_b布尔型，可选

是否覆盖 b 中的数据（可能提高性能）

check_finite布尔型，可选

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

x数组

系统的解决方案

另请参阅

lu_factor

LU 分解矩阵

示例

>>> import numpy as np
>>> from scipy.linalg import lu_factor, lu_solve
>>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
>>> b = np.array([1, 1, 1, 1])
>>> lu, piv = lu_factor(A)
>>> x = lu_solve((lu, piv), b)
>>> np.allclose(A @ x - b, np.zeros((4,)))
True

`scipy.linalg.svd`

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

scipy.linalg.svd(a, full_matrices=True, compute_uv=True, overwrite_a=False, check_finite=True, lapack_driver='gesdd')

奇异值分解。

将矩阵a因子分解为两个单位矩阵U和Vh，以及奇异值（实数、非负）的一维数组s，使得a == U @ S @ Vh，其中S是具有主对角线s的适当形状的零矩阵。

参数：

a：(M, N)的 array_like

要分解的矩阵。

full_matrices：bool，可选

如果为 True（默认），U和Vh的形状为(M, M)，(N, N)。如果为 False，则形状为(M, K)和(K, N)，其中K = min(M, N)。

compute_uv：bool，可选

是否计算U和Vh以及s。默认为 True。

overwrite_a：bool，可选

是否覆盖a；可能提高性能。默认为 False。

check_finite：bool，可选

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

lapack_driver：{‘gesdd’, ‘gesvd’}，可选

是否使用更高效的分而治之方法（'gesdd'）或一般的矩形方法（'gesvd'）来计算 SVD。MATLAB 和 Octave 使用'gesvd'方法。默认为'gesdd'。

0.18 版中的新功能。

U：ndarray

单位矩阵，左奇异向量作为列。形状为(M, M)或(M, K)，取决于full_matrices。

s：ndarray

奇异值，按非增顺序排序。形状为(K,)，其中K = min(M, N)。

Vh：ndarray

单位矩阵，右奇异向量作为行。形状为(N, N)或(K, N)，取决于full_matrices。

对于compute_uv=False，仅返回s。

引发：

LinAlgError

如果奇异值分解计算不收敛。

另请参阅

scipy.linalg.svdvals

计算矩阵的奇异值。

diagsvd

构造 Sigma 矩阵，给定向量 s。

示例

>>> import numpy as np
>>> from scipy import linalg
>>> rng = np.random.default_rng()
>>> m, n = 9, 6
>>> a = rng.standard_normal((m, n)) + 1.j*rng.standard_normal((m, n))
>>> U, s, Vh = linalg.svd(a)
>>> U.shape,  s.shape, Vh.shape
((9, 9), (6,), (6, 6))

从分解重建原始矩阵：

>>> sigma = np.zeros((m, n))
>>> for i in range(min(m, n)):
...     sigma[i, i] = s[i]
>>> a1 = np.dot(U, np.dot(sigma, Vh))
>>> np.allclose(a, a1)
True

或者，使用full_matrices=False（注意此时U的形状为(m, n)而不是(m, m)）：

>>> U, s, Vh = linalg.svd(a, full_matrices=False)
>>> U.shape, s.shape, Vh.shape
((9, 6), (6,), (6, 6))
>>> S = np.diag(s)
>>> np.allclose(a, np.dot(U, np.dot(S, Vh)))
True

>>> s2 = linalg.svd(a, compute_uv=False)
>>> np.allclose(s, s2)
True

SciPy-1-12-中文文档-十五-

SciPy 1.12 中文文档（十五）

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.linalg.eigvals

scipy.linalg.eigh

scipy.linalg.eigvalsh

scipy.linalg.eig_banded

scipy.linalg.eigvals_banded

scipy.linalg.eigh_tridiagonal

scipy.linalg.eigvalsh_tridiagonal

scipy.linalg.lu

scipy.linalg.lu_factor

scipy.linalg.lu_solve

scipy.linalg.svd

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

`scipy.linalg.eigh`

`scipy.linalg.eigvalsh`

`scipy.linalg.eig_banded`

`scipy.linalg.eigvals_banded`

`scipy.linalg.eigh_tridiagonal`

`scipy.linalg.eigvalsh_tridiagonal`

`scipy.linalg.lu`

`scipy.linalg.lu_factor`

`scipy.linalg.lu_solve`

`scipy.linalg.svd`