线性代数

*(A::AbstractMatrix, B::AbstractMatrix)

矩阵乘法。

示例

julia> [1 1; 0 1] * [1 0; 1 1]
2×2 Matrix{Int64}:
 2  1
 1  1

\(A, B)

使用多算法的矩阵除法。对于输入矩阵 A 和 B，结果 X 使得 A*X == B，其中 A 为方阵。使用的求解器取决于 A 的结构。如果 A 为上三角或下三角（或对角线），则不需要对 A 进行分解，并且系统用正向或反向替换来求解。对于非三角方阵，使用 LU 分解。

对于矩形 A，结果是通过 A 的带 pivoting 的 QR 分解以及基于 R 因子的 A 的秩估计计算的最小范数最小二乘解。

当 A 为稀疏矩阵时，使用类似的多算法。对于不定矩阵，LDLt 分解在数值分解期间不使用 pivoting，因此即使对于可逆矩阵，该过程也可能失败。

另请参见：factorize、pinv。

示例

julia> A = [1 0; 1 -2]; B = [32; -4];

julia> X = A \ B
2-element Vector{Float64}:
 32.0
 18.0

julia> A * X == B
true

A / B

矩阵右除：A / B 等效于 (B' \ A')'，其中 \ 为左除运算符。对于方阵，结果 X 使得 A == X*B。

另请参见：rdiv!。

示例

julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

julia> X = A / B
2×3 Matrix{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

julia> isapprox(A, X*B)
true

julia> isapprox(X, A*pinv(B))
true

SingularException

当输入矩阵具有一个或多个零值特征值并且不可逆时抛出的异常。无法计算涉及此类矩阵的线性求解。info 字段指示奇异值（之一）的位置。

PosDefException

当输入矩阵不是 正定的 时抛出的异常。一些线性代数函数和分解仅适用于正定矩阵。info 字段指示小于/等于 0 的特征值（之一）的位置。

ZeroPivotException <: Exception

当矩阵分解/求解遇到主元（对角线）位置上的零并且无法继续时抛出的异常。这可能不意味着矩阵是奇异的：尝试切换到其他分解（例如带 pivoting 的 LU）可能是有效的，该分解可以重新排序变量以消除虚假的零主元。info 字段指示零主元（之一）的位置。

dot(x, y)
x ⋅ y

计算两个向量的点积。对于复向量，第一个向量被共轭。

dot 也适用于任意可迭代对象，包括任何维度的数组，只要在元素上定义了 dot。

dot 在语义上等效于 sum(dot(vx,vy) for (vx,vy) in zip(x, y))，附加限制是参数必须具有相等的长度。

x ⋅ y（其中 ⋅ 可以通过在 REPL 中自动补全 \cdot 来键入）是 dot(x, y) 的同义词。

示例

julia> dot([1; 1], [2; 3])
5

julia> dot([im; im], [1; 1])
0 - 2im

julia> dot(1:5, 2:6)
70

julia> x = fill(2., (5,5));

julia> y = fill(3., (5,5));

julia> dot(x, y)
150.0

dot(x, A, y)

计算两个向量 x 和 y 之间的广义点积 dot(x, A*y)，无需存储 A*y 的中间结果。与两个参数的 dot(_,_) 一样，它递归地进行。此外，对于复向量，第一个向量被共轭。

示例

julia> dot([1; 1], [1 2; 3 4], [2; 3])
26

julia> dot(1:5, reshape(1:25, 5, 5), 2:6)
4850

julia> ⋅(1:5, reshape(1:25, 5, 5), 2:6) == dot(1:5, reshape(1:25, 5, 5), 2:6)
true

cross(x, y)
×(x,y)

计算两个 3 向量之间的叉积。

示例

julia> a = [0;1;0]
3-element Vector{Int64}:
 0
 1
 0

julia> b = [0;0;1]
3-element Vector{Int64}:
 0
 0
 1

julia> cross(a,b)
3-element Vector{Int64}:
 1
 0
 0

axpy!(α, x::AbstractArray, y::AbstractArray)

用 x * α + y 覆盖 y 并返回 y。如果 x 和 y 具有相同的轴，则它等效于 y .+= x .* a。

示例

julia> x = [1; 2; 3];

julia> y = [4; 5; 6];

julia> axpy!(2, x, y)
3-element Vector{Int64}:
  6
  9
 12

axpby!(α, x::AbstractArray, β, y::AbstractArray)

用 x * α + y * β 覆盖 y 并返回 y。如果 x 和 y 具有相同的轴，则它等效于 y .= x .* a .+ y .* β。

示例

julia> x = [1; 2; 3];

julia> y = [4; 5; 6];

julia> axpby!(2, x, 2, y)
3-element Vector{Int64}:
 10
 14
 18

rotate!(x, y, c, s)

用 c*x + s*y 覆盖 x 以及用 -conj(s)*x + c*y 覆盖 y。返回 x 和 y。

reflect!(x, y, c, s)

用 c*x + s*y 覆盖 x 以及用 conj(s)*x - c*y 覆盖 y。返回 x 和 y。

factorize(A)

根据输入矩阵的类型计算 A 的便捷分解。factorize 检查 A 以查看它是否是对称/三角/等等。如果 A 作为通用矩阵传递。factorize 检查 A 的每个元素以验证/排除每个属性。它将在它能够排除对称/三角结构后立即短路。返回值可以重复使用以有效地解决多个系统。例如：A=factorize(A); x=A\b; y=A\C。

如果 factorize 在 Hermitian 正定矩阵上调用，例如，则 factorize 将返回 Cholesky 分解。

示例

julia> A = Array(Bidiagonal(fill(1.0, (5, 5)), :U))
5×5 Matrix{Float64}:
 1.0  1.0  0.0  0.0  0.0
 0.0  1.0  1.0  0.0  0.0
 0.0  0.0  1.0  1.0  0.0
 0.0  0.0  0.0  1.0  1.0
 0.0  0.0  0.0  0.0  1.0

julia> factorize(A) # factorize will check to see that A is already factorized
5×5 Bidiagonal{Float64, Vector{Float64}}:
 1.0  1.0   ⋅    ⋅    ⋅
  ⋅   1.0  1.0   ⋅    ⋅
  ⋅    ⋅   1.0  1.0   ⋅
  ⋅    ⋅    ⋅   1.0  1.0
  ⋅    ⋅    ⋅    ⋅   1.0

这将返回一个 5×5 Bidiagonal{Float64}，现在可以将其传递给其他线性代数函数（例如特征值求解器），这些函数将使用专门的方法来处理 Bidiagonal 类型。

Diagonal(V::AbstractVector)

用 V 作为其对角线构建一个延迟矩阵。

另请参见 UniformScaling 以获取延迟单位矩阵 I、diagm 以创建密集矩阵以及 diag 以提取对角元素。

示例

julia> d = Diagonal([1, 10, 100])
3×3 Diagonal{Int64, Vector{Int64}}:
 1   ⋅    ⋅
 ⋅  10    ⋅
 ⋅   ⋅  100

julia> diagm([7, 13])
2×2 Matrix{Int64}:
 7   0
 0  13

julia> ans + I
2×2 Matrix{Int64}:
 8   0
 0  14

julia> I(2)
2×2 Diagonal{Bool, Vector{Bool}}:
 1  ⋅
 ⋅  1

请注意，一列矩阵不被视为向量，而是调用方法 Diagonal(A::AbstractMatrix)，该方法提取 1 元素 diag(A)

julia> A = transpose([7.0 13.0])
2×1 transpose(::Matrix{Float64}) with eltype Float64:
  7.0
 13.0

julia> Diagonal(A)
1×1 Diagonal{Float64, Vector{Float64}}:
 7.0

Diagonal(A::AbstractMatrix)

从 A 的对角线构建一个矩阵。

示例

julia> A = permutedims(reshape(1:15, 5, 3))
3×5 Matrix{Int64}:
  1   2   3   4   5
  6   7   8   9  10
 11  12  13  14  15

julia> Diagonal(A)
3×3 Diagonal{Int64, Vector{Int64}}:
 1  ⋅   ⋅
 ⋅  7   ⋅
 ⋅  ⋅  13

julia> diag(A, 2)
3-element Vector{Int64}:
  3
  9
 15

Diagonal{T}(undef, n)

构建一个长度为 n 的未初始化 Diagonal{T}。参见 undef。

Bidiagonal(dv::V, ev::V, uplo::Symbol) where V <: AbstractVector

使用给定的对角线 (dv) 和非对角线 (ev) 向量构造上 (uplo=:U) 或下 (uplo=:L) 双对角矩阵。结果类型为 Bidiagonal，并提供高效的专用线性求解器，但可以使用 convert(Array, _)（或简写为 Array(_)）转换为普通矩阵。ev 的长度必须比 dv 的长度少 1。

示例

julia> dv = [1, 2, 3, 4]
4-element Vector{Int64}:
 1
 2
 3
 4

julia> ev = [7, 8, 9]
3-element Vector{Int64}:
 7
 8
 9

julia> Bu = Bidiagonal(dv, ev, :U) # ev is on the first superdiagonal
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 ⋅  2  8  ⋅
 ⋅  ⋅  3  9
 ⋅  ⋅  ⋅  4

julia> Bl = Bidiagonal(dv, ev, :L) # ev is on the first subdiagonal
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 7  2  ⋅  ⋅
 ⋅  8  3  ⋅
 ⋅  ⋅  9  4

Bidiagonal(A, uplo::Symbol)

从 A 的主对角线及其第一个上 (如果 uplo=:U) 或下对角线 (如果 uplo=:L) 构造 Bidiagonal 矩阵。

示例

julia> A = [1 1 1 1; 2 2 2 2; 3 3 3 3; 4 4 4 4]
4×4 Matrix{Int64}:
 1  1  1  1
 2  2  2  2
 3  3  3  3
 4  4  4  4

julia> Bidiagonal(A, :U) # contains the main diagonal and first superdiagonal of A
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  1  ⋅  ⋅
 ⋅  2  2  ⋅
 ⋅  ⋅  3  3
 ⋅  ⋅  ⋅  4

julia> Bidiagonal(A, :L) # contains the main diagonal and first subdiagonal of A
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 2  2  ⋅  ⋅
 ⋅  3  3  ⋅
 ⋅  ⋅  4  4

SymTridiagonal(dv::V, ev::V) where V <: AbstractVector

分别从对角线 (dv) 和第一个子/上对角线 (ev) 构造对称三对角矩阵。结果类型为 SymTridiagonal，并提供高效的专用特征值求解器，但可以使用 convert(Array, _)（或简写为 Array(_)）转换为普通矩阵。

对于 SymTridiagonal 块矩阵，dv 的元素将被对称化。参数 ev 被解释为上对角线。来自下对角线的块是 (具体化) 对应上对角线块的转置。

示例

julia> dv = [1, 2, 3, 4]
4-element Vector{Int64}:
 1
 2
 3
 4

julia> ev = [7, 8, 9]
3-element Vector{Int64}:
 7
 8
 9

julia> SymTridiagonal(dv, ev)
4×4 SymTridiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 7  2  8  ⋅
 ⋅  8  3  9
 ⋅  ⋅  9  4

julia> A = SymTridiagonal(fill([1 2; 3 4], 3), fill([1 2; 3 4], 2));

julia> A[1,1]
2×2 Symmetric{Int64, Matrix{Int64}}:
 1  2
 2  4

julia> A[1,2]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> A[2,1]
2×2 Matrix{Int64}:
 1  3
 2  4

SymTridiagonal(A::AbstractMatrix)

从对称矩阵 A 的对角线和第一个上对角线构造对称三对角矩阵。

示例

julia> A = [1 2 3; 2 4 5; 3 5 6]
3×3 Matrix{Int64}:
 1  2  3
 2  4  5
 3  5  6

julia> SymTridiagonal(A)
3×3 SymTridiagonal{Int64, Vector{Int64}}:
 1  2  ⋅
 2  4  5
 ⋅  5  6

julia> B = reshape([[1 2; 2 3], [1 2; 3 4], [1 3; 2 4], [1 2; 2 3]], 2, 2);

julia> SymTridiagonal(B)
2×2 SymTridiagonal{Matrix{Int64}, Vector{Matrix{Int64}}}:
 [1 2; 2 3]  [1 3; 2 4]
 [1 2; 3 4]  [1 2; 2 3]

Tridiagonal(dl::V, d::V, du::V) where V <: AbstractVector

分别从第一个下对角线、对角线和第一个上对角线构造三对角矩阵。结果类型为 Tridiagonal，并提供高效的专用线性求解器，但可以使用 convert(Array, _)（或简写为 Array(_)）转换为普通矩阵。dl 和 du 的长度必须比 d 的长度少 1。

示例

julia> dl = [1, 2, 3];

julia> du = [4, 5, 6];

julia> d = [7, 8, 9, 0];

julia> Tridiagonal(dl, d, du)
4×4 Tridiagonal{Int64, Vector{Int64}}:
 7  4  ⋅  ⋅
 1  8  5  ⋅
 ⋅  2  9  6
 ⋅  ⋅  3  0

Tridiagonal(A)

从矩阵 A 的第一个下对角线、对角线和第一个上对角线构造三对角矩阵。

示例

julia> A = [1 2 3 4; 1 2 3 4; 1 2 3 4; 1 2 3 4]
4×4 Matrix{Int64}:
 1  2  3  4
 1  2  3  4
 1  2  3  4
 1  2  3  4

julia> Tridiagonal(A)
4×4 Tridiagonal{Int64, Vector{Int64}}:
 1  2  ⋅  ⋅
 1  2  3  ⋅
 ⋅  2  3  4
 ⋅  ⋅  3  4

Symmetric(A, uplo=:U)

构造矩阵 A 的上 (如果 uplo = :U) 或下 (如果 uplo = :L) 三角形的 Symmetric 视图。

Symmetric 视图主要用于实对称矩阵，对于这些矩阵，针对 Symmetric 类型启用了专用算法（例如特征值问题）。更一般地说，另请参见 Hermitian(A)，用于 Hermitian 矩阵 A == A'，它在实矩阵中实际上等效于 Symmetric，但对于复矩阵也很有用。（而复 Symmetric 矩阵是支持的，但没有或几乎没有专用算法。）

要计算实矩阵的对称部分，或者更一般地计算实或复矩阵 A 的 Hermitian 部分 (A + A') / 2，请使用 hermitianpart。

示例

julia> A = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
 1  2  3
 4  5  6
 7  8  9

julia> Supper = Symmetric(A)
3×3 Symmetric{Int64, Matrix{Int64}}:
 1  2  3
 2  5  6
 3  6  9

julia> Slower = Symmetric(A, :L)
3×3 Symmetric{Int64, Matrix{Int64}}:
 1  4  7
 4  5  8
 7  8  9

julia> hermitianpart(A)
3×3 Hermitian{Float64, Matrix{Float64}}:
 1.0  3.0  5.0
 3.0  5.0  7.0
 5.0  7.0  9.0

请注意，除非 A 本身是对称的（例如，如果 A == transpose(A)），否则 Supper 将不会等于 Slower。

Hermitian(A, uplo=:U)

构造矩阵 A 的上 (如果 uplo = :U) 或下 (如果 uplo = :L) 三角形的 Hermitian 视图。

要计算 A 的 Hermitian 部分，请使用 hermitianpart。

示例

julia> A = [1 2+2im 3-3im; 4 5 6-6im; 7 8+8im 9]
3×3 Matrix{Complex{Int64}}:
 1+0im  2+2im  3-3im
 4+0im  5+0im  6-6im
 7+0im  8+8im  9+0im

julia> Hupper = Hermitian(A)
3×3 Hermitian{Complex{Int64}, Matrix{Complex{Int64}}}:
 1+0im  2+2im  3-3im
 2-2im  5+0im  6-6im
 3+3im  6+6im  9+0im

julia> Hlower = Hermitian(A, :L)
3×3 Hermitian{Complex{Int64}, Matrix{Complex{Int64}}}:
 1+0im  4+0im  7+0im
 4+0im  5+0im  8-8im
 7+0im  8+8im  9+0im

julia> hermitianpart(A)
3×3 Hermitian{ComplexF64, Matrix{ComplexF64}}:
 1.0+0.0im  3.0+1.0im  5.0-1.5im
 3.0-1.0im  5.0+0.0im  7.0-7.0im
 5.0+1.5im  7.0+7.0im  9.0+0.0im

请注意，除非 A 本身是 Hermitian 的（例如，如果 A == adjoint(A)），否则 Hupper 将不会等于 Hlower。

所有非实部对角线将被忽略。

Hermitian(fill(complex(1,1), 1, 1)) == fill(1, 1, 1)

LowerTriangular(A::AbstractMatrix)

构造矩阵 A 的 LowerTriangular 视图。

示例

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> LowerTriangular(A)
3×3 LowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅    ⋅
 4.0  5.0   ⋅
 7.0  8.0  9.0

UpperTriangular(A::AbstractMatrix)

构造矩阵 A 的 UpperTriangular 视图。

示例

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> UpperTriangular(A)
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 1.0  2.0  3.0
  ⋅   5.0  6.0
  ⋅    ⋅   9.0

UnitLowerTriangular(A::AbstractMatrix)

构造矩阵 A 的 UnitLowerTriangular 视图。此视图在其对角线上具有 A 的 eltype 的 oneunit。

示例

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> UnitLowerTriangular(A)
3×3 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅    ⋅
 4.0  1.0   ⋅
 7.0  8.0  1.0

UnitUpperTriangular(A::AbstractMatrix)

构造矩阵 A 的 UnitUpperTriangular 视图。此视图在其对角线上具有 A 的 eltype 的 oneunit。

示例

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> UnitUpperTriangular(A)
3×3 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  2.0  3.0
  ⋅   1.0  6.0
  ⋅    ⋅   1.0

UpperHessenberg(A::AbstractMatrix)

构造矩阵 A 的 UpperHessenberg 视图。忽略 A 中第一个下对角线以下的条目。

为 H \ b、det(H) 以及类似内容实现了高效算法。

另请参见 hessenberg 函数，用于将任何矩阵分解为类似的上 Hessenberg 矩阵。

如果 F::Hessenberg 是分解对象，则可以使用 F.Q 访问酉矩阵，可以使用 F.H 访问 Hessenberg 矩阵。当提取 Q 时，结果类型是 HessenbergQ 对象，可以使用 convert(Array, _)（或简写为 Array(_)）转换为普通矩阵。

迭代分解将生成因子 F.Q 和 F.H。

示例

julia> A = [1 2 3 4; 5 6 7 8; 9 10 11 12; 13 14 15 16]
4×4 Matrix{Int64}:
  1   2   3   4
  5   6   7   8
  9  10  11  12
 13  14  15  16

julia> UpperHessenberg(A)
4×4 UpperHessenberg{Int64, Matrix{Int64}}:
 1   2   3   4
 5   6   7   8
 ⋅  10  11  12
 ⋅   ⋅  15  16

UniformScaling{T<:Number}

通用大小的均匀缩放运算符，定义为标量乘以恒等运算符 λ*I。尽管没有显式的 size，但在许多情况下它的作用类似于矩阵，并且包括对某些索引的支持。另请参见 I。

示例

julia> J = UniformScaling(2.)
UniformScaling{Float64}
2.0*I

julia> A = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> J*A
2×2 Matrix{Float64}:
 2.0  4.0
 6.0  8.0

julia> J[1:2, 1:2]
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  2.0

I

一个类型为 UniformScaling 的对象，表示任何大小的恒等矩阵。

示例

julia> fill(1, (5,6)) * I == fill(1, (5,6))
true

julia> [1 2im 3; 1im 2 3] * I
2×3 Matrix{Complex{Int64}}:
 1+0im  0+2im  3+0im
 0+1im  2+0im  3+0im

(I::UniformScaling)(n::Integer)

从 UniformScaling 构造 Diagonal 矩阵。

示例

julia> I(3)
3×3 Diagonal{Bool, Vector{Bool}}:
 1  ⋅  ⋅
 ⋅  1  ⋅
 ⋅  ⋅  1

julia> (0.7*I)(3)
3×3 Diagonal{Float64, Vector{Float64}}:
 0.7   ⋅    ⋅
  ⋅   0.7   ⋅
  ⋅    ⋅   0.7

LinearAlgebra.Factorization

用于 矩阵分解（也称为矩阵分解）的抽象类型。有关可用矩阵分解的列表，请参阅 在线文档。

LU <: Factorization

方阵 A 的 LU 分解的矩阵分解类型。这是 lu（相应的矩阵分解函数）的返回类型。

可以使用 getproperty 访问分解 F::LU 的各个组成部分。

迭代分解将生成组件 F.L、F.U 和 F.p。

示例

julia> A = [4 3; 6 3]
2×2 Matrix{Int64}:
 4  3
 6  3

julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U factor:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

julia> F.L * F.U == A[F.p, :]
true

julia> l, u, p = lu(A); # destructuring via iteration

julia> l == F.L && u == F.U && p == F.p
true

lu(A::AbstractSparseMatrixCSC; check = true, q = nothing, control = get_umfpack_control()) -> F::UmfpackLU

计算稀疏矩阵 A 的 LU 分解。

对于具有实数或复数元素类型的稀疏 A，F 的返回类型是 UmfpackLU{Tv, Ti}，其中 Tv = Float64 或 ComplexF64，Ti 是整数类型 (Int32 或 Int64)。

当 check = true 时，如果分解失败，将抛出错误。当 check = false 时，分解有效性的检查责任 (通过 issuccess) 由用户承担。

置换 q 可以是置换向量，也可以是 nothing。如果没有提供置换向量或 q 为 nothing，则使用 UMFPACK 的默认值。如果置换不是基于零的，则将创建基于零的副本。

control 向量默认为 UMFPACK 的包默认配置，但可以通过传递长度为 UMFPACK_CONTROL 的向量来更改。有关可能的配置，请参阅 UMFPACK 手册。由于 Julia 使用基于一的索引，因此相应的变量名为 JL_UMFPACK_。

可以通过索引访问分解 F 的各个组件

F 与 A 之间的关系是

F.L*F.U == (F.Rs .* A)[F.p, F.q]

F 还支持以下功能

• \
• det

另请参见 lu!

lu(A, pivot = RowMaximum(); check = true) -> F::LU

计算 A 的 LU 分解。

当 check = true 时，如果分解失败，将抛出错误。当 check = false 时，分解有效性的检查责任 (通过 issuccess) 由用户承担。

在大多数情况下，如果 A 是 AbstractMatrix{T} 的子类型 S，其元素类型 T 支持 +、-、* 和 /，则返回类型是 LU{T,S{T}}。

通常，LU 分解涉及对矩阵的行进行置换（对应于下面描述的 F.p 输出），称为“主元选择”（因为它对应于选择哪个行包含“主元”，即 F.U 的对角线条目）。可以使用可选的 pivot 参数选择以下主元选择策略之一

• RowMaximum()（默认）：标准主元选择策略；主元对应于剩余待分解行中绝对值最大的元素。此主元选择策略要求元素类型还支持 abs 和 <。（对于浮点矩阵，这通常是唯一数值稳定的选项。）
• RowNonZero()：主元对应于剩余待分解行中第一个非零元素。（这对应于手算中的典型选择，对于支持 iszero 但不支持 abs 或 < 的更通用的代数数类型也很有用。）
• NoPivot(): 关闭旋转（如果遇到零项则可能会失败）。

可以通过 getproperty 访问分解 F 的各个组成部分

迭代分解将生成组件 F.L、F.U 和 F.p。

F 和 A 之间的关系为

F.L*F.U == A[F.p, :]

F 还支持以下功能

示例

julia> A = [4 3; 6 3]
2×2 Matrix{Int64}:
 4  3
 6  3

julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U factor:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

julia> F.L * F.U == A[F.p, :]
true

julia> l, u, p = lu(A); # destructuring via iteration

julia> l == F.L && u == F.U && p == F.p
true

lu!(F::UmfpackLU, A::AbstractSparseMatrixCSC; check=true, reuse_symbolic=true, q=nothing) -> F::UmfpackLU

计算稀疏矩阵 A 的 LU 分解，重用已存在 LU 分解 F 中存储的符号分解。 除非 reuse_symbolic 设置为 false，否则稀疏矩阵 A 必须与用于创建 LU 分解 F 的矩阵具有相同的非零模式，否则会抛出错误。 如果 A 和 F 的大小不同，所有向量将相应调整大小。

当 check = true 时，如果分解失败，将抛出错误。当 check = false 时，分解有效性的检查责任 (通过 issuccess) 由用户承担。

排列 q 可以是排列向量或 nothing。 如果没有提供排列向量或 q 为 nothing，则使用 UMFPACK 的默认值。 如果排列不是从零开始的，则会创建一个从零开始的副本。

另请参阅 lu

示例

julia> A = sparse(Float64[1.0 2.0; 0.0 3.0]);

julia> F = lu(A);

julia> B = sparse(Float64[1.0 1.0; 0.0 1.0]);

julia> lu!(F, B);

julia> F \ ones(2)
2-element Vector{Float64}:
 0.0
 1.0

lu!(A, pivot = RowMaximum(); check = true) -> LU

lu! 与 lu 相同，但通过覆盖输入 A 来节省空间，而不是创建副本。 如果分解产生的数字无法用 A 的元素类型表示，则会抛出 InexactError 异常，例如对于整数类型。

示例

julia> A = [4. 3.; 6. 3.]
2×2 Matrix{Float64}:
 4.0  3.0
 6.0  3.0

julia> F = lu!(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U factor:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

julia> iA = [4 3; 6 3]
2×2 Matrix{Int64}:
 4  3
 6  3

julia> lu!(iA)
ERROR: InexactError: Int64(0.6666666666666666)
Stacktrace:
[...]

Cholesky <: Factorization

密集对称/厄米特正定矩阵 A 的 Cholesky 分解的矩阵分解类型。 这是 cholesky（相应的矩阵分解函数）的返回类型。

可以通过分解 F::Cholesky 通过 F.L 和 F.U 获取三角形 Cholesky 因子，其中 A ≈ F.U' * F.U ≈ F.L * F.L'。

以下函数可用于 Cholesky 对象：size、\、inv、det、logdet 和 isposdef。

迭代分解会生成 L 和 U 组件。

示例

julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
3×3 Matrix{Float64}:
   4.0   12.0  -16.0
  12.0   37.0  -43.0
 -16.0  -43.0   98.0

julia> C = cholesky(A)
Cholesky{Float64, Matrix{Float64}}
U factor:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.U
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.L
3×3 LowerTriangular{Float64, Matrix{Float64}}:
  2.0   ⋅    ⋅
  6.0  1.0   ⋅
 -8.0  5.0  3.0

julia> C.L * C.U == A
true

julia> l, u = C; # destructuring via iteration

julia> l == C.L && u == C.U
true

CholeskyPivoted

密集对称/厄米特半正定矩阵 A 的带旋转 Cholesky 分解的矩阵分解类型。 这是 cholesky(_, ::RowMaximum)（相应的矩阵分解函数）的返回类型。

可以通过分解 F::CholeskyPivoted 通过 F.L 和 F.U 获取三角形 Cholesky 因子，并通过 F.p 获取排列，其中 A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr'，其中 Ur = F.U[1:F.rank, :] 和 Lr = F.L[:, 1:F.rank]，或者 A ≈ Up' * Up ≈ Lp * Lp'，其中 Up = F.U[1:F.rank, invperm(F.p)] 和 Lp = F.L[invperm(F.p), 1:F.rank]。

以下函数可用于 CholeskyPivoted 对象：size、\、inv、det 和 rank。

迭代分解会生成 L 和 U 组件。

示例

julia> X = [1.0, 2.0, 3.0, 4.0];

julia> A = X * X';

julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U factor with rank 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
permutation:
4-element Vector{Int64}:
 4
 2
 3
 1

julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
true

julia> l, u = C; # destructuring via iteration

julia> l == C.L && u == C.U
true

cholesky(A, NoPivot(); check = true) -> Cholesky

计算密集对称正定矩阵 A 的 Cholesky 分解，并返回 Cholesky 分解。 矩阵 A 可以是 Symmetric 或 Hermitian AbstractMatrix，也可以是完美对称或厄米特 AbstractMatrix。

可以通过分解 F 通过 F.L 和 F.U 获取三角形 Cholesky 因子，其中 A ≈ F.U' * F.U ≈ F.L * F.L'。

以下函数可用于 Cholesky 对象：size、\、inv、det、logdet 和 isposdef。

如果你有一个矩阵 A，由于其构造中的舍入误差而略微非厄米特，请在将其传递给 cholesky 之前将其包装在 Hermitian(A) 中，以便将其视为完美的厄米特矩阵。

当 check = true 时，如果分解失败，将抛出错误。当 check = false 时，分解有效性的检查责任 (通过 issuccess) 由用户承担。

示例

julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
3×3 Matrix{Float64}:
   4.0   12.0  -16.0
  12.0   37.0  -43.0
 -16.0  -43.0   98.0

julia> C = cholesky(A)
Cholesky{Float64, Matrix{Float64}}
U factor:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.U
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.L
3×3 LowerTriangular{Float64, Matrix{Float64}}:
  2.0   ⋅    ⋅
  6.0  1.0   ⋅
 -8.0  5.0  3.0

julia> C.L * C.U == A
true

cholesky(A, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted

计算密集对称半正定矩阵 A 的带旋转 Cholesky 分解，并返回 CholeskyPivoted 分解。 矩阵 A 可以是 Symmetric 或 Hermitian AbstractMatrix，也可以是完美对称或厄米特 AbstractMatrix。

可以通过分解 F 通过 F.L 和 F.U 获取三角形 Cholesky 因子，并通过 F.p 获取排列，其中 A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr'，其中 Ur = F.U[1:F.rank, :] 和 Lr = F.L[:, 1:F.rank]，或者 A ≈ Up' * Up ≈ Lp * Lp'，其中 Up = F.U[1:F.rank, invperm(F.p)] 和 Lp = F.L[invperm(F.p), 1:F.rank]。

以下函数可用于 CholeskyPivoted 对象：size、\、inv、det 和 rank。

参数 tol 决定用于确定秩的容差。 对于负值，容差是机器精度。

如果你有一个矩阵 A，由于其构造中的舍入误差而略微非厄米特，请在将其传递给 cholesky 之前将其包装在 Hermitian(A) 中，以便将其视为完美的厄米特矩阵。

当 check = true 时，如果分解失败，将抛出错误。当 check = false 时，分解有效性的检查责任 (通过 issuccess) 由用户承担。

示例

julia> X = [1.0, 2.0, 3.0, 4.0];

julia> A = X * X';

julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U factor with rank 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
permutation:
4-element Vector{Int64}:
 4
 2
 3
 1

julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
true

julia> l, u = C; # destructuring via iteration

julia> l == C.L && u == C.U
true

cholesky(A::SparseMatrixCSC; shift = 0.0, check = true, perm = nothing) -> CHOLMOD.Factor

计算稀疏正定矩阵 A 的 Cholesky 分解。 A 必须是 SparseMatrixCSC 或 SparseMatrixCSC 的 Symmetric/Hermitian 视图。 请注意，即使 A 没有类型标签，它也必须是对称的或厄米特的。 如果没有给出 perm，则使用填充减少排列。 F = cholesky(A) 最常用于使用 F\b 求解方程组，但 F 也定义了 diag、det 和 logdet 方法。 你还可以使用 F.L 从 F 中提取各个因子。 但是，由于默认情况下旋转处于启用状态，因此分解在内部表示为 A == P'*L*L'*P，其中 P 是一个排列矩阵； 只使用 L 而不考虑 P 会导致错误的答案。 为了包含排列的影响，通常最好提取诸如 PtL = F.PtL（等效于 P'*L）和 LtP = F.UP（等效于 L'*P）之类的“组合”因子。

当 check = true 时，如果分解失败，将抛出错误。当 check = false 时，分解有效性的检查责任 (通过 issuccess) 由用户承担。

设置可选的 shift 关键字参数会计算 A+shift*I 而不是 A 的分解。 如果提供了 perm 参数，则它应该是一个 1:size(A,1) 的排列，给出要使用的顺序（而不是 CHOLMOD 的默认 AMD 顺序）。

示例

在以下示例中，使用的填充减少排列为 [3, 2, 1]。 如果 perm 设置为 1:3 以强制不进行排列，则因子中非零元素的数量为 6。

julia> A = [2 1 1; 1 2 0; 1 0 2]
3×3 Matrix{Int64}:
 2  1  1
 1  2  0
 1  0  2

julia> C = cholesky(sparse(A))
SparseArrays.CHOLMOD.Factor{Float64, Int64}
type:    LLt
method:  simplicial
maxnnz:  5
nnz:     5
success: true

julia> C.p
3-element Vector{Int64}:
 3
 2
 1

julia> L = sparse(C.L);

julia> Matrix(L)
3×3 Matrix{Float64}:
 1.41421   0.0       0.0
 0.0       1.41421   0.0
 0.707107  0.707107  1.0

julia> L * L' ≈ A[C.p, C.p]
true

julia> P = sparse(1:3, C.p, ones(3))
3×3 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
  ⋅    ⋅   1.0
  ⋅   1.0   ⋅
 1.0   ⋅    ⋅

julia> P' * L * L' * P ≈ A
true

julia> C = cholesky(sparse(A), perm=1:3)
SparseArrays.CHOLMOD.Factor{Float64, Int64}
type:    LLt
method:  simplicial
maxnnz:  6
nnz:     6
success: true

julia> L = sparse(C.L);

julia> Matrix(L)
3×3 Matrix{Float64}:
 1.41421    0.0       0.0
 0.707107   1.22474   0.0
 0.707107  -0.408248  1.1547

julia> L * L' ≈ A
true

cholesky!(A::AbstractMatrix, NoPivot(); check = true) -> Cholesky

与 cholesky 相同，但通过覆盖输入 A 来节省空间，而不是创建副本。 如果分解产生的数字无法用 A 的元素类型表示，则会抛出 InexactError 异常，例如对于整数类型。

示例

julia> A = [1 2; 2 50]
2×2 Matrix{Int64}:
 1   2
 2  50

julia> cholesky!(A)
ERROR: InexactError: Int64(6.782329983125268)
Stacktrace:
[...]

cholesky!(A::AbstractMatrix, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted

与 cholesky 相同，但通过覆盖输入 A 来节省空间，而不是创建副本。 如果分解产生的数字无法用 A 的元素类型表示，则会抛出 InexactError 异常，例如对于整数类型。

cholesky!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

计算 A 的 Cholesky ($LL'$) 分解，重用符号分解 F。 A 必须是 SparseMatrixCSC 或 SparseMatrixCSC 的 Symmetric/ Hermitian 视图。 请注意，即使 A 没有类型标签，它也必须是对称的或厄米特的。

另请参阅 cholesky。

lowrankupdate(C::Cholesky, v::AbstractVector) -> CC::Cholesky

使用向量 v 更新 Cholesky 分解 C。 如果 A = C.U'C.U，则 CC = cholesky(C.U'C.U + v*v')，但 CC 的计算只使用 O(n^2) 个操作。

lowrankupdate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor

获取 A + C*C' 的 LDLt 分解，假设 A 的 LDLt 或 LLt 分解为 F。

返回的因子始终是 LDLt 分解。

另请参阅 lowrankupdate!、lowrankdowndate、lowrankdowndate!。

lowrankdowndate(C::Cholesky, v::AbstractVector) -> CC::Cholesky

使用向量 v 向下更新 Cholesky 分解 C。 如果 A = C.U'C.U，则 CC = cholesky(C.U'C.U - v*v')，但 CC 的计算只使用 O(n^2) 个操作。

lowrankdowndate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor

获取 A + C*C' 的 LDLt 分解，假设 A 的 LDLt 或 LLt 分解为 F。

返回的因子始终是 LDLt 分解。

另请参阅 lowrankdowndate!、lowrankupdate、lowrankupdate!。

lowrankupdate!(C::Cholesky, v::AbstractVector) -> CC::Cholesky

使用向量 v 更新 Cholesky 分解 C。 如果 A = C.U'C.U，则 CC = cholesky(C.U'C.U + v*v')，但 CC 的计算只使用 O(n^2) 个操作。 输入分解 C 在原地更新，以便在退出时 C == CC。 向量 v 在计算过程中被销毁。

lowrankupdate!(F::CHOLMOD.Factor, C::AbstractArray)

将 A 的 LDLt 或 LLt 分解 F 更新为 A + C*C' 的分解。

LLt 分解将转换为 LDLt。

另请参阅 lowrankupdate、lowrankdowndate、lowrankdowndate!。

lowrankdowndate!(C::Cholesky, v::AbstractVector) -> CC::Cholesky

使用向量 v 向下更新 Cholesky 分解 C。 如果 A = C.U'C.U，则 CC = cholesky(C.U'C.U - v*v')，但 CC 的计算只使用 O(n^2) 个操作。 输入分解 C 在原地更新，以便在退出时 C == CC。 向量 v 在计算过程中被销毁。

lowrankdowndate!(F::CHOLMOD.Factor, C::AbstractArray)

将 A 的 LDLt 或 LLt 分解 F 更新为 A - C*C' 的分解。

LLt 分解将转换为 LDLt。

另请参见 lowrankdowndate、lowrankupdate、lowrankupdate!。

LDLt <: Factorization

实数 SymTridiagonal 矩阵 S 的 LDLt 分解的矩阵分解类型，使得 S = L*Diagonal(d)*L'，其中 L 是一个 UnitLowerTriangular 矩阵，而 d 是一个向量。LDLt 分解 F = ldlt(S) 的主要用途是求解线性方程组 Sx = b，可以使用 F\b 求解。这是 ldlt 的返回值类型，该函数是相应的矩阵分解函数。

可以使用 getproperty 访问分解 F::LDLt 的各个组成部分。

示例

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0  1.0   ⋅
 1.0  4.0  2.0
  ⋅   2.0  5.0

julia> F = ldlt(S)
LDLt{Float64, SymTridiagonal{Float64, Vector{Float64}}}
L factor:
3×3 UnitLowerTriangular{Float64, SymTridiagonal{Float64, Vector{Float64}}}:
 1.0        ⋅         ⋅
 0.333333  1.0        ⋅
 0.0       0.545455  1.0
D factor:
3×3 Diagonal{Float64, Vector{Float64}}:
 3.0   ⋅        ⋅
  ⋅   3.66667   ⋅
  ⋅    ⋅       3.90909

ldlt(S::SymTridiagonal) -> LDLt

计算实数对称三对角矩阵 S 的 LDLt (即 $LDL^T$) 分解，使得 S = L*Diagonal(d)*L'，其中 L 是单位下三角矩阵，而 d 是一个向量。LDLt 分解 F = ldlt(S) 的主要用途是求解线性方程组 Sx = b，可以使用 F\b 求解。

另请参见 bunchkaufman，该函数用于对任意对称或厄米矩阵进行类似的分解，但使用了主元分解。

示例

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0  1.0   ⋅
 1.0  4.0  2.0
  ⋅   2.0  5.0

julia> ldltS = ldlt(S);

julia> b = [6., 7., 8.];

julia> ldltS \ b
3-element Vector{Float64}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255

julia> S \ b
3-element Vector{Float64}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255

ldlt(A::SparseMatrixCSC; shift = 0.0, check = true, perm=nothing) -> CHOLMOD.Factor

计算稀疏矩阵 A 的 $LDL'$ 分解。A 必须是 SparseMatrixCSC 或者 SparseMatrixCSC 的 Symmetric/Hermitian 视图。请注意，即使 A 没有类型标签，它也必须是对称的或厄米特的。将使用减少填充的主元排列。F = ldlt(A) 通常用于求解方程组 A*x = b，可以使用 F\b 求解。返回的分解对象 F 还支持 diag、det、logdet 和 inv 方法。您可以使用 F.L 从 F 中提取各个因子。但是，由于默认情况下启用了主元分解，因此分解在内部表示为 A == P'*L*D*L'*P，其中 P 是一个置换矩阵；仅使用 L 而没有考虑 P 将导致错误的结果。为了包括置换的影响，通常最好提取 "组合" 因子，例如 PtL = F.PtL (等效于 P'*L) 和 LtP = F.UP (等效于 L'*P)。支持的因子的完整列表是 :L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP。

当 check = true 时，如果分解失败，将抛出错误。当 check = false 时，分解有效性的检查责任 (通过 issuccess) 由用户承担。

设置可选的 shift 关键字参数会计算 A+shift*I 而不是 A 的分解。 如果提供了 perm 参数，则它应该是一个 1:size(A,1) 的排列，给出要使用的顺序（而不是 CHOLMOD 的默认 AMD 顺序）。

ldlt!(S::SymTridiagonal) -> LDLt

与 ldlt 相同，但通过覆盖输入 S 而不是创建副本，从而节省了空间。

示例

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0  1.0   ⋅
 1.0  4.0  2.0
  ⋅   2.0  5.0

julia> ldltS = ldlt!(S);

julia> ldltS === S
false

julia> S
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0       0.333333   ⋅
 0.333333  3.66667   0.545455
  ⋅        0.545455  3.90909

ldlt!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

计算 A 的 $LDL'$ 分解，重新使用符号分解 F。A 必须是 SparseMatrixCSC 或者 SparseMatrixCSC 的 Symmetric/Hermitian 视图。请注意，即使 A 没有类型标签，它也必须是对称的或厄米特的。

另请参见 ldlt。

QR <: Factorization

以打包格式存储的 QR 矩阵分解，通常通过 qr 获得。如果 $A$ 是一个 m×n 矩阵，那么

\[A = Q R\]

其中 $Q$ 是一个正交/酉矩阵，而 $R$ 是一个上三角矩阵。矩阵 $Q$ 存储为一系列 Householder 反射器 $v_i$ 和系数 $\tau_i$，其中

\[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T).\]

迭代分解会生成 Q 和 R 组件。

该对象有两个字段

• factors 是一个 m×n 矩阵。

  • 上三角部分包含 $R$ 的元素，即对于 QR 对象 F，R = triu(F.factors)。

  • 次对角线部分包含以打包格式存储的反射器 $v_i$，其中 $v_i$ 是矩阵 V = I + tril(F.factors, -1) 的第 $i$ 列。

• τ 是一个长度为 min(m,n) 的向量，包含系数 $au_i$。

QRCompactWY <: Factorization

以紧凑的块格式存储的 QR 矩阵分解，通常通过 qr 获得。如果 $A$ 是一个 m×n 矩阵，那么

\[A = Q R\]

其中 $Q$ 是一个正交/酉矩阵，而 $R$ 是一个上三角矩阵。它与 QR 格式类似，只是正交/酉矩阵 $Q$ 以 Compact WY 格式存储 ^{[Schreiber1989]}。对于块大小 $n_b$，它存储为一个 m×n 下梯形矩阵 $V$ 和一个矩阵 $T = (T_1 \; T_2 \; ... \; T_{b-1} \; T_b')$，该矩阵由 $b = \lceil \min(m,n) / n_b \rceil$ 个大小为 $n_b$×$n_b$ ($j = 1, ..., b-1$) 的上三角矩阵 $T_j$ 和一个上梯形 $n_b$×$\min(m,n) - (b-1) n_b$ 矩阵 $T_b'$ ($j=b$) 组成，其上方的方阵表示为 $T_b$，满足

\[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T) = \prod_{j=1}^{b} (I - V_j T_j V_j^T)\]

使得 $v_i$ 是 $V$ 的第 $i$ 列，$\tau_i$ 是 [diag(T_1); diag(T_2); …; diag(T_b)] 的第 $i$ 个元素，而 $(V_1 \; V_2 \; ... \; V_b)$ 是 $V$ 的左 m×min(m, n) 块。当使用 qr 构造时，块大小由 $n_b = \min(m, n, 36)$ 给出。

迭代分解会生成 Q 和 R 组件。

该对象有两个字段

• factors，与 QR 类型一样，是一个 m×n 矩阵。

  • 上三角部分包含 $R$ 的元素，即对于 QR 对象 F，R = triu(F.factors)。

  • 次对角线部分包含以打包格式存储的反射器 $v_i$，使得 V = I + tril(F.factors, -1)。

• T 是一个 $n_b$-by-$\min(m,n)$ 矩阵，如上所述。每个三角矩阵 $T_j$ 的次对角线元素被忽略。

QRPivoted <: Factorization

以打包格式存储的包含列主元分解的 QR 矩阵分解，通常通过 qr 获得。如果 $A$ 是一个 m×n 矩阵，那么

\[A P = Q R\]

其中 $P$ 是一个置换矩阵，$Q$ 是一个正交/酉矩阵，而 $R$ 是一个上三角矩阵。矩阵 $Q$ 存储为一系列 Householder 反射器

\[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T).\]

迭代分解会生成 Q、R 和 p 组件。

该对象有三个字段

• factors 是一个 m×n 矩阵。

  • 上三角部分包含 $R$ 的元素，即对于 QR 对象 F，R = triu(F.factors)。

  • 次对角线部分包含以打包格式存储的反射器 $v_i$，其中 $v_i$ 是矩阵 V = I + tril(F.factors, -1) 的第 $i$ 列。

• τ 是一个长度为 min(m,n) 的向量，包含系数 $au_i$。

• jpvt 是一个长度为 n 的整数向量，对应于置换 $P$。

qr(A::SparseMatrixCSC; tol=_default_tol(A), ordering=ORDERING_DEFAULT) -> QRSparse

计算稀疏矩阵 A 的 QR 分解。将使用减少填充的行和列主元排列，使得 F.R = F.Q'*A[F.prow,F.pcol]。这种类型的应用主要用于解决最小二乘或欠定问题，可以使用 \ 进行解决。该函数调用 C 库 SPQR^[ACM933]。

示例

julia> A = sparse([1,2,3,4], [1,1,2,2], [1.0,1.0,1.0,1.0])
4×2 SparseMatrixCSC{Float64, Int64} with 4 stored entries:
 1.0   ⋅
 1.0   ⋅
  ⋅   1.0
  ⋅   1.0

julia> qr(A)
SparseArrays.SPQR.QRSparse{Float64, Int64}
Q factor:
4×4 SparseArrays.SPQR.QRSparseQ{Float64, Int64}
R factor:
2×2 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
 -1.41421    ⋅
   ⋅       -1.41421
Row permutation:
4-element Vector{Int64}:
 1
 3
 4
 2
Column permutation:
2-element Vector{Int64}:
 1
 2

qr(A, pivot = NoPivot(); blocksize) -> F

计算矩阵 A 的 QR 分解：一个正交 (如果 A 是复数值，则为酉) 矩阵 Q 和一个上三角矩阵 R，使得

\[A = Q R\]

返回的对象 F 以打包格式存储分解

• 如果 pivot == ColumnNorm()，则 F 是一个 QRPivoted 对象，

• 否则，如果 A 的元素类型是 BLAS 类型 (Float32、Float64、ComplexF32 或 ComplexF64)，则 F 是一个 QRCompactWY 对象，

• 否则，F 是一个 QR 对象。

可以使用属性访问器检索分解 F 的各个组成部分。

• F.Q：正交/酉矩阵 Q
• F.R：上三角矩阵 R
• F.p：主元分解的置换向量 (QRPivoted 仅此一项)
• F.P：主元分解的置换矩阵 (QRPivoted 仅此一项)

迭代分解会生成 Q、R 和 (如果有) p 组件。

QR 对象可以使用以下函数：inv、size 和 \。当 A 是矩形时，\ 将返回最小二乘解，如果解不唯一，则返回范数最小的解。当 A 不是满秩时，需要使用 (列) 主元分解来获得最小范数解。

允许对完整的/方阵或非完整的/非方阵 Q 进行乘法运算，即支持 F.Q*F.R 和 F.Q*A。可以使用 Matrix 将 Q 矩阵转换为普通矩阵。此操作将返回 "瘦" Q 因子，即如果 A 是 m×n 矩阵，并且 m>=n，则 Matrix(F.Q) 将生成一个具有正交列的 m×n 矩阵。为了检索 "完整" Q 因子，即一个 m×m 正交矩阵，请使用 F.Q*I 或 collect(F.Q)。如果 m<=n，则 Matrix(F.Q) 将生成一个 m×m 正交矩阵。

当 pivot == NoPivot() 且 A isa StridedMatrix{<:BlasFloat} 时，可以通过关键字参数 blocksize :: Integer 指定 QR 分解的块大小。当 blocksize > minimum(size(A)) 时，它将被忽略。请参阅 QRCompactWY.

示例

julia> A = [3.0 -6.0; 4.0 -8.0; 0.0 1.0]
3×2 Matrix{Float64}:
 3.0  -6.0
 4.0  -8.0
 0.0   1.0

julia> F = qr(A)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}, Matrix{Float64}}
Q factor: 3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R factor:
2×2 Matrix{Float64}:
 -5.0  10.0
  0.0  -1.0

julia> F.Q * F.R == A
true

qr!(A, pivot = NoPivot(); blocksize)

当 A 是 AbstractMatrix 的子类型时，qr! 与 qr 相同，但通过覆盖输入 A 而不是创建副本，节省了空间。如果分解产生一个不能由 A 的元素类型表示的数字，例如对于整数类型，则会抛出 InexactError 异常。

示例

julia> a = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> qr!(a)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}, Matrix{Float64}}
Q factor: 2×2 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R factor:
2×2 Matrix{Float64}:
 -3.16228  -4.42719
  0.0      -0.632456

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> qr!(a)
ERROR: InexactError: Int64(3.1622776601683795)
Stacktrace:
[...]

LQ <: Factorization

矩阵 A 的 LQ 分解的矩阵分解类型。LQ 分解是 transpose(A) 的 QR 分解。这是 lq 的返回类型，即相应的矩阵分解函数。

如果 S::LQ 是分解对象，则可以通过 S.L 获得下三角分量，并通过 S.Q 获得正交/酉分量，使得 A ≈ S.L*S.Q。

遍历分解会生成 S.L 和 S.Q 分量。

示例

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> S = lq(A)
LQ{Float64, Matrix{Float64}, Vector{Float64}}
L factor:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}

julia> S.L * S.Q
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> l, q = S; # destructuring via iteration

julia> l == S.L &&  q == S.Q
true

lq(A) -> S::LQ

计算 A 的 LQ 分解。可以通过 LQ 对象 S 的 S.L 获得分解的下三角分量，并通过 S.Q 获得正交/酉分量，使得 A ≈ S.L*S.Q。

遍历分解会生成 S.L 和 S.Q 分量。

LQ 分解是 transpose(A) 的 QR 分解，它用于计算欠定方程组 (A 的列数大于行数，但具有完整的行秩) 的最小范数解 lq(A) \ b。

示例

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> S = lq(A)
LQ{Float64, Matrix{Float64}, Vector{Float64}}
L factor:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}

julia> S.L * S.Q
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> l, q = S; # destructuring via iteration

julia> l == S.L &&  q == S.Q
true

lq!(A) -> LQ

计算 A 的 LQ 分解，使用输入矩阵作为工作空间。另请参阅 lq.

BunchKaufman <: Factorization

对称或厄米特矩阵 A 的 Bunch-Kaufman 分解的矩阵分解类型，表示为 P'UDU'P 或 P'LDL'P，具体取决于 A 中存储的是上三角 (默认) 还是下三角。如果 A 是复对称矩阵，则 U' 和 L' 表示非共轭转置，即分别表示 transpose(U) 和 transpose(L)。这是 bunchkaufman 的返回类型，即相应的矩阵分解函数。

如果 S::BunchKaufman 是分解对象，则可以通过 S.D、S.U 或 S.L (根据 S.uplo 选择) 和 S.p 获得各个分量。

遍历分解会生成 S.D、S.U 或 S.L 分量 (根据 S.uplo 选择) 和 S.p。

示例

julia> A = [1 2; 2 3]
2×2 Matrix{Int64}:
 1  2
 2  3

julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U factor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
permutation:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # destructuring via iteration

julia> d == S.D && u == S.U && p == S.p
true

julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L factor:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
permutation:
2-element Vector{Int64}:
 2
 1

bunchkaufman(A, rook::Bool=false; check = true) -> S::BunchKaufman

计算对称或厄米特矩阵 A 的 Bunch-Kaufman ^[Bunch1977] 分解，表示为 P'*U*D*U'*P 或 P'*L*D*L'*P，具体取决于 A 中存储的是哪个三角，并返回 BunchKaufman 对象。请注意，如果 A 是复对称矩阵，则 U' 和 L' 表示非共轭转置，即分别表示 transpose(U) 和 transpose(L)。

遍历分解会生成 S.D、S.U 或 S.L 分量 (根据 S.uplo 选择) 和 S.p。

如果 rook 为 true，则使用 rook 主元。如果 rook 为 false，则不使用 rook 主元。

当 check = true 时，如果分解失败，将抛出错误。当 check = false 时，分解有效性的检查责任 (通过 issuccess) 由用户承担。

以下函数可用于 BunchKaufman 对象：size、\、inv、issymmetric、ishermitian、getindex.

示例

julia> A = [1 2; 2 3]
2×2 Matrix{Int64}:
 1  2
 2  3

julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U factor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
permutation:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # destructuring via iteration

julia> d == S.D && u == S.U && p == S.p
true

julia> S.U*S.D*S.U' - S.P*A*S.P'
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L factor:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
permutation:
2-element Vector{Int64}:
 2
 1

julia> S.L*S.D*S.L' - A[S.p, S.p]
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

bunchkaufman!(A, rook::Bool=false; check = true) -> BunchKaufman

bunchkaufman! 与 bunchkaufman 相同，但通过覆盖输入 A 而不是创建副本，节省了空间。

Eigen <: Factorization

方阵 A 的特征值/谱分解的矩阵分解类型。这是 eigen 的返回类型，即相应的矩阵分解函数。

如果 F::Eigen 是分解对象，则可以通过 F.values 获得特征值，并将特征向量作为矩阵 F.vectors 的列获得。(可以从切片 F.vectors[:, k] 获得第 k 个特征向量)。

遍历分解会生成 F.values 和 F.vectors 分量。

示例

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
  1.0
  3.0
 18.0
vectors:
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> F.values
3-element Vector{Float64}:
  1.0
  3.0
 18.0

julia> F.vectors
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

GeneralizedEigen <: Factorization

A 和 B 的广义特征值/谱分解的矩阵分解类型。这是 eigen 的返回类型，即相应的矩阵分解函数，当用两个矩阵参数调用时。

如果 F::GeneralizedEigen 是分解对象，则可以通过 F.values 获得特征值，并将特征向量作为矩阵 F.vectors 的列获得。(可以从切片 F.vectors[:, k] 获得第 k 个特征向量)。

遍历分解会生成 F.values 和 F.vectors 分量。

示例

julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
 1   0
 0  -1

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> F = eigen(A, B)
GeneralizedEigen{ComplexF64, ComplexF64, Matrix{ComplexF64}, Vector{ComplexF64}}
values:
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im
vectors:
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> F.values
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> F.vectors
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

eigvals(A; permute::Bool=true, scale::Bool=true, sortby) -> values

返回 A 的特征值。

对于一般的非对称矩阵，可以指定在特征值计算之前如何对矩阵进行平衡。permute、scale 和 sortby 关键字与 eigen 相同。

示例

julia> diag_matrix = [1 0; 0 4]
2×2 Matrix{Int64}:
 1  0
 0  4

julia> eigvals(diag_matrix)
2-element Vector{Float64}:
 1.0
 4.0

对于标量输入，eigvals 将返回标量。

示例

julia> eigvals(-2)
-2

eigvals(A, B) -> values

计算 A 和 B 的广义特征值。

示例

julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
 1   0
 0  -1

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> eigvals(A,B)
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

返回 A 的特征值。可以通过指定覆盖排序后的特征值索引的 UnitRange irange 来计算特征值的一个子集，例如第二个到第八个特征值。

示例

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

julia> eigvals(A, 2:2)
1-element Vector{Float64}:
 0.9999999999999996

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259

eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values

返回 A 的特征值。可以通过指定特征值的下界 vl 和上界 vu 来计算特征值的一个子集。

示例

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

julia> eigvals(A, -1, 2)
1-element Vector{Float64}:
 1.0000000000000009

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259

eigvals!(A; permute::Bool=true, scale::Bool=true, sortby) -> values

与 eigvals 相同，但通过覆盖输入 A 而不是创建副本，节省了空间。permute、scale 和 sortby 关键字与 eigen 相同。

示例

julia> A = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> eigvals!(A)
2-element Vector{Float64}:
 -0.3722813232690143
  5.372281323269014

julia> A
2×2 Matrix{Float64}:
 -0.372281  -1.0
  0.0        5.37228

eigvals!(A, B; sortby) -> values

与 eigvals 相同，但通过覆盖输入 A (和 B) 而不是创建副本，节省了空间。

示例

julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
 0.0  1.0
 1.0  0.0

julia> eigvals!(A, B)
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> A
2×2 Matrix{Float64}:
 -0.0  -1.0
  1.0  -0.0

julia> B
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

与 eigvals 相同，但通过覆盖输入 A 而不是创建副本，节省了空间。irange 是要搜索的特征值索引范围 - 例如，第二个到第八个特征值。

eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values

与 eigvals 相同，但通过覆盖输入 A 而不是创建副本，节省了空间。vl 是要搜索的特征值区间的下界，vu 是上界。

eigmax(A; permute::Bool=true, scale::Bool=true)

返回 A 的最大特征值。选项 permute=true 会将矩阵置换得更接近上三角矩阵，而 scale=true 会按其对角元素对矩阵进行缩放，使行和列的范数更接近。请注意，如果 A 的特征值是复数，则此方法将失败，因为复数不能排序。

示例

julia> A = [0 im; -im 0]
2×2 Matrix{Complex{Int64}}:
 0+0im  0+1im
 0-1im  0+0im

julia> eigmax(A)
1.0

julia> A = [0 im; -1 0]
2×2 Matrix{Complex{Int64}}:
  0+0im  0+1im
 -1+0im  0+0im

julia> eigmax(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` cannot have complex eigenvalues.
Stacktrace:
[...]

eigmin(A; permute::Bool=true, scale::Bool=true)

返回 A 的最小特征值。选项 permute=true 会将矩阵置换得更接近上三角矩阵，而 scale=true 会按其对角元素对矩阵进行缩放，使行和列的范数更接近。请注意，如果 A 的特征值是复数，则此方法将失败，因为复数不能排序。

示例

julia> A = [0 im; -im 0]
2×2 Matrix{Complex{Int64}}:
 0+0im  0+1im
 0-1im  0+0im

julia> eigmin(A)
-1.0

julia> A = [0 im; -1 0]
2×2 Matrix{Complex{Int64}}:
  0+0im  0+1im
 -1+0im  0+0im

julia> eigmin(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` cannot have complex eigenvalues.
Stacktrace:
[...]

eigvecs(A::SymTridiagonal[, eigvals]) -> Matrix

返回一个矩阵 M，其列是 A 的特征向量。(可以从切片 M[:, k] 获得第 k 个特征向量)。

如果指定了可选的特征值向量 eigvals，则 eigvecs 将返回特定相应的特征向量。

示例

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259

julia> eigvecs(A)
3×3 Matrix{Float64}:
  0.418304  -0.83205      0.364299
 -0.656749  -7.39009e-16  0.754109
  0.627457   0.5547       0.546448

julia> eigvecs(A, [1.])
3×1 Matrix{Float64}:
  0.8320502943378438
  4.263514128092366e-17
 -0.5547001962252291

eigvecs(A; permute::Bool=true, scale::Bool=true, `sortby`) -> Matrix

返回一个矩阵 M，其列是 A 的特征向量。(可以从切片 M[:, k] 获得第 k 个特征向量)。permute、scale 和 sortby 关键字与 eigen 相同。

示例

julia> eigvecs([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

eigvecs(A, B) -> Matrix

返回一个矩阵 M，其列是 A 和 B 的广义特征向量。(可以从切片 M[:, k] 获得第 k 个特征向量)。

示例

julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
 1   0
 0  -1

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> eigvecs(A, B)
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

eigen(A; permute::Bool=true, scale::Bool=true, sortby) -> Eigen

计算 A 的特征值分解，返回一个 Eigen 分解对象 F，其中包含 F.values 中的特征值和矩阵 F.vectors 列中的特征向量。这对应于求解形式为 Ax = λx 的特征值问题，其中 A 是一个矩阵，x 是一个特征向量，而 λ 是一个特征值。(可以从切片 F.vectors[:, k] 获得第 k 个特征向量)。

遍历分解会生成 F.values 和 F.vectors 分量。

以下函数可用于 Eigen 对象：inv、det 和 isposdef.

对于一般的非对称矩阵，可以指定在特征向量计算之前如何对矩阵进行平衡。选项 permute=true 会将矩阵置换得更接近上三角矩阵，而 scale=true 会按其对角元素对矩阵进行缩放，使行和列的范数更接近。这两个选项的默认值为 true。

默认情况下，特征值和向量按 (real(λ),imag(λ)) 字典排序。可以将不同的比较函数 by(λ) 传递给 sortby，或者将 sortby=nothing 传递给 sortby 以保留特征值的任意顺序。某些特殊矩阵类型 (例如 Diagonal 或 SymTridiagonal) 可能实现了自己的排序约定，并且不接受 sortby 关键字。

示例

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
  1.0
  3.0
 18.0
vectors:
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> F.values
3-element Vector{Float64}:
  1.0
  3.0
 18.0

julia> F.vectors
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

eigen(A, B; sortby) -> GeneralizedEigen

计算 A 和 B 的广义特征值分解，返回一个 GeneralizedEigen 分解对象 F，其中包含 F.values 中的广义特征值和矩阵 F.vectors 的列中的广义特征向量。这对应于求解形式为 Ax = λBx 的广义特征值问题，其中 A, B 是矩阵，x 是特征向量，λ 是特征值。（第 k 个广义特征向量可以从切片 F.vectors[:, k] 中获得。）

遍历分解会生成 F.values 和 F.vectors 分量。

默认情况下，特征值和特征向量按 (real(λ),imag(λ)) 的字典序排序。可以将不同的比较函数 by(λ) 传递给 sortby，或者可以传递 sortby=nothing 来使特征值保持任意顺序。

示例

julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
 1   0
 0  -1

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> F = eigen(A, B);

julia> F.values
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> F.vectors
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> Eigen

计算 A 的特征值分解，返回一个 Eigen 分解对象 F，其中包含 F.values 中的特征值和矩阵 F.vectors 的列中的特征向量。（第 k 个特征向量可以从切片 F.vectors[:, k] 中获得。）

遍历分解会生成 F.values 和 F.vectors 分量。

以下函数可用于 Eigen 对象：inv、det 和 isposdef.

UnitRange irange 指定要搜索的已排序特征值的索引。

eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> Eigen

计算 A 的特征值分解，返回一个 Eigen 分解对象 F，其中包含 F.values 中的特征值和矩阵 F.vectors 的列中的特征向量。（第 k 个特征向量可以从切片 F.vectors[:, k] 中获得。）

遍历分解会生成 F.values 和 F.vectors 分量。

以下函数可用于 Eigen 对象：inv、det 和 isposdef.

vl 是要搜索的特征值窗口的下限，vu 是上限。

eigen!(A; permute, scale, sortby)
eigen!(A, B; sortby)

与 eigen 相同，但通过覆盖输入 A（和 B）而不是创建副本，节省了空间。

Hessenberg <: Factorization

Hessenberg 对象表示方阵的 Hessenberg 分解 QHQ'，或其移位 Q(H+μI)Q'，这是由 hessenberg 函数产生的。

hessenberg(A) -> Hessenberg

计算 A 的 Hessenberg 分解并返回一个 Hessenberg 对象。如果 F 是分解对象，则可以通过 F.Q（类型为 LinearAlgebra.HessenbergQ）访问酉矩阵，并通过 F.H（类型为 UpperHessenberg）访问 Hessenberg 矩阵，两者都可以使用 Matrix(F.H) 或 Matrix(F.Q) 转换为普通矩阵。

如果 A 是 Hermitian 或实数 Symmetric，则 Hessenberg 分解会产生一个实对称三对角矩阵，并且 F.H 的类型为 SymTridiagonal。

请注意，移位分解 A+μI = Q (H+μI) Q' 可以通过 F + μ*I 使用 UniformScaling 对象 I 有效地构建，这会创建一个具有共享存储空间和修改后的移位的新的 Hessenberg 对象。给定 F 的移位通过 F.μ 获得。这很有用，因为一旦创建了 F，就可以有效地执行多个移位求解 (F + μ*I) \ b（对于不同的 μ 和/或 b）。

迭代分解会产生因子 F.Q, F.H, F.μ。

示例

julia> A = [4. 9. 7.; 4. 4. 1.; 4. 3. 2.]
3×3 Matrix{Float64}:
 4.0  9.0  7.0
 4.0  4.0  1.0
 4.0  3.0  2.0

julia> F = hessenberg(A)
Hessenberg{Float64, UpperHessenberg{Float64, Matrix{Float64}}, Matrix{Float64}, Vector{Float64}, Bool}
Q factor: 3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}
H factor:
3×3 UpperHessenberg{Float64, Matrix{Float64}}:
  4.0      -11.3137       -1.41421
 -5.65685    5.0           2.0
   ⋅        -8.88178e-16   1.0

julia> F.Q * F.H * F.Q'
3×3 Matrix{Float64}:
 4.0  9.0  7.0
 4.0  4.0  1.0
 4.0  3.0  2.0

julia> q, h = F; # destructuring via iteration

julia> q == F.Q && h == F.H
true

hessenberg!(A) -> Hessenberg

hessenberg! 与 hessenberg 相同，但通过覆盖输入 A 而不是创建副本，节省了空间。

Schur <: Factorization

矩阵 A 的 Schur 分解的矩阵分解类型。这是 schur(_)（相应的矩阵分解函数）的返回类型。

如果 F::Schur 是分解对象，则可以通过 F.Schur 或 F.T 获取（拟）三角 Schur 因子，并通过 F.vectors 或 F.Z 获取正交/酉 Schur 向量，使得 A = F.vectors * F.Schur * F.vectors'。可以通过 F.values 获取 A 的特征值。

迭代分解会产生组件 F.T、F.Z 和 F.values。

示例

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
eigenvalues:
2-element Vector{Float64}:
  3.0
 -2.0

julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> t, z, vals = F; # destructuring via iteration

julia> t == F.T && z == F.Z && vals == F.values
true

GeneralizedSchur <: Factorization

两个矩阵 A 和 B 的广义 Schur 分解的矩阵分解类型。这是 schur(_, _)（相应的矩阵分解函数）的返回类型。

如果 F::GeneralizedSchur 是分解对象，则可以通过 F.S 和 F.T 获取（拟）三角 Schur 因子，可以通过 F.left 或 F.Q 获取左酉/正交 Schur 向量，并可以通过 F.right 或 F.Z 获取右酉/正交 Schur 向量，使得 A=F.left*F.S*F.right' 和 B=F.left*F.T*F.right'。可以通过 F.α./F.β 获取 A 和 B 的广义特征值。

迭代分解会产生组件 F.S、F.T、F.Q、F.Z、F.α 和 F.β。

schur(A) -> F::Schur

计算矩阵 A 的 Schur 分解。可以通过 Schur 对象 F 的 F.Schur 或 F.T 获取（拟）三角 Schur 因子，并可以通过 F.vectors 或 F.Z 获取正交/酉 Schur 向量，使得 A = F.vectors * F.Schur * F.vectors'。可以通过 F.values 获取 A 的特征值。

对于实数 A，Schur 分解是“拟三角”的，这意味着它除了在任何复共轭特征值对的复共轭特征值对的 2×2 对角块外，是上三角的；这使得即使存在复特征值，分解也能保持纯实数。

迭代分解会产生组件 F.T、F.Z 和 F.values。

示例

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
eigenvalues:
2-element Vector{Float64}:
  3.0
 -2.0

julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> t, z, vals = F; # destructuring via iteration

julia> t == F.T && z == F.Z && vals == F.values
true

schur(A, B) -> F::GeneralizedSchur

计算矩阵 A 和 B 的广义 Schur（或 QZ）分解。可以通过 Schur 对象 F 的 F.S 和 F.T 获取（拟）三角 Schur 因子，可以通过 F.left 或 F.Q 获取左酉/正交 Schur 向量，并可以通过 F.right 或 F.Z 获取右酉/正交 Schur 向量，使得 A=F.left*F.S*F.right' 和 B=F.left*F.T*F.right'。可以通过 F.α./F.β 获取 A 和 B 的广义特征值。

迭代分解会产生组件 F.S、F.T、F.Q、F.Z、F.α 和 F.β。

schur!(A) -> F::Schur

与 schur 相同，但使用输入参数 A 作为工作空间。

示例

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> F = schur!(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
eigenvalues:
2-element Vector{Float64}:
  3.0
 -2.0

julia> A
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0

schur!(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur

与 schur 相同，但使用输入矩阵 A 和 B 作为工作空间。

ordschur(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur

根据逻辑数组 select 对矩阵 A = Z*T*Z' 的 Schur 分解 F 进行重新排序，返回重新排序的分解 F 对象。选定的特征值出现在 F.Schur 的主对角线上，F.vectors 的对应前导列构成相应右不变子空间的正交/酉基。在实数情况下，复共轭特征值对必须通过 select 都包含或都排除。

ordschur(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur

根据逻辑数组 select 对矩阵对 (A, B) = (Q*S*Z', Q*T*Z') 的广义 Schur 分解 F 进行重新排序，并返回一个 GeneralizedSchur 对象 F。选定的特征值出现在 F.S 和 F.T 的主对角线上，并且左、右正交/酉 Schur 向量也被重新排序，使得 (A, B) = F.Q*(F.S, F.T)*F.Z' 仍然成立，并且 A 和 B 的广义特征值仍然可以通过 F.α./F.β 获取。

ordschur!(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur

与 ordschur 相同，但覆盖了分解 F。

ordschur!(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur

与 ordschur 相同，但覆盖了分解 F。

SVD <: Factorization

矩阵 A 的奇异值分解 (SVD) 的矩阵分解类型。这是 svd(_)（相应的矩阵分解函数）的返回类型。

如果 F::SVD 是分解对象，则可以通过 F.U、F.S、F.V 和 F.Vt 获取 U、S、V 和 Vt，使得 A = U * Diagonal(S) * Vt。S 中的奇异值按降序排序。

迭代分解会产生组件 U、S 和 V。

示例

julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
4×5 Matrix{Float64}:
 1.0  0.0  0.0  0.0  2.0
 0.0  0.0  3.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  2.0  0.0  0.0  0.0

julia> F = svd(A)
SVD{Float64, Float64, Matrix{Float64}, Vector{Float64}}
U factor:
4×4 Matrix{Float64}:
 0.0  1.0   0.0  0.0
 1.0  0.0   0.0  0.0
 0.0  0.0   0.0  1.0
 0.0  0.0  -1.0  0.0
singular values:
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0
Vt factor:
4×5 Matrix{Float64}:
 -0.0        0.0  1.0  -0.0  0.0
  0.447214   0.0  0.0   0.0  0.894427
  0.0       -1.0  0.0   0.0  0.0
  0.0        0.0  0.0   1.0  0.0

julia> F.U * Diagonal(F.S) * F.Vt
4×5 Matrix{Float64}:
 1.0  0.0  0.0  0.0  2.0
 0.0  0.0  3.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  2.0  0.0  0.0  0.0

julia> u, s, v = F; # destructuring via iteration

julia> u == F.U && s == F.S && v == F.V
true

GeneralizedSVD <: Factorization

两个矩阵 A 和 B 的广义奇异值分解 (SVD) 的矩阵分解类型，使得 A = F.U*F.D1*F.R0*F.Q' 和 B = F.V*F.D2*F.R0*F.Q'。这是 svd(_, _)（相应的矩阵分解函数）的返回类型。

对于 M 行 N 列的矩阵 A 和 P 行 N 列的矩阵 B，

• U 是一个 M 行 M 列的正交矩阵，
• V 是一个 P 行 P 列的正交矩阵，
• Q 是一个 N 行 N 列的正交矩阵，
• D1 是一个 M 行 (K+L) 列的对角矩阵，前 K 个元素为 1，
• D2 是一个 P 行 (K+L) 列的矩阵，其右上角 L 行 L 列的块是对角的，
• R0 是一个 (K+L) 行 N 列的矩阵，其最右侧的 (K+L) 行 (K+L) 列的块是非奇异的上块三角的，

K+L 是矩阵 [A; B] 的有效数值秩。

迭代分解会产生组件 U、V、Q、D1、D2 和 R0。

F.D1 和 F.D2 的元素之间存在关联，如 LAPACK 文档中对 广义 SVD 和 xGGSVD3 例程的说明（在 LAPACK 3.6.0 及更高版本中）。

示例

julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
 0.0  1.0
 1.0  0.0

julia> F = svd(A, B)
GeneralizedSVD{Float64, Matrix{Float64}, Float64, Vector{Float64}}
U factor:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
V factor:
2×2 Matrix{Float64}:
 -0.0  -1.0
  1.0   0.0
Q factor:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
D1 factor:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
D2 factor:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
R0 factor:
2×2 Matrix{Float64}:
 1.41421   0.0
 0.0      -1.41421

julia> F.U*F.D1*F.R0*F.Q'
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> F.V*F.D2*F.R0*F.Q'
2×2 Matrix{Float64}:
 -0.0  1.0
  1.0  0.0

svd(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD

计算 A 的奇异值分解 (SVD) 并返回一个 SVD 对象。

可以通过分解 F 的 F.U、F.S、F.V 和 F.Vt 获取 U、S、V 和 Vt，使得 A = U * Diagonal(S) * Vt。该算法产生 Vt，因此提取 Vt 比提取 V 更有效。S 中的奇异值按降序排序。

迭代分解会产生组件 U、S 和 V。

如果 full = false（默认），则返回“瘦”SVD。对于一个 $M \times N$ 矩阵 A，在完整分解中 U 是 $M \times M$ 并且 V 是 $N \times N$，而在瘦分解中 U 是 $M \times K$ 并且 V 是 $N \times K$，其中 $K = \min(M,N)$ 是奇异值的个数。

如果alg = DivideAndConquer()，则使用分治算法计算SVD。另一种（通常速度较慢但更准确）的选择是alg = QRIteration()。

示例

julia> A = rand(4,3);

julia> F = svd(A); # Store the Factorization Object

julia> A ≈ F.U * Diagonal(F.S) * F.Vt
true

julia> U, S, V = F; # destructuring via iteration

julia> A ≈ U * Diagonal(S) * V'
true

julia> Uonly, = svd(A); # Store U only

julia> Uonly == U
true

svd(A, B) -> GeneralizedSVD

计算A 和 B 的广义 SVD，返回一个GeneralizedSVD 分解对象 F，使得[A;B] = [F.U * F.D1; F.V * F.D2] * F.R0 * F.Q'

• U 是一个 M 行 M 列的正交矩阵，
• V 是一个 P 行 P 列的正交矩阵，
• Q 是一个 N 行 N 列的正交矩阵，
• D1 是一个 M 行 (K+L) 列的对角矩阵，前 K 个元素为 1，
• D2 是一个 P 行 (K+L) 列的矩阵，其右上角 L 行 L 列的块是对角的，
• R0 是一个 (K+L) 行 N 列的矩阵，其最右侧的 (K+L) 行 (K+L) 列的块是非奇异的上块三角的，

K+L 是矩阵 [A; B] 的有效数值秩。

迭代分解会产生组件 U、V、Q、D1、D2 和 R0。

广义 SVD 用于诸如想要比较多少属于 A 与多少属于 B 的应用，例如人类与酵母基因组、信号与噪声或簇间与簇内。 (有关讨论，请参阅 Edelman 和 Wang：https://arxiv.org/abs/1901.00485)

它将[A; B] 分解为 [UC; VS]H，其中 [UC; VS] 是 [A; B] 列空间的自然正交基，而 H = RQ' 是 [A;B] 行空间的自然非正交基，其中最上面的行最接近于 A 矩阵，最下面的行最接近于 B 矩阵。多余弦/正弦矩阵 C 和 S 提供了多少 A 与多少 B 的多重度量，而 U 和 V 提供了这些度量的方向。

示例

julia> A = randn(3,2); B=randn(4,2);

julia> F = svd(A, B);

julia> U,V,Q,C,S,R = F;

julia> H = R*Q';

julia> [A; B] ≈ [U*C; V*S]*H
true

julia> [A; B] ≈ [F.U*F.D1; F.V*F.D2]*F.R0*F.Q'
true

julia> Uonly, = svd(A,B);

julia> U == Uonly
true

svd!(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD

svd! 与 svd 相同，但通过覆盖输入 A 而不是创建副本，从而节省空间。有关详细信息，请参见 svd 的文档。

svd!(A, B) -> GeneralizedSVD

svd! 与 svd 相同，但它会就地修改参数 A 和 B，而不是创建副本。有关详细信息，请参见 svd 的文档。

svdvals(A)

以降序返回 A 的奇异值。

示例

julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
4×5 Matrix{Float64}:
 1.0  0.0  0.0  0.0  2.0
 0.0  0.0  3.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  2.0  0.0  0.0  0.0

julia> svdvals(A)
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0

svdvals(A, B)

返回 A 和 B 的广义奇异值分解中的广义奇异值。另请参见 svd。

示例

julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
 0.0  1.0
 1.0  0.0

julia> svdvals(A, B)
2-element Vector{Float64}:
 1.0
 1.0

svdvals!(A)

返回 A 的奇异值，通过覆盖输入来节省空间。另请参见 svdvals 和 svd。

svdvals!(A, B)

返回 A 和 B 的广义奇异值分解中的广义奇异值，通过覆盖 A 和 B 来节省空间。另请参见 svd 和 svdvals。

LinearAlgebra.Givens(i1,i2,c,s) -> G

Givens 旋转线性算子。字段 c 和 s 分别表示旋转角的余弦和正弦。Givens 类型支持左乘 G*A 和共轭转置右乘 A*G'。该类型没有 size，因此可以与任意大小的矩阵相乘，只要 i2<=size(A,2) 用于 G*A 或 i2<=size(A,1) 用于 A*G' 即可。

另请参见 givens。

givens(f::T, g::T, i1::Integer, i2::Integer) where {T} -> (G::Givens, r::T)

计算 Givens 旋转 G 和标量 r，使得对于任何向量 x，其中

x[i1] = f
x[i2] = g

乘法的结果

y = G*x

具有以下属性：

y[i1] = r
y[i2] = 0

另请参见 LinearAlgebra.Givens。

givens(A::AbstractArray, i1::Integer, i2::Integer, j::Integer) -> (G::Givens, r)

计算 Givens 旋转 G 和标量 r，使得乘法的结果

B = G*A

具有以下属性：

B[i1,j] = r
B[i2,j] = 0

另请参见 LinearAlgebra.Givens。

givens(x::AbstractVector, i1::Integer, i2::Integer) -> (G::Givens, r)

计算 Givens 旋转 G 和标量 r，使得乘法的结果

B = G*x

具有以下属性：

B[i1] = r
B[i2] = 0

另请参见 LinearAlgebra.Givens。

triu(M)

矩阵的上三角。

示例

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> triu(a)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 0.0  1.0  1.0  1.0
 0.0  0.0  1.0  1.0
 0.0  0.0  0.0  1.0

triu(M, k::Integer)

从第 k 个超对角线开始，返回 M 的上三角。

示例

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> triu(a,3)
4×4 Matrix{Float64}:
 0.0  0.0  0.0  1.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

julia> triu(a,-3)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

triu!(M)

矩阵的上三角，在此过程中覆盖 M。另请参见 triu。

triu!(M, k::Integer)

从第 k 个超对角线开始，返回 M 的上三角，在此过程中覆盖 M。

示例

julia> M = [1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5]
5×5 Matrix{Int64}:
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

julia> triu!(M, 1)
5×5 Matrix{Int64}:
 0  2  3  4  5
 0  0  3  4  5
 0  0  0  4  5
 0  0  0  0  5
 0  0  0  0  0

tril(M)

矩阵的下三角。

示例

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a)
4×4 Matrix{Float64}:
 1.0  0.0  0.0  0.0
 1.0  1.0  0.0  0.0
 1.0  1.0  1.0  0.0
 1.0  1.0  1.0  1.0

tril(M, k::Integer)

从第 k 个超对角线开始，返回 M 的下三角。

示例

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a,3)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a,-3)
4×4 Matrix{Float64}:
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 1.0  0.0  0.0  0.0

tril!(M)

矩阵的下三角，在此过程中覆盖 M。另请参见 tril。

tril!(M, k::Integer)

从第 k 个超对角线开始，返回 M 的下三角，在此过程中覆盖 M。

示例

julia> M = [1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5]
5×5 Matrix{Int64}:
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

julia> tril!(M, 2)
5×5 Matrix{Int64}:
 1  2  3  0  0
 1  2  3  4  0
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

diagind(M, k::Integer=0)

一个 AbstractRange，它给出矩阵 M 的第 k 个对角线的索引。

另请参见：diag，diagm，Diagonal。

示例

julia> A = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
 1  2  3
 4  5  6
 7  8  9

julia> diagind(A,-1)
2:4:6

diag(M, k::Integer=0)

矩阵的第 k 个对角线，作为向量。

另请参见 diagm，diagind，Diagonal，isdiag。

示例

julia> A = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
 1  2  3
 4  5  6
 7  8  9

julia> diag(A,1)
2-element Vector{Int64}:
 2
 6

diagm(kv::Pair{<:Integer,<:AbstractVector}...)
diagm(m::Integer, n::Integer, kv::Pair{<:Integer,<:AbstractVector}...)

从对角线和向量的 Pair 对构建矩阵。向量 kv.second 将被放置在 kv.first 对角线上。默认情况下，矩阵是方阵，其大小由 kv 推断，但可以通过将 m,n 作为第一个参数传递来指定非方阵大小 m×n（根据需要用零填充）。对于重复的对角线索引 kv.first，对应向量 kv.second 中的值将被加起来。

diagm 构造一个完整矩阵；如果您想要具有快速算术的存储效率版本，请参见 Diagonal，Bidiagonal Tridiagonal 和 SymTridiagonal。

示例

julia> diagm(1 => [1,2,3])
4×4 Matrix{Int64}:
 0  1  0  0
 0  0  2  0
 0  0  0  3
 0  0  0  0

julia> diagm(1 => [1,2,3], -1 => [4,5])
4×4 Matrix{Int64}:
 0  1  0  0
 4  0  2  0
 0  5  0  3
 0  0  0  0

julia> diagm(1 => [1,2,3], 1 => [1,2,3])
4×4 Matrix{Int64}:
 0  2  0  0
 0  0  4  0
 0  0  0  6
 0  0  0  0

diagm(v::AbstractVector)
diagm(m::Integer, n::Integer, v::AbstractVector)

构造一个矩阵，其元素的向量作为对角元素。默认情况下，矩阵是方阵，其大小由 length(v) 给出，但可以通过将 m,n 作为第一个参数传递来指定非方阵大小 m×n。

示例

julia> diagm([1,2,3])
3×3 Matrix{Int64}:
 1  0  0
 0  2  0
 0  0  3

rank(::QRSparse{Tv,Ti}) -> Ti

返回 QR 分解的秩。

rank(S::SparseMatrixCSC{Tv,Ti}; [tol::Real]) -> Ti

通过计算 S 的 QR 分解来计算其秩。小于 tol 的值被认为是零。请参阅 SPQR 的手册。

rank(A::AbstractMatrix; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
rank(A::AbstractMatrix, rtol::Real)

通过计算 svdvals(A) 的多少输出大于 max(atol, rtol*σ₁) 来计算矩阵的数值秩，其中 σ₁ 是 A 的最大计算出的奇异值。atol 和 rtol 分别是绝对和相对容差。默认的相对容差为 n*ϵ，其中 n 是 A 的最小维度的尺寸，而 ϵ 是 A 的元素类型的 eps。

示例

julia> rank(Matrix(I, 3, 3))
3

julia> rank(diagm(0 => [1, 0, 2]))
2

julia> rank(diagm(0 => [1, 0.001, 2]), rtol=0.1)
2

julia> rank(diagm(0 => [1, 0.001, 2]), rtol=0.00001)
3

julia> rank(diagm(0 => [1, 0.001, 2]), atol=1.5)
1

norm(A, p::Real=2)

对于任何可迭代容器 A（包括任何维度的数组）的数字（或任何定义了 norm 的元素类型），计算 p 范数（默认值为 p=2），就好像 A 是对应长度的向量一样。

p 范数定义为

\[\|A\|_p = \left( \sum_{i=1}^n | a_i | ^p \right)^{1/p}\]

其中 $a_i$ 是 $A$ 的元素，$| a_i |$ 是 $a_i$ 的 norm，而 $n$ 是 $A$ 的长度。由于 p 范数是使用 A 的元素的 norm 计算的，因此如果 p != 2，向量向量的 p 范数通常与将其解释为块向量的解释不兼容。

p 可以取任何数值（即使并非所有值都会产生数学上有效的向量范数）。特别是，norm(A, Inf) 返回 abs.(A) 中的最大值，而 norm(A, -Inf) 返回最小值。如果 A 是矩阵并且 p=2，那么这等效于 Frobenius 范数。

第二个参数 p 不一定是 norm 的接口的一部分，即自定义类型可能只实现没有第二个参数的 norm(A)。

使用 opnorm 计算矩阵的算子范数。

示例

julia> v = [3, -2, 6]
3-element Vector{Int64}:
  3
 -2
  6

julia> norm(v)
7.0

julia> norm(v, 1)
11.0

julia> norm(v, Inf)
6.0

julia> norm([1 2 3; 4 5 6; 7 8 9])
16.881943016134134

julia> norm([1 2 3 4 5 6 7 8 9])
16.881943016134134

julia> norm(1:9)
16.881943016134134

julia> norm(hcat(v,v), 1) == norm(vcat(v,v), 1) != norm([v,v], 1)
true

julia> norm(hcat(v,v), 2) == norm(vcat(v,v), 2) == norm([v,v], 2)
true

julia> norm(hcat(v,v), Inf) == norm(vcat(v,v), Inf) != norm([v,v], Inf)
true

norm(x::Number, p::Real=2)

对于数字，返回 $\left( |x|^p \right)^{1/p}$。

示例

julia> norm(2, 1)
2.0

julia> norm(-2, 1)
2.0

julia> norm(2, 2)
2.0

julia> norm(-2, 2)
2.0

julia> norm(2, Inf)
2.0

julia> norm(-2, Inf)
2.0

opnorm(A::AbstractMatrix, p::Real=2)

计算由向量 p 范数诱导的算子范数（或矩阵范数），其中 p 的有效值为 1、2 或 Inf。（请注意，对于稀疏矩阵，目前未实现 p=2。）使用 norm 计算 Frobenius 范数。

当 p=1 时，算子范数是 A 的最大绝对列和

\[\|A\|_1 = \max_{1 ≤ j ≤ n} \sum_{i=1}^m | a_{ij} |\]

其中 $a_{ij}$ 是 $A$ 的元素，而 $m$ 和 $n$ 是它的维度。

当 p=2 时，算子范数是谱范数，等于 A 的最大奇异值。

当 p=Inf 时，算子范数是 A 的最大绝对行和

\[\|A\|_\infty = \max_{1 ≤ i ≤ m} \sum _{j=1}^n | a_{ij} |\]

示例

julia> A = [1 -2 -3; 2 3 -1]
2×3 Matrix{Int64}:
 1  -2  -3
 2   3  -1

julia> opnorm(A, Inf)
6.0

julia> opnorm(A, 1)
5.0

opnorm(x::Number, p::Real=2)

对于数字，返回 $\left( |x|^p \right)^{1/p}$。这等效于 norm。

opnorm(A::Adjoint{<:Any,<:AbstracVector}, q::Real=2)
opnorm(A::Transpose{<:Any,<:AbstracVector}, q::Real=2)

对于 Adjoint/Transpose 包装的向量，返回 A 的算子 $q$ 范数，这等效于值为 p = q/(q-1) 的 p 范数。它们在 p = q = 2 时重合。使用 norm 计算 A 作为向量的 p 范数。

向量空间与其对偶之间的范数差异是为了保持对偶与点积之间的关系，并且结果与 1 × n 矩阵的算子 p 范数一致。

示例

julia> v = [1; im];

julia> vc = v';

julia> opnorm(vc, 1)
1.0

julia> norm(vc, 1)
2.0

julia> norm(v, 1)
2.0

julia> opnorm(vc, 2)
1.4142135623730951

julia> norm(vc, 2)
1.4142135623730951

julia> norm(v, 2)
1.4142135623730951

julia> opnorm(vc, Inf)
2.0

julia> norm(vc, Inf)
1.0

julia> norm(v, Inf)
1.0

normalize!(a::AbstractArray, p::Real=2)

就地归一化数组 a，使其 p 范数等于 1，即 norm(a, p) == 1。另请参见 normalize 和 norm。

normalize(a, p::Real=2)

归一化 a，使其 p 范数等于 1，即 norm(a, p) == 1。对于标量，这类似于 sign(a)，但 normalize(0) = NaN。另请参见 normalize!，norm 和 sign。

示例

julia> a = [1,2,4];

julia> b = normalize(a)
3-element Vector{Float64}:
 0.2182178902359924
 0.4364357804719848
 0.8728715609439696

julia> norm(b)
1.0

julia> c = normalize(a, 1)
3-element Vector{Float64}:
 0.14285714285714285
 0.2857142857142857
 0.5714285714285714

julia> norm(c, 1)
1.0

julia> a = [1 2 4 ; 1 2 4]
2×3 Matrix{Int64}:
 1  2  4
 1  2  4

julia> norm(a)
6.48074069840786

julia> normalize(a)
2×3 Matrix{Float64}:
 0.154303  0.308607  0.617213
 0.154303  0.308607  0.617213

julia> normalize(3, 1)
1.0

julia> normalize(-8, 1)
-1.0

julia> normalize(0, 1)
NaN

cond(M, p::Real=2)

矩阵 M 的条件数，使用算子 p 范数计算。p 的有效值为 1、2（默认）或 Inf。

condskeel(M, [x, p::Real=Inf])

\[\kappa_S(M, p) = \left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \right\Vert_p \\ \kappa_S(M, x, p) = \frac{\left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \left\vert x \right\vert \right\Vert_p}{\left \Vert x \right \Vert_p}\]

矩阵 M 的 Skeel 条件数 $\kappa_S$，可选地针对向量 x，使用算子 p 范数计算。 $\left\vert M \right\vert$ 表示 (逐元素) 绝对值矩阵 $M$； $\left\vert M \right\vert_{ij} = \left\vert M_{ij} \right\vert$。p 的有效值为 1、2 和 Inf（默认）。

此量在文献中也被称为鲍尔条件数、相对条件数或分量相对条件数。

tr(M)

矩阵迹。对 M 的对角线元素求和。

示例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> tr(A)
5

det(M)

矩阵行列式。

另请参阅：logdet 和 logabsdet。

示例

julia> M = [1 0; 2 2]
2×2 Matrix{Int64}:
 1  0
 2  2

julia> det(M)
2.0

logdet(M)

矩阵行列式的对数。等效于 log(det(M))，但可能提供更高的精度和/或速度。

示例

julia> M = [1 0; 2 2]
2×2 Matrix{Int64}:
 1  0
 2  2

julia> logdet(M)
0.6931471805599453

julia> logdet(Matrix(I, 3, 3))
0.0

logabsdet(M)

矩阵行列式绝对值的对数。等效于 (log(abs(det(M))), sign(det(M)))，但可能提供更高的精度和/或速度。

示例

julia> A = [-1. 0.; 0. 1.]
2×2 Matrix{Float64}:
 -1.0  0.0
  0.0  1.0

julia> det(A)
-1.0

julia> logabsdet(A)
(0.0, -1.0)

julia> B = [2. 0.; 0. 1.]
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  1.0

julia> det(B)
2.0

julia> logabsdet(B)
(0.6931471805599453, 1.0)

inv(M)

矩阵逆。计算矩阵 N 使得 M * N = I，其中 I 是单位矩阵。通过求解左除 N = M \ I 来计算。

示例

julia> M = [2 5; 1 3]
2×2 Matrix{Int64}:
 2  5
 1  3

julia> N = inv(M)
2×2 Matrix{Float64}:
  3.0  -5.0
 -1.0   2.0

julia> M*N == N*M == Matrix(I, 2, 2)
true

pinv(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
pinv(M, rtol::Real) = pinv(M; rtol=rtol) # to be deprecated in Julia 2.0

计算 Moore-Penrose 伪逆。

对于具有浮点元素的矩阵 M，通过仅反转大于 max(atol, rtol*σ₁) 的奇异值来方便地计算伪逆，其中 σ₁ 是 M 的最大奇异值。

绝对容差 (atol) 和相对容差 (rtol) 的最佳选择会根据 M 的值和伪逆的预期应用而有所不同。默认相对容差为 n*ϵ，其中 n 是 M 的最小维度的尺寸，而 ϵ 是 M 的元素类型的 eps。

为了用最小二乘法反转密集的病态矩阵，建议 rtol = sqrt(eps(real(float(oneunit(eltype(M))))))。

有关更多信息，请参阅 ^[issue8859]、^[B96]、^[S84]、^[KY88]。

示例

julia> M = [1.5 1.3; 1.2 1.9]
2×2 Matrix{Float64}:
 1.5  1.3
 1.2  1.9

julia> N = pinv(M)
2×2 Matrix{Float64}:
  1.47287   -1.00775
 -0.930233   1.16279

julia> M * N
2×2 Matrix{Float64}:
 1.0          -2.22045e-16
 4.44089e-16   1.0

nullspace(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
nullspace(M, rtol::Real) = nullspace(M; rtol=rtol) # to be deprecated in Julia 2.0

通过包含奇异值大小小于 max(atol, rtol*σ₁) 的 M 的奇异向量来计算 M 的零空间的基，其中 σ₁ 是 M 的最大奇异值。

默认情况下，相对容差 rtol 为 n*ϵ，其中 n 是 M 的最小维度的尺寸，而 ϵ 是 M 的元素类型的 eps。

示例

julia> M = [1 0 0; 0 1 0; 0 0 0]
3×3 Matrix{Int64}:
 1  0  0
 0  1  0
 0  0  0

julia> nullspace(M)
3×1 Matrix{Float64}:
 0.0
 0.0
 1.0

julia> nullspace(M, rtol=3)
3×3 Matrix{Float64}:
 0.0  1.0  0.0
 1.0  0.0  0.0
 0.0  0.0  1.0

julia> nullspace(M, atol=0.95)
3×1 Matrix{Float64}:
 0.0
 0.0
 1.0

kron(A, B)

计算两个向量、矩阵或数字的克罗内克积。

对于实数向量 v 和 w，克罗内克积与外积的关系为 kron(v,w) == vec(w * transpose(v)) 或 w * transpose(v) == reshape(kron(v,w), (length(w), length(v)))。请注意，这些表达式左侧和右侧的 v 和 w 的排序方式不同（由于列优先存储）。对于复数向量，外积 w * v' 也通过 v 的共轭而有所不同。

示例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> B = [im 1; 1 -im]
2×2 Matrix{Complex{Int64}}:
 0+1im  1+0im
 1+0im  0-1im

julia> kron(A, B)
4×4 Matrix{Complex{Int64}}:
 0+1im  1+0im  0+2im  2+0im
 1+0im  0-1im  2+0im  0-2im
 0+3im  3+0im  0+4im  4+0im
 3+0im  0-3im  4+0im  0-4im

julia> v = [1, 2]; w = [3, 4, 5];

julia> w*transpose(v)
3×2 Matrix{Int64}:
 3   6
 4   8
 5  10

julia> reshape(kron(v,w), (length(w), length(v)))
3×2 Matrix{Int64}:
 3   6
 4   8
 5  10

kron!(C, A, B)

计算 A 和 B 的克罗内克积，并将结果存储在 C 中，覆盖 C 的现有内容。这是 kron 的就地版本。

exp(A::AbstractMatrix)

计算 A 的矩阵指数，定义为

\[e^A = \sum_{n=0}^{\infty} \frac{A^n}{n!}.\]

对于对称或厄米特 A，使用特征分解 (eigen)，否则选择缩放和平方算法（参见 ^[H05]）。

示例

julia> A = Matrix(1.0I, 2, 2)
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

julia> exp(A)
2×2 Matrix{Float64}:
 2.71828  0.0
 0.0      2.71828

cis(A::AbstractMatrix)

对于方阵 A 的 exp(im*A) 的更有效方法（尤其是如果 A 是 Hermitian 或实数 Symmetric）。

另请参阅 cispi、sincos、exp。

示例

julia> cis([π 0; 0 π]) ≈ -I
true

^(A::AbstractMatrix, p::Number)

矩阵幂，等效于 $\exp(p\log(A))$

示例

julia> [1 2; 0 3]^3
2×2 Matrix{Int64}:
 1  26
 0  27

^(b::Number, A::AbstractMatrix)

矩阵指数，等效于 $\exp(\log(b)A)$。

示例

julia> 2^[1 2; 0 3]
2×2 Matrix{Float64}:
 2.0  6.0
 0.0  8.0

julia> ℯ^[1 2; 0 3]
2×2 Matrix{Float64}:
 2.71828  17.3673
 0.0      20.0855

log(A::AbstractMatrix)

如果 A 没有负实数特征值，则计算 A 的主矩阵对数，即唯一的矩阵 $X$，使得 $e^X = A$ 且 $-\pi < Im(\lambda) < \pi$ 对于 $X$ 的所有特征值 $\lambda$ 均成立。如果 A 具有非正特征值，则只要可能，就会返回非主矩阵函数。

如果 A 是对称的或厄米特的，则使用其特征分解 (eigen)，如果 A 是三角形的，则采用改进版本的逆缩放和平方方法（参见 ^[AH12] 和 ^[AHR13]）。如果 A 是实数且没有负特征值，则计算实数 Schur 形式。否则，将计算复数 Schur 形式。然后，在 ^[AHR13] 中的顶端 (拟) 三角算法将应用于顶端 (拟) 三角因子。

示例

julia> A = Matrix(2.7182818*I, 2, 2)
2×2 Matrix{Float64}:
 2.71828  0.0
 0.0      2.71828

julia> log(A)
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

sqrt(x)

返回 $\sqrt{x}$。对于负 Real 参数抛出 DomainError。使用复数负参数代替。前缀运算符 √ 等效于 sqrt。

另请参阅：hypot。

示例

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError with -81.0:
NaN result for non-NaN input.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

julia> sqrt(big(complex(-81)))
0.0 + 9.0im

julia> .√(1:4)
4-element Vector{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772
 2.0

sqrt(A::AbstractMatrix)

如果 A 没有负实数特征值，则计算 A 的主矩阵平方根，即特征值具有正实数部分的唯一矩阵 $X$，使得 $X^2 = A$。否则，将返回非主平方根。

如果 A 是实数对称的或厄米特的，则使用其特征分解 (eigen) 来计算平方根。对于此类矩阵，由于舍入误差而看似略微为负的特征值 λ 将被视为零。更准确地说，所有特征值 ≥ -rtol*(max |λ|) 的矩阵将被视为半定矩阵（产生厄米特平方根），其中负特征值被视为零。rtol 是 sqrt 的关键字参数（仅在厄米特/实数对称情况下），其默认值为机器精度乘以 size(A,1)。

否则，平方根将通过 Björck-Hammarling 方法 ^[BH83] 确定，该方法计算复数 Schur 形式 (schur)，然后计算三角因子的复数平方根。如果存在实数平方根，则改为使用该方法的扩展版本 ^[H87]，该方法计算实数 Schur 形式，然后计算拟三角因子的实数平方根。

示例

julia> A = [4 0; 0 4]
2×2 Matrix{Int64}:
 4  0
 0  4

julia> sqrt(A)
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  2.0

cos(A::AbstractMatrix)

计算方阵 A 的矩阵余弦。

如果 A 是对称的或厄米特的，则使用其特征分解 (eigen) 来计算余弦。否则，余弦将通过调用 exp 来确定。

示例

julia> cos(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927

sin(A::AbstractMatrix)

计算方阵 A 的矩阵正弦。

如果 A 是对称的或厄米特的，则使用其特征分解 (eigen) 来计算正弦。否则，正弦将通过调用 exp 来确定。

示例

julia> sin(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 0.454649  0.454649
 0.454649  0.454649

sincos(A::AbstractMatrix)

计算方阵 A 的矩阵正弦和余弦。

示例

julia> S, C = sincos(fill(1.0, (2,2)));

julia> S
2×2 Matrix{Float64}:
 0.454649  0.454649
 0.454649  0.454649

julia> C
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927

tan(A::AbstractMatrix)

计算方阵 A 的矩阵正切。

如果 A 是对称的或厄米特的，则使用其特征分解 (eigen) 来计算正切。否则，正切将通过调用 exp 来确定。

示例

julia> tan(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 -1.09252  -1.09252
 -1.09252  -1.09252

sec(A::AbstractMatrix)

计算方阵 A 的矩阵正割。

csc(A::AbstractMatrix)

计算方阵 A 的矩阵余割。

cot(A::AbstractMatrix)

计算方阵 A 的矩阵余切。

cosh(A::AbstractMatrix)

计算方阵A的矩阵双曲余弦。

sinh(A::AbstractMatrix)

计算方阵A的矩阵双曲正弦。

tanh(A::AbstractMatrix)

计算方阵A的矩阵双曲正切。

sech(A::AbstractMatrix)

计算方阵A的矩阵双曲正割。

csch(A::AbstractMatrix)

计算方阵A的矩阵双曲余割。

coth(A::AbstractMatrix)

计算方阵A的矩阵双曲余切。

acos(A::AbstractMatrix)

计算方阵A的矩阵反余弦。

如果A是对称或厄米特矩阵，则使用其特征分解（eigen）来计算反余弦。否则，反余弦由 log 和 sqrt 确定。有关用于计算此函数的理论和对数公式，请参阅 ^[AH16_1]。

示例

julia> acos(cos([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5-8.32667e-17im  0.1+0.0im
 -0.2+2.63678e-16im  0.3-3.46945e-16im

asin(A::AbstractMatrix)

计算方阵A的矩阵反正弦。

如果A是对称或厄米特矩阵，则使用其特征分解（eigen）来计算反正弦。否则，反正弦由 log 和 sqrt 确定。有关用于计算此函数的理论和对数公式，请参阅 ^[AH16_2]。

示例

julia> asin(sin([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5-4.16334e-17im  0.1-5.55112e-17im
 -0.2+9.71445e-17im  0.3-1.249e-16im

atan(A::AbstractMatrix)

计算方阵A的矩阵反正切。

如果A是对称或厄米特矩阵，则使用其特征分解（eigen）来计算反正切。否则，反正切由 log 确定。有关用于计算此函数的理论和对数公式，请参阅 ^[AH16_3]。

示例

julia> atan(tan([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5+1.38778e-17im  0.1-2.77556e-17im
 -0.2+6.93889e-17im  0.3-4.16334e-17im

asec(A::AbstractMatrix)

计算A的矩阵反正割。

acsc(A::AbstractMatrix)

计算A的矩阵反余割。

acot(A::AbstractMatrix)

计算A的矩阵反余切。

acosh(A::AbstractMatrix)

计算方阵A的矩阵反双曲余弦。有关用于计算此函数的理论和对数公式，请参阅 ^[AH16_4]。

asinh(A::AbstractMatrix)

计算方阵A的矩阵反双曲正弦。有关用于计算此函数的理论和对数公式，请参阅 ^[AH16_5]。

atanh(A::AbstractMatrix)

计算方阵A的矩阵反双曲正切。有关用于计算此函数的理论和对数公式，请参阅 ^[AH16_6]。

asech(A::AbstractMatrix)

计算A的矩阵反双曲正割。

acsch(A::AbstractMatrix)

计算A的矩阵反双曲余割。

acoth(A::AbstractMatrix)

计算A的矩阵反双曲余切。

lyap(A, C)

计算连续李雅普诺夫方程 AX + XA' + C = 0 的解 X，其中 A 的任何特征值都没有零实部，并且没有两个特征值是彼此的负复共轭。

示例

julia> A = [3. 4.; 5. 6]
2×2 Matrix{Float64}:
 3.0  4.0
 5.0  6.0

julia> B = [1. 1.; 1. 2.]
2×2 Matrix{Float64}:
 1.0  1.0
 1.0  2.0

julia> X = lyap(A, B)
2×2 Matrix{Float64}:
  0.5  -0.5
 -0.5   0.25

julia> A*X + X*A' ≈ -B
true

sylvester(A, B, C)

计算西尔维斯特方程 AX + XB + C = 0 的解 X，其中 A、B 和 C 具有兼容的维度，并且 A 和 -B 没有具有相同实部的特征值。

示例

julia> A = [3. 4.; 5. 6]
2×2 Matrix{Float64}:
 3.0  4.0
 5.0  6.0

julia> B = [1. 1.; 1. 2.]
2×2 Matrix{Float64}:
 1.0  1.0
 1.0  2.0

julia> C = [1. 2.; -2. 1]
2×2 Matrix{Float64}:
  1.0  2.0
 -2.0  1.0

julia> X = sylvester(A, B, C)
2×2 Matrix{Float64}:
 -4.46667   1.93333
  3.73333  -1.8

julia> A*X + X*B ≈ -C
true

issuccess(F::Factorization)

测试矩阵的因式分解是否成功。

julia> F = cholesky([1 0; 0 1]);

julia> issuccess(F)
true

julia> F = lu([1 0; 0 0]; check = false);

julia> issuccess(F)
false

issymmetric(A) -> Bool

测试矩阵是否是对称矩阵。

示例

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> issymmetric(a)
true

julia> b = [1 im; -im 1]
2×2 Matrix{Complex{Int64}}:
 1+0im  0+1im
 0-1im  1+0im

julia> issymmetric(b)
false

isposdef(A) -> Bool

通过尝试对 A 执行 Cholesky 因式分解来测试矩阵是否为正定矩阵（且为厄米特矩阵）。

另请参见 isposdef!、cholesky。

示例

julia> A = [1 2; 2 50]
2×2 Matrix{Int64}:
 1   2
 2  50

julia> isposdef(A)
true

isposdef!(A) -> Bool

通过尝试对 A 执行 Cholesky 因式分解来测试矩阵是否为正定矩阵（且为厄米特矩阵），在此过程中会覆盖 A。另请参见 isposdef。

示例

julia> A = [1. 2.; 2. 50.];

julia> isposdef!(A)
true

julia> A
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  6.78233

istril(A::AbstractMatrix, k::Integer = 0) -> Bool

测试 A 是否从第 k 个超对角线开始为下三角矩阵。

示例

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> istril(a)
false

julia> istril(a, 1)
true

julia> b = [1 0; -im -1]
2×2 Matrix{Complex{Int64}}:
 1+0im   0+0im
 0-1im  -1+0im

julia> istril(b)
true

julia> istril(b, -1)
false

istriu(A::AbstractMatrix, k::Integer = 0) -> Bool

测试 A 是否从第 k 个超对角线开始为上三角矩阵。

示例

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> istriu(a)
false

julia> istriu(a, -1)
true

julia> b = [1 im; 0 -1]
2×2 Matrix{Complex{Int64}}:
 1+0im   0+1im
 0+0im  -1+0im

julia> istriu(b)
true

julia> istriu(b, 1)
false

isdiag(A) -> Bool

测试矩阵是否为对角矩阵，即 iszero(A[i,j]) 为真，除非 i == j。请注意，A 不必为方阵；如果您还想检查这一点，则需要检查 size(A, 1) == size(A, 2)。

示例

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> isdiag(a)
false

julia> b = [im 0; 0 -im]
2×2 Matrix{Complex{Int64}}:
 0+1im  0+0im
 0+0im  0-1im

julia> isdiag(b)
true

julia> c = [1 0 0; 0 2 0]
2×3 Matrix{Int64}:
 1  0  0
 0  2  0

julia> isdiag(c)
true

julia> d = [1 0 0; 0 2 3]
2×3 Matrix{Int64}:
 1  0  0
 0  2  3

julia> isdiag(d)
false

ishermitian(A) -> Bool

测试矩阵是否为厄米特矩阵。

示例

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> ishermitian(a)
true

julia> b = [1 im; -im 1]
2×2 Matrix{Complex{Int64}}:
 1+0im  0+1im
 0-1im  1+0im

julia> ishermitian(b)
true

transpose(A)

延迟转置。对返回的对象进行变异应该适当地变异 A。通常，但不总是，会产生 Transpose(A)，其中 Transpose 是延迟转置包装器。请注意，此操作是递归的。

此操作旨在用于线性代数用法 - 对于一般数据操作，请参阅 permutedims，它是非递归的。

示例

julia> A = [3 2; 0 0]
2×2 Matrix{Int64}:
 3  2
 0  0

julia> B = transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 3  0
 2  0

julia> B isa Transpose
true

julia> transpose(B) === A # the transpose of a transpose unwraps the parent
true

julia> Transpose(B) # however, the constructor always wraps its argument
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
 3  2
 0  0

julia> B[1,2] = 4; # modifying B will modify A automatically

julia> A
2×2 Matrix{Int64}:
 3  2
 4  0

对于复数矩阵，adjoint 操作等效于共轭转置。

julia> A = reshape([Complex(x, x) for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> adjoint(A) == conj(transpose(A))
true

AbstractVector 的 transpose 是一个行向量

julia> v = [1,2,3]
3-element Vector{Int64}:
 1
 2
 3

julia> transpose(v) # returns a row-vector
1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> transpose(v) * v # compute the dot product
14

对于矩阵的矩阵，对各个块进行递归操作

julia> C = [1 3; 2 4]
2×2 Matrix{Int64}:
 1  3
 2  4

julia> D = reshape([C, 2C, 3C, 4C], 2, 2) # construct a block matrix
2×2 Matrix{Matrix{Int64}}:
 [1 3; 2 4]  [3 9; 6 12]
 [2 6; 4 8]  [4 12; 8 16]

julia> transpose(D) # blocks are recursively transposed
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 2; 3 4]   [2 4; 6 8]
 [3 6; 9 12]  [4 8; 12 16]

transpose(F::Factorization)

因式分解 F 的延迟转置。默认情况下，返回 TransposeFactorization，除了 Factorization 的 eltype 为实数，在这种情况下返回 AdjointFactorization。

transpose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

转置矩阵 A 并将其存储在矩阵 X 中。size(X) 必须等于 size(transpose(A))。除了根据需要调整 X 的 rowval 和 nzval 的大小外，不会分配任何其他内存。

参见 halfperm!

transpose!(dest,src)

转置数组 src 并将结果存储在预分配的数组 dest 中，该数组的大小应对应于 (size(src,2),size(src,1))。不支持就地转置，如果 src 和 dest 具有重叠的内存区域，则会发生意外结果。

示例

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
 0+0im  0+0im
 0+0im  0+0im

julia> transpose!(B, A);

julia> B
2×2 Matrix{Complex{Int64}}:
 3+2im  8+7im
 9+2im  4+6im

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

Transpose

对底层线性代数对象的转置视图的延迟包装器类型，通常是 AbstractVector/AbstractMatrix。通常，不应直接调用 Transpose 构造函数，而是使用 transpose。要实现视图，请使用 copy。

此类型旨在用于线性代数用法 - 对于一般数据操作，请参阅 permutedims。

示例

julia> A = [2 3; 0 0]
2×2 Matrix{Int64}:
 2  3
 0  0

julia> Transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 2  0
 3  0

TransposeFactorization

对底层 Factorization 对象的转置的延迟包装器类型。通常，不应直接调用 TransposeFactorization 构造函数，而是使用 transpose(:: Factorization)。

A'
adjoint(A)

延迟伴随（共轭转置）。请注意，adjoint 递归地应用于元素。

对于数字类型，adjoint 返回复共轭，因此对于实数，它等效于恒等函数。

此操作旨在用于线性代数用法 - 对于一般数据操作，请参阅 permutedims。

示例

julia> A = [3+2im 9+2im; 0  0]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 0+0im  0+0im

julia> B = A' # equivalently adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

julia> B isa Adjoint
true

julia> adjoint(B) === A # the adjoint of an adjoint unwraps the parent
true

julia> Adjoint(B) # however, the constructor always wraps its argument
2×2 adjoint(adjoint(::Matrix{Complex{Int64}})) with eltype Complex{Int64}:
 3+2im  9+2im
 0+0im  0+0im

julia> B[1,2] = 4 + 5im; # modifying B will modify A automatically

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 4-5im  0+0im

对于实数矩阵，adjoint 操作等效于 transpose。

julia> A = reshape([x for x in 1:4], 2, 2)
2×2 Matrix{Int64}:
 1  3
 2  4

julia> A'
2×2 adjoint(::Matrix{Int64}) with eltype Int64:
 1  2
 3  4

julia> adjoint(A) == transpose(A)
true

AbstractVector 的伴随是一个行向量

julia> x = [3, 4im]
2-element Vector{Complex{Int64}}:
 3 + 0im
 0 + 4im

julia> x'
1×2 adjoint(::Vector{Complex{Int64}}) with eltype Complex{Int64}:
 3+0im  0-4im

julia> x'x # compute the dot product, equivalently x' * x
25 + 0im

对于矩阵的矩阵，对各个块进行递归操作

julia> A = reshape([x + im*x for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> C = reshape([A, 2A, 3A, 4A], 2, 2)
2×2 Matrix{Matrix{Complex{Int64}}}:
 [1+1im 3+3im; 2+2im 4+4im]  [3+3im 9+9im; 6+6im 12+12im]
 [2+2im 6+6im; 4+4im 8+8im]  [4+4im 12+12im; 8+8im 16+16im]

julia> C'
2×2 adjoint(::Matrix{Matrix{Complex{Int64}}}) with eltype Adjoint{Complex{Int64}, Matrix{Complex{Int64}}}:
 [1-1im 2-2im; 3-3im 4-4im]    [2-2im 4-4im; 6-6im 8-8im]
 [3-3im 6-6im; 9-9im 12-12im]  [4-4im 8-8im; 12-12im 16-16im]

adjoint(F::Factorization)

因式分解 F 的延迟伴随。默认情况下，返回 AdjointFactorization 包装器。

adjoint!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

将矩阵A转置，并将元素的伴随存储在矩阵X中。size(X)必须等于size(transpose(A))。除了在需要时调整X的rowval和nzval的大小外，不会分配其他内存。

参见 halfperm!

adjoint!(dest,src)

将共轭转置数组src存储在预先分配的数组dest中，该数组的大小应对应于(size(src,2),size(src,1))。不支持就地转置，如果src和dest具有重叠的内存区域，则会发生意外的结果。

示例

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
 0+0im  0+0im
 0+0im  0+0im

julia> adjoint!(B, A);

julia> B
2×2 Matrix{Complex{Int64}}:
 3-2im  8-7im
 9-2im  4-6im

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

Adjoint

用于底层线性代数对象的伴随视图的惰性包装类型，通常是AbstractVector/AbstractMatrix。通常，不应直接调用Adjoint构造函数，请使用adjoint。要实现视图，请使用copy.

此类型旨在用于线性代数用法 - 对于一般数据操作，请参阅 permutedims。

示例

julia> A = [3+2im 9+2im; 0 0]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 0+0im  0+0im

julia> Adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

AdjointFactorization

用于底层Factorization对象的伴随的惰性包装类型。通常，不应直接调用AdjointFactorization构造函数，请使用adjoint(:: Factorization)。

copy(A::Transpose)
copy(A::Adjoint)

急切地评估惰性矩阵转置/伴随。请注意，转置递归地应用于元素。

此操作旨在用于线性代数用法 - 对于一般数据操作，请参阅 permutedims，它是非递归的。

示例

julia> A = [1 2im; -3im 4]
2×2 Matrix{Complex{Int64}}:
 1+0im  0+2im
 0-3im  4+0im

julia> T = transpose(A)
2×2 transpose(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 1+0im  0-3im
 0+2im  4+0im

julia> copy(T)
2×2 Matrix{Complex{Int64}}:
 1+0im  0-3im
 0+2im  4+0im

stride1(A) -> Int

以元素大小为单位返回维度 1 中连续数组元素之间的距离。

示例

julia> A = [1,2,3,4]
4-element Vector{Int64}:
 1
 2
 3
 4

julia> LinearAlgebra.stride1(A)
1

julia> B = view(A, 2:2:4)
2-element view(::Vector{Int64}, 2:2:4) with eltype Int64:
 2
 4

julia> LinearAlgebra.stride1(B)
2

LinearAlgebra.checksquare(A)

检查矩阵是否为方阵，然后返回其公共维度。对于多个参数，返回一个向量。

示例

julia> A = fill(1, (4,4)); B = fill(1, (5,5));

julia> LinearAlgebra.checksquare(A, B)
2-element Vector{Int64}:
 4
 5

LinearAlgebra.peakflops(n::Integer=4096; eltype::DataType=Float64, ntrials::Integer=3, parallel::Bool=false)

peakflops通过使用双精度gemm!计算计算机的峰值浮点运算速率。默认情况下，如果未指定参数，它会将两个大小为n x n的Float64矩阵相乘，其中n = 4096。如果底层 BLAS 使用多个线程，则会实现更高的浮点运算速率。可以使用BLAS.set_num_threads(n)设置 BLAS 线程数。

如果提供了关键字参数eltype，peakflops将使用类型为eltype的元素构造矩阵以计算峰值浮点运算速率。

默认情况下，peakflops将使用 3 次试验中的最佳计时。如果提供了ntrials关键字参数，peakflops将使用这些次数的试验来选择最佳计时。

如果关键字参数parallel设置为true，peakflops将在所有工作进程上并行运行。将返回整个并行计算机的浮点运算速率。在并行运行时，仅使用 1 个 BLAS 线程。参数n仍然是指每个处理器上求解的问题的大小。

hermitianpart(A, uplo=:U) -> Hermitian

返回方阵A的厄米特部分，定义为(A + A') / 2，作为Hermitian矩阵。对于实矩阵A，这也称为A的对称部分；它有时也被称为“算子实部”。可选参数uplo控制Hermitian视图的相应参数。对于实矩阵，后者等效于Symmetric视图。

另请参阅hermitianpart!以获取相应的就地操作。

hermitianpart!(A, uplo=:U) -> Hermitian

用其厄米特部分(A + A') / 2就地覆盖方阵A，并返回Hermitian(A, uplo)。对于实矩阵A，这也称为A的对称部分。

另请参阅hermitianpart以获取相应的非就地操作。

mul!(Y, A, B) -> Y

计算矩阵-矩阵或矩阵-向量积$AB$并将结果存储在Y中，覆盖Y的现有值。请注意，Y不能与A或B别名。

示例

julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; Y = similar(B); mul!(Y, A, B);

julia> Y
2×2 Matrix{Float64}:
 3.0  3.0
 7.0  7.0

实现

对于自定义矩阵和向量类型，建议尽可能实现 5 参数mul!，而不是直接实现 3 参数mul!。

mul!(C, A, B, α, β) -> C

组合就地矩阵-矩阵或矩阵-向量乘法-加法$A B α + C β$。结果通过覆盖存储在C中。请注意，C不能与A或B别名。

示例

julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; C=[1.0 2.0; 3.0 4.0];

julia> mul!(C, A, B, 100.0, 10.0) === C
true

julia> C
2×2 Matrix{Float64}:
 310.0  320.0
 730.0  740.0

lmul!(a::Number, B::AbstractArray)

将数组B按标量a缩放，就地覆盖B。使用rmul!从右边乘以标量。缩放操作尊重a和B的元素之间的乘法*的语义。特别地，这也适用于涉及非有限数（如NaN和±Inf）的乘法。

示例

julia> B = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> lmul!(2, B)
2×2 Matrix{Int64}:
 2  4
 6  8

julia> lmul!(0.0, [Inf])
1-element Vector{Float64}:
 NaN

lmul!(A, B)

计算矩阵-矩阵积$AB$，覆盖B，并返回结果。这里，A必须是特殊矩阵类型，例如Diagonal、UpperTriangular或LowerTriangular，或一些正交类型，见QR。

示例

julia> B = [0 1; 1 0];

julia> A = UpperTriangular([1 2; 0 3]);

julia> lmul!(A, B);

julia> B
2×2 Matrix{Int64}:
 2  1
 3  0

julia> B = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> lmul!(F.Q, B)
2×2 Matrix{Float64}:
 3.0  4.0
 1.0  2.0

rmul!(A::AbstractArray, b::Number)

将数组A按标量b缩放，就地覆盖A。使用lmul!从左边乘以标量。缩放操作尊重A的元素和b之间的乘法*的语义。特别地，这也适用于涉及非有限数（如NaN和±Inf）的乘法。

示例

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rmul!(A, 2)
2×2 Matrix{Int64}:
 2  4
 6  8

julia> rmul!([NaN], 0.0)
1-element Vector{Float64}:
 NaN

rmul!(A, B)

计算矩阵-矩阵积$AB$，覆盖A，并返回结果。这里，B必须是特殊矩阵类型，例如Diagonal、UpperTriangular或LowerTriangular，或一些正交类型，见QR。

示例

julia> A = [0 1; 1 0];

julia> B = UpperTriangular([1 2; 0 3]);

julia> rmul!(A, B);

julia> A
2×2 Matrix{Int64}:
 0  3
 1  2

julia> A = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> rmul!(A, F.Q)
2×2 Matrix{Float64}:
 2.0  1.0
 4.0  3.0

ldiv!(Y, A, B) -> Y

就地计算A \ B并将结果存储在Y中，返回结果。

参数A不应是矩阵。相反，它不应该是矩阵，而应该是分解对象（例如，由factorize或cholesky生成）。这样做的原因是，分解本身既昂贵又通常会分配内存（尽管也可以通过例如lu!就地进行），并且需要ldiv!的高性能情况通常也需要对A的分解进行细粒度控制。

示例

julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];

julia> X = [1; 2.5; 3];

julia> Y = zero(X);

julia> ldiv!(Y, qr(A), X);

julia> Y
3-element Vector{Float64}:
  0.7128099173553719
 -0.051652892561983674
  0.10020661157024757

julia> A\X
3-element Vector{Float64}:
  0.7128099173553719
 -0.05165289256198333
  0.10020661157024785

ldiv!(A, B)

就地计算A \ B，覆盖B以存储结果。

参数A不应是矩阵。相反，它不应该是矩阵，而应该是分解对象（例如，由factorize或cholesky生成）。这样做的原因是，分解本身既昂贵又通常会分配内存（尽管也可以通过例如lu!就地进行），并且需要ldiv!的高性能情况通常也需要对A的分解进行细粒度控制。

示例

julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];

julia> X = [1; 2.5; 3];

julia> Y = copy(X);

julia> ldiv!(qr(A), X);

julia> X
3-element Vector{Float64}:
  0.7128099173553719
 -0.051652892561983674
  0.10020661157024757

julia> A\Y
3-element Vector{Float64}:
  0.7128099173553719
 -0.05165289256198333
  0.10020661157024785

ldiv!(a::Number, B::AbstractArray)

将数组B中的每个条目除以标量a，就地覆盖B。使用rdiv!从右边除以标量。

示例

julia> B = [1.0 2.0; 3.0 4.0]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> ldiv!(2.0, B)
2×2 Matrix{Float64}:
 0.5  1.0
 1.5  2.0

rdiv!(A, B)

就地计算A / B，覆盖A以存储结果。

参数B不应是矩阵。相反，它不应该是矩阵，而应该是分解对象（例如，由factorize或cholesky生成）。这样做的原因是，分解本身既昂贵又通常会分配内存（尽管也可以通过例如lu!就地进行），并且需要rdiv!的高性能情况通常也需要对B的分解进行细粒度控制。

rdiv!(A::AbstractArray, b::Number)

将数组A中的每个条目除以标量b，就地覆盖A。使用ldiv!从左边除以标量。

示例

julia> A = [1.0 2.0; 3.0 4.0]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> rdiv!(A, 2.0)
2×2 Matrix{Float64}:
 0.5  1.0
 1.5  2.0

LinearAlgebra.BLAS — 模块

set_num_threads(n::Integer)
set_num_threads(::Nothing)

LinearAlgebra.BLAS.set_num_threads — 函数

将 BLAS 库使用的线程数设置为等于n::Integer。

get_num_threads()

LinearAlgebra.BLAS.get_num_threads — 函数

rot!(n, X, incx, Y, incy, c, s)

LinearAlgebra.BLAS.rot! — 函数

scal!(n, a, X, incx)
scal!(a, X)

LinearAlgebra.BLAS.scal! — 函数

将 X 覆盖为 a*X，用于数组 X 的前 n 个元素（步长为 incx）。返回 X。

scal(n, a, X, incx)
scal(a, X)

LinearAlgebra.BLAS.scal — 函数

将 X 覆盖为 a*X，用于数组 X 的前 n 个元素（步长为 incx）。返回 X。

blascopy!(n, X, incx, Y, incy)

LinearAlgebra.BLAS.blascopy! — 函数

dot(n, X, incx, Y, incy)

LinearAlgebra.BLAS.dot — 函数

示例

julia> BLAS.dot(10, fill(1.0, 10), 1, fill(1.0, 20), 2)
10.0

dotu(n, X, incx, Y, incy)

LinearAlgebra.BLAS.dotu — 函数

示例

julia> BLAS.dotu(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
-10.0 + 10.0im

dotc(n, X, incx, U, incy)

LinearAlgebra.BLAS.dotc — 函数

示例

julia> BLAS.dotc(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
10.0 - 10.0im

nrm2(n, X, incx)

LinearAlgebra.BLAS.nrm2 — 函数

示例

julia> BLAS.nrm2(4, fill(1.0, 8), 2)
2.0

julia> BLAS.nrm2(1, fill(1.0, 8), 2)
1.0

asum(n, X, incx)

LinearAlgebra.BLAS.asum — 函数

数组 X 的前 n 个元素（步长为 incx）的幅值的总和。

示例

julia> BLAS.asum(5, fill(1.0im, 10), 2)
5.0

julia> BLAS.asum(2, fill(1.0im, 10), 5)
2.0

iamax(n, dx, incx)
iamax(dx)

LinearAlgebra.BLAS.iamax — 函数

gemv!(tA, alpha, A, x, beta, y)

LinearAlgebra.BLAS.gemv! — 函数

gemv(tA, alpha, A, x)

LinearAlgebra.BLAS.gemv — 方法

gemv(tA, A, x)

LinearAlgebra.BLAS.gemv — 方法

gbmv!(trans, m, kl, ku, alpha, A, x, beta, y)

LinearAlgebra.BLAS.gbmv! — 函数

gbmv(trans, m, kl, ku, alpha, A, x)

LinearAlgebra.BLAS.gbmv — 函数

hemv!(ul, alpha, A, x, beta, y)

LinearAlgebra.BLAS.hemv! — 函数

hemv(ul, alpha, A, x)

LinearAlgebra.BLAS.hemv — 方法

hemv(ul, A, x)

LinearAlgebra.BLAS.hemv — 方法

hpmv!(uplo, α, AP, x, β, y)

LinearAlgebra.BLAS.hpmv! — 函数

将向量 y 更新为 α*A*x + β*y，其中 A 是以压缩格式 AP 提供的厄米特矩阵。

当 uplo = 'U' 时，数组 AP 必须包含按顺序逐列压缩的厄米特矩阵的上三角部分，使得 AP[1] 包含 A[1, 1]，AP[2] 和 AP[3] 分别包含 A[1, 2] 和 A[2, 2]，依此类推。

当 uplo = 'L' 时，数组 AP 必须包含按顺序逐列压缩的厄米特矩阵的下三角部分，使得 AP[1] 包含 A[1, 1]，AP[2] 和 AP[3] 分别包含 A[2, 1] 和 A[3, 1]，依此类推。

标量输入 α 和 β 必须是复数或实数。

数组输入 x、y 和 AP 必须都是 ComplexF32 或 ComplexF64 类型。

symv!(ul, alpha, A, x, beta, y)

LinearAlgebra.BLAS.symv! — 函数

symv(ul, alpha, A, x)

LinearAlgebra.BLAS.symv — 方法

symv(ul, A, x)

LinearAlgebra.BLAS.symv — 方法

sbmv!(uplo, k, alpha, A, x, beta, y)

LinearAlgebra.BLAS.sbmv! — 函数

数组输入 x、y 和 AP 必须都是 ComplexF32 或 ComplexF64 类型。

sbmv(uplo, k, alpha, A, x)

LinearAlgebra.BLAS.sbmv — 方法

sbmv(uplo, k, A, x)

返回 A*x，其中 A 是一个阶数为 size(A,2) 的对称带状矩阵，其 k 个超对角线存储在参数 A 中。仅使用 A 的 uplo 三角形。

spmv!(uplo, α, AP, x, β, y)

将向量 y 更新为 α*A*x + β*y，其中 A 是以压缩格式 AP 提供的对称矩阵。

当 uplo = 'U' 时，数组 AP 必须包含对称矩阵的上三角部分，按列顺序压缩，以便 AP[1] 包含 A[1, 1]，AP[2] 和 AP[3] 分别包含 A[1, 2] 和 A[2, 2]，依此类推。

当 uplo = 'L' 时，数组 AP 必须包含对称矩阵的下三角部分，按列顺序压缩，以便 AP[1] 包含 A[1, 1]，AP[2] 和 AP[3] 分别包含 A[2, 1] 和 A[3, 1]，依此类推。

标量输入 α 和 β 必须为实数。

数组输入 x、y 和 AP 必须全部为 Float32 或 Float64 类型。

数组输入 x、y 和 AP 必须都是 ComplexF32 或 ComplexF64 类型。

trmv!(ul, tA, dA, A, b)

返回 op(A)*b，其中 op 由 tA 决定。仅使用 A 的 ul 三角形。 dA 决定是读取对角线值还是假定它们全部为 1。乘法在 b 上就地进行。

trmv(ul, tA, dA, A, b)

返回 op(A)*b，其中 op 由 tA 决定。仅使用 A 的 ul 三角形。 dA 决定是读取对角线值还是假定它们全部为 1。

trsv!(ul, tA, dA, A, b)

将 b 覆盖为 A*x = b 的解，或由 tA 和 ul 决定的另外两种变体之一。 dA 决定是读取对角线值还是假定它们全部为 1。返回更新后的 b。

trsv(ul, tA, dA, A, b)

返回 A*x = b 的解，或由 tA 和 ul 决定的另外两种变体之一。 dA 决定是读取对角线值还是假定它们全部为 1。

ger!(alpha, x, y, A)

矩阵 A 的秩 1 更新，向量 x 和 y 作为 alpha*x*y' + A。

her!(uplo, alpha, x, A)

仅适用于复数数组。埃尔米特矩阵 A 的秩 1 更新，向量 x 作为 alpha*x*x' + A。 uplo 控制 A 的哪个三角形被更新。返回 A。

syr!(uplo, alpha, x, A)

对称矩阵 A 的秩 1 更新，向量 x 作为 alpha*x*transpose(x) + A。 uplo 控制 A 的哪个三角形被更新。返回 A。

spr!(uplo, α, x, AP)

将矩阵 A 更新为 A+α*x*x'，其中 A 是以压缩格式 AP 提供的对称矩阵，x 是一个向量。

当 uplo = 'U' 时，数组 AP 必须包含对称矩阵的上三角部分，按列顺序压缩，以便 AP[1] 包含 A[1, 1]，AP[2] 和 AP[3] 分别包含 A[1, 2] 和 A[2, 2]，依此类推。

当 uplo = 'L' 时，数组 AP 必须包含对称矩阵的下三角部分，按列顺序压缩，以便 AP[1] 包含 A[1, 1]，AP[2] 和 AP[3] 分别包含 A[2, 1] 和 A[3, 1]，依此类推。

标量输入 α 必须为实数。

数组输入 x 和 AP 必须全部为 Float32 或 Float64 类型。返回更新后的 AP。

gemm!(tA, tB, alpha, A, B, beta, C)

根据 tA 和 tB 将 C 更新为 alpha*A*B + beta*C 或另外三个变体。返回更新后的 C。

gemm(tA, tB, alpha, A, B)

根据 tA 和 tB 返回 alpha*A*B 或另外三个变体。

gemm(tA, tB, A, B)

根据 tA 和 tB 返回 A*B 或另外三个变体。

symm!(side, ul, alpha, A, B, beta, C)

根据 side 将 C 更新为 alpha*A*B + beta*C 或 alpha*B*A + beta*C。假定 A 为对称矩阵。仅使用 A 的 ul 三角形。返回更新后的 C。

symm(side, ul, alpha, A, B)

根据 side 返回 alpha*A*B 或 alpha*B*A。假定 A 为对称矩阵。仅使用 A 的 ul 三角形。

symm(side, ul, A, B)

根据 side 返回 A*B 或 B*A。假定 A 为对称矩阵。仅使用 A 的 ul 三角形。

hemm!(side, ul, alpha, A, B, beta, C)

根据 side 将 C 更新为 alpha*A*B + beta*C 或 alpha*B*A + beta*C。假定 A 为埃尔米特矩阵。仅使用 A 的 ul 三角形。返回更新后的 C。

hemm(side, ul, alpha, A, B)

根据 side 返回 alpha*A*B 或 alpha*B*A。假定 A 为埃尔米特矩阵。仅使用 A 的 ul 三角形。

hemm(side, ul, A, B)

根据 side 返回 A*B 或 B*A。假定 A 为埃尔米特矩阵。仅使用 A 的 ul 三角形。

syrk!(uplo, trans, alpha, A, beta, C)

对称矩阵 C 的秩 k 更新，作为 alpha*A*transpose(A) + beta*C 或 alpha*transpose(A)*A + beta*C，根据 trans。仅使用 C 的 uplo 三角形。返回 C。

syrk(uplo, trans, alpha, A)

根据 uplo 返回 alpha*A*transpose(A) 或 alpha*transpose(A)*A 的上三角或下三角，根据 trans。

herk!(uplo, trans, alpha, A, beta, C)

仅适用于复数数组。埃尔米特矩阵 C 的秩 k 更新，作为 alpha*A*A' + beta*C 或 alpha*A'*A + beta*C，根据 trans。仅更新 C 的 uplo 三角形。返回 C。

herk(uplo, trans, alpha, A)

仅适用于复数数组。返回 alpha*A*A' 或 alpha*A'*A 的 uplo 三角形，根据 trans。

syr2k!(uplo, trans, alpha, A, B, beta, C)

对称矩阵 C 的秩 2k 更新，作为 alpha*A*transpose(B) + alpha*B*transpose(A) + beta*C 或 alpha*transpose(A)*B + alpha*transpose(B)*A + beta*C，根据 trans。仅使用 C 的 uplo 三角形。返回 C。

syr2k(uplo, trans, alpha, A, B)

返回 alpha*A*transpose(B) + alpha*B*transpose(A) 或 alpha*transpose(A)*B + alpha*transpose(B)*A 的 uplo 三角形，根据 trans。

syr2k(uplo, trans, A, B)

返回 A*transpose(B) + B*transpose(A) 或 transpose(A)*B + transpose(B)*A 的 uplo 三角形，根据 trans。

her2k!(uplo, trans, alpha, A, B, beta, C)

埃尔米特矩阵 C 的秩 2k 更新，作为 alpha*A*B' + alpha*B*A' + beta*C 或 alpha*A'*B + alpha*B'*A + beta*C，根据 trans。标量 beta 必须为实数。仅使用 C 的 uplo 三角形。返回 C。

her2k(uplo, trans, alpha, A, B)

返回 alpha*A*B' + alpha*B*A' 或 alpha*A'*B + alpha*B'*A 的 uplo 三角形，根据 trans。

her2k(uplo, trans, A, B)

返回 A*B' + B*A' 或 A'*B + B'*A 的 uplo 三角形，根据 trans。

trmm!(side, ul, tA, dA, alpha, A, B)

将 B 更新为 alpha*A*B，或由 side 和 tA 决定的另外三个变体之一。仅使用 A 的 ul 三角形。 dA 决定是读取对角线值还是假定它们全部为 1。返回更新后的 B。

trmm(side, ul, tA, dA, alpha, A, B)

返回 alpha*A*B，或由 side 和 tA 决定的另外三个变体之一。仅使用 A 的 ul 三角形。 dA 决定是读取对角线值还是假定它们全部为 1。

trsm!(side, ul, tA, dA, alpha, A, B)

将 B 覆盖为 A*X = alpha*B 的解，或由 side 和 tA 决定的另外三个变体之一。仅使用 A 的 ul 三角形。 dA 决定是读取对角线值还是假定它们全部为 1。返回更新后的 B。

trsm(side, ul, tA, dA, alpha, A, B)

返回 A*X = alpha*B 的解或由 side 和 tA 确定的其他三种变体之一。仅使用 A 的 ul 三角形。 dA 确定是否读取对角线值或假设它们全部为一。

LAPACK 子例程的接口。

gbtrf!(kl, ku, m, AB) -> (AB, ipiv)

计算带状矩阵 AB 的 LU 分解。kl 是包含非零带的第一个次对角线，ku 是包含一个的最后一个超级对角线，m 是矩阵 AB 的第一个维度。返回原位 LU 分解和 ipiv，即所用主元的向量。

gbtrs!(trans, kl, ku, m, AB, ipiv, B)

求解方程 AB * X = B。trans 确定 AB 的方向。它可以是 N（无转置）、T（转置）或 C（共轭转置）。kl 是包含非零带的第一个次对角线，ku 是包含一个的最后一个超级对角线，m 是矩阵 AB 的第一个维度。ipiv 是从 gbtrf! 返回的主元向量。返回向量或矩阵 X，原位覆盖 B。

gebal!(job, A) -> (ilo, ihi, scale)

在计算矩阵 A 的特征系统或 Schur 分解之前平衡矩阵 A。job 可以是 N（A 不会被置换或缩放）、P（A 只会被置换）、S（A 只会被缩放）或 B（A 将同时被置换和缩放）。原位修改 A 并返回 ilo、ihi 和 scale。如果打开了置换，则如果 j > i 且 1 < j < ilo 或 j > ihi，则 A[i,j] = 0。scale 包含有关执行的缩放/置换的信息。

gebak!(job, side, ilo, ihi, scale, V)

将使用 gebal! 平衡的矩阵的特征向量 V 转换为原始矩阵的未缩放/未置换特征向量。原位修改 V。side 可以是 L（左特征向量被转换）或 R（右特征向量被转换）。

gebrd!(A) -> (A, d, e, tauq, taup)

原位将 A 约化为双对角形式 A = QBP'。返回 A，包含双对角矩阵 B；d，包含 B 的对角元素；e，包含 B 的非对角元素；tauq，包含表示 Q 的基本反射器；和 taup，包含表示 P 的基本反射器。

gelqf!(A, tau)

计算 A 的 LQ 分解，A = LQ。tau 包含标量，这些标量参数化分解的基本反射器。tau 的长度必须大于或等于 A 的最小维度。

返回原位修改的 A 和 tau。

gelqf!(A) -> (A, tau)

计算 A 的 LQ 分解，A = LQ。

返回原位修改的 A 和 tau，其中 tau 包含标量，这些标量参数化分解的基本反射器。

geqlf!(A, tau)

计算 A 的 QL 分解，A = QL。tau 包含标量，这些标量参数化分解的基本反射器。tau 的长度必须大于或等于 A 的最小维度。

返回原位修改的 A 和 tau。

geqlf!(A) -> (A, tau)

计算 A 的 QL 分解，A = QL。

返回原位修改的 A 和 tau，其中 tau 包含标量，这些标量参数化分解的基本反射器。

geqrf!(A, tau)

计算 A 的 QR 分解，A = QR。tau 包含标量，这些标量参数化分解的基本反射器。tau 的长度必须大于或等于 A 的最小维度。

返回原位修改的 A 和 tau。

geqrf!(A) -> (A, tau)

计算 A 的 QR 分解，A = QR。

返回原位修改的 A 和 tau，其中 tau 包含标量，这些标量参数化分解的基本反射器。

geqp3!(A, [jpvt, tau]) -> (A, tau, jpvt)

使用 BLAS 级别 3 计算 A 的带主元的 QR 分解，AP = QR。P 是一个主元矩阵，由 jpvt 表示。tau 存储基本反射器。参数 jpvt 和 tau 是可选的，允许传递预分配的数组。如果传递，则如果 A 是一个 (m x n) 矩阵，jpvt 的长度必须大于或等于 n，并且 tau 的长度必须大于或等于 A 的最小维度。

A、jpvt 和 tau 原位修改。

gerqf!(A, tau)

计算 A 的 RQ 分解，A = RQ。tau 包含标量，这些标量参数化分解的基本反射器。tau 的长度必须大于或等于 A 的最小维度。

返回原位修改的 A 和 tau。

gerqf!(A) -> (A, tau)

计算 A 的 RQ 分解，A = RQ。

返回原位修改的 A 和 tau，其中 tau 包含标量，这些标量参数化分解的基本反射器。

geqrt!(A, T)

计算 A 的块 QR 分解，A = QR。T 包含上三角块反射器，这些反射器参数化分解的基本反射器。T 的第一个维度设置块大小，它必须在 1 和 n 之间。T 的第二个维度必须等于 A 的最小维度。

返回原位修改的 A 和 T。

geqrt!(A, nb) -> (A, T)

计算 A 的块 QR 分解，A = QR。nb 设置块大小，它必须在 1 和 n 之间，n 是 A 的第二个维度。

返回原位修改的 A 和 T，其中 T 包含上三角块反射器，这些反射器参数化分解的基本反射器。

geqrt3!(A, T)

递归地计算 A 的块 QR 分解，A = QR。T 包含上三角块反射器，这些反射器参数化分解的基本反射器。T 的第一个维度设置块大小，它必须在 1 和 n 之间。T 的第二个维度必须等于 A 的最小维度。

返回原位修改的 A 和 T。

geqrt3!(A) -> (A, T)

递归地计算 A 的块 QR 分解，A = QR。

返回原位修改的 A 和 T，其中 T 包含上三角块反射器，这些反射器参数化分解的基本反射器。

getrf!(A) -> (A, ipiv, info)

计算 A 的带主元的 LU 分解，A = LU。

返回原位修改的 A、ipiv（主元信息）和一个 info 代码，该代码指示成功（info = 0）、U 中的奇异值（info = i，在这种情况下 U[i,i] 是奇异的）或错误代码（info < 0）。

tzrzf!(A) -> (A, tau)

将上梯形矩阵 A 原位转换为上三角形式。返回 A 和 tau，即变换基本反射器的标量参数。

ormrz!(side, trans, A, tau, C)

将矩阵 C 乘以 tzrzf! 提供的变换中的 Q。根据 side 或 trans，乘法可以是左侧的（side = L, Q*C）或右侧的（side = R, C*Q），并且 Q 可以是未修改的（trans = N）、转置的（trans = T）或共轭转置的（trans = C）。返回矩阵 C，该矩阵原位修改为乘法的结果。

gels!(trans, A, B) -> (F, B, ssr)

使用 QR 或 LQ 分解求解线性方程 A * X = B、transpose(A) * X = B 或 adjoint(A) * X = B。使用解原位修改矩阵/向量 B。A 被覆盖为其 QR 或 LQ 分解。trans 可以是 N（无修改）、T（转置）或 C（共轭转置）。gels! 搜索最小范数/最小二乘解。A 可能是欠定的或超定的。解在 B 中返回。

gesv!(A, B) -> (B, A, ipiv)

求解线性方程 A * X = B，其中 A 是使用 A 的 LU 分解的方阵。A 被覆盖为其 LU 分解，并且 B 被覆盖为解 X。ipiv 包含 A 的 LU 分解的主元信息。

getrs!(trans, A, ipiv, B)

对于方阵 A，求解线性方程 A * X = B、transpose(A) * X = B 或 adjoint(A) * X = B。使用解原位修改矩阵/向量 B。A 是 getrf! 中的 LU 分解，ipiv 是主元信息。trans 可以是 N（无修改）、T（转置）或 C（共轭转置）。

getri!(A, ipiv)

使用 getrf! 找到的 LU 分解计算 A 的逆。ipiv 是输出的主元信息，A 包含 getrf! 的 LU 分解。A 被覆盖为其逆。

gesvx!(fact, trans, A, AF, ipiv, equed, R, C, B) -> (X, equed, R, C, B, rcond, ferr, berr, work)

使用 A 的 LU 分解求解线性方程 A * X = B (trans = N)，transpose(A) * X = B (trans = T) 或 adjoint(A) * X = B (trans = C)。fact 可以是 E，在这种情况下，A 将被平衡并复制到 AF；F，在这种情况下，AF 和 ipiv 来自先前 LU 分解的输入；或者 N，在这种情况下，A 将被复制到 AF 然后进行分解。如果 fact = F，equed 可以是 N，表示 A 未被平衡；R，表示 A 从左侧乘以 Diagonal(R)；C，表示 A 从右侧乘以 Diagonal(C)；或 B，表示 A 从左侧乘以 Diagonal(R)，从右侧乘以 Diagonal(C)。如果 fact = F 且 equed = R 或 B，则 R 的所有元素都必须为正。如果 fact = F 且 equed = C 或 B，则 C 的所有元素都必须为正。

返回解 X；equed，如果 fact 不是 N，则是输出，描述了所执行的平衡；R，行平衡对角线；C，列平衡对角线；B，可能被其平衡形式 Diagonal(R)*B 覆盖（如果 trans = N 且 equed = R,B）或 Diagonal(C)*B（如果 trans = T,C 且 equed = C,B）；rcond，A 在平衡后的倒数条件数；ferr，X 中每个解向量的正向误差边界；berr，X 中每个解向量的后向误差边界；work，倒数枢轴增长因子。

gesvx!(A, B)

gesvx! 的无平衡、无转置简化。

gelsd!(A, B, rcond) -> (B, rnk)

通过找到 A 的 SVD 分解，然后分治问题来计算 A * X = B 的最小范数解。B 被解 X 覆盖。小于 rcond 的奇异值将被视为零。返回 B 中的解和 rnk 中 A 的有效秩。

gelsy!(A, B, rcond) -> (B, rnk)

通过找到 A 的完整 QR 分解，然后分治问题来计算 A * X = B 的最小范数解。B 被解 X 覆盖。小于 rcond 的奇异值将被视为零。返回 B 中的解和 rnk 中 A 的有效秩。

gglse!(A, c, B, d) -> (X,res)

求解方程 A * x = c，其中 x 受等式约束 B * x = d。使用公式 ||c - A*x||^2 = 0 求解。返回 X 和残差平方和。

geev!(jobvl, jobvr, A) -> (W, VL, VR)

找到 A 的特征系统。如果 jobvl = N，则不计算 A 的左特征向量。如果 jobvr = N，则不计算 A 的右特征向量。如果 jobvl = V 或 jobvr = V，则计算相应的特征向量。返回 W 中的特征值，VR 中的右特征向量和 VL 中的左特征向量。

gesdd!(job, A) -> (U, S, VT)

使用分治法找到 A 的奇异值分解，A = U * S * V'。如果 job = A，则计算 U 的所有列和 V' 的所有行。如果 job = N，则不计算 U 的任何列或 V' 的任何行。如果 job = O，则 A 被 (瘦) U 的列和 (瘦) V' 的行覆盖。如果 job = S，则计算 (瘦) U 的列和 (瘦) V' 的行并分别返回。