Linear Algebra

NoPivot

不进行主元选择。没有主元选择的矩阵分解，例如 LU 分解，可能会失败，并且在浮点矩阵面临舍入误差时可能也会在数值上不稳定。这个主元策略主要用于教学目的。

RowNonZero

剩余行中的第一个非零元素被选为主元。

请注意，对于浮点矩阵，结果 LU 算法在数值上是不稳定的——这种策略主要用于与手动计算（通常使用这种策略）进行比较，或用于其他不易受到舍入误差影响的代数类型（例如有理数）。否则，在高斯消元中通常应优先使用默认的 RowMaximum 主元策略。

请注意，矩阵的 element type 必须支持 iszero 方法。

RowMaximum

在剩余行中选择最大绝对值元素作为主元。这是浮点矩阵LU分解的默认策略，有时被称为“部分主元”算法。

请注意，矩阵的 元素类型 必须支持 abs 方法，其结果类型必须支持 < 方法。

ColumnNorm

具有最大范数的列用于后续计算。这用于带主元的QR分解。

请注意，矩阵的 元素类型 必须支持 norm 和 abs 方法，其各自的结果类型必须支持 < 方法。

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

矩阵乘法。

示例

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

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

3个或4个矩阵的链式乘法是根据数组的大小以最有效的顺序进行的。也就是说，比较(A * B) * C（使用3个稠密矩阵）所需的标量乘法次数与A * (B * C)所需的次数，以选择执行其中的一个。

如果最后一个因子是一个向量，或者第一个是一个转置向量，那么优先处理这些是高效的。特别是x' * B * y意味着对于普通的列主序B::Matrix，它表示(x' * B) * y。与dot(x, B, y)不同，这会分配一个中间数组。

如果第一个或最后一个因子是一个数字，这将与矩阵乘法融合，使用5个参数的mul!。

另见muladd，dot。

\(A, B)

使用多算法进行矩阵除法。对于输入矩阵 A 和 B，结果 X 满足 A*X == B 当 A 为方阵时。所使用的求解器取决于 A 的结构。如果 A 是上三角或下三角（或对角）矩阵，则不需要对 A 进行因式分解，系统通过前向或后向替代法求解。对于非三角形的方阵，使用 LU 因式分解。

对于矩形的 A，结果是通过对 A 进行带主元的 QR 因式分解和基于 R 因子的 A 的秩估计计算的最小范数最小二乘解。

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

另见：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

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

RankDeficientException

当输入矩阵是 秩缺陷 时抛出异常。一些线性代数函数，例如 Cholesky 分解，仅适用于非秩缺陷的矩阵。info 字段指示矩阵的计算秩。

LAPACK异常

在直接调用LAPACK函数或调用其他内部使用LAPACK函数但缺乏专门错误处理的函数时抛出的通用LAPACK异常。info字段包含有关基础错误的附加信息，并取决于被调用的LAPACK函数。

dot(x, y)
x ⋅ y

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

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

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

x ⋅ y（其中 ⋅ 可以通过在 REPL 中输入 \cdot 后按 Tab 键来输入）是 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)

计算两个三维向量的叉积。

示例

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，那么 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 将检查 A 是否已经被分解
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

对角线(A::AbstractMatrix)

从 A 的主对角线构造一个矩阵。输入矩阵 A 可以是矩形的，但输出将是方形的。

示例

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

julia> D = Diagonal(A)
2×2 Diagonal{Int64, Vector{Int64}}:
 1  ⋅
 ⋅  4

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

julia> Diagonal(A)
2×2 Diagonal{Int64, Vector{Int64}}:
 1  ⋅
 ⋅  5

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 的长度少一个。

示例

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 在第一个超对角线上
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 ⋅  2  8  ⋅
 ⋅  ⋅  3  9
 ⋅  ⋅  ⋅  4

julia> Bl = Bidiagonal(dv, ev, :L) # ev 在第一个下对角线上
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) # 包含 A 的主对角线和第一个超对角线
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  1  ⋅  ⋅
 ⋅  2  2  ⋅
 ⋅  ⋅  3  3
 ⋅  ⋅  ⋅  4

julia> Bidiagonal(A, :L) # 包含 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 的长度少一。

示例

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::AbstractMatrix, uplo::Symbol=:U)

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

Symmetric 视图主要用于实对称矩阵，对于这些矩阵，专门的算法（例如特征问题）可以为 Symmetric 类型启用。更一般地，参见 Hermitian(A) 用于厄米矩阵 A == A'，这在实矩阵中实际上等同于 Symmetric，但对于复矩阵也很有用。（而复 Symmetric 矩阵受到支持，但几乎没有任何专门的算法。）

要计算实矩阵的对称部分，或更一般地，实或复矩阵 A 的厄米部分 (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::AbstractMatrix, uplo::Symbol=:U)

构造一个 Hermitian 视图，表示矩阵 A 的上三角（如果 uplo = :U）或下三角（如果 uplo = :L）。

要计算 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 矩阵{复数{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

矩阵分解类型的 LU 分解一个方阵 A。这是 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); # 通过迭代解构

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 向量默认为 Julia SparseArrays 包的 UMFPACK 默认配置（注意：这已从 UMFPACK 默认值修改，以禁用迭代精炼），但可以通过传递长度为 UMFPACK_CONTROL 的向量进行更改，具体配置请参见 UMFPACK 手册。例如，要重新启用迭代精炼：

umfpack_control = SparseArrays.UMFPACK.get_umfpack_control(Float64, Int64) # 读取 Float64 稀疏矩阵的 Julia 默认配置
SparseArrays.UMFPACK.show_umf_ctrl(umfpack_control) # 可选 - 显示值
umfpack_control[SparseArrays.UMFPACK.JL_UMFPACK_IRSTEP] = 2.0 # 重新启用迭代精炼（2 是 UMFPACK 默认的最大迭代精炼步骤）

Alu = lu(A; control = umfpack_control)
x = Alu \ b   # 解 Ax = b，包括 UMFPACK 迭代精炼

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

F 和 A 之间的关系为

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

F 进一步支持以下函数：

• \
• det

另见 lu!

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

计算 A 的 LU 分解。

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

默认情况下，当 check = true 时，如果分解产生有效因子，但上三角因子 U 的秩不足，也会抛出错误。可以通过传递 allowsingular = true 来更改此行为。

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

一般来说，LU 分解涉及对矩阵行的排列（对应于下面描述的 F.p 输出），称为“主元选择”（因为它对应于选择哪个行包含“主元”，即 F.U 的对角元素）。可以通过可选的 pivot 参数选择以下主元选择策略：

• RowMaximum()（默认）：标准主元选择策略；主元对应于剩余待分解行中绝对值最大的元素。此主元选择策略要求元素类型也支持 abs 和 <。 （这通常是浮点矩阵的唯一数值稳定选项。）
• RowNonZero()：主元对应于剩余待分解行中第一个非零元素。 （这对应于手动计算中的典型选择，对于支持 iszero 但不支持 abs 或 < 的更一般的代数数类型也很有用。）
• NoPivot()：关闭主元选择（如果在主元位置遇到零条目，将失败，即使 allowsingular = true）。

可以通过 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); # 通过迭代解构

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

julia> lu([1 2; 1 2], allowsingular = true)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0  0.0
 1.0  1.0
U factor (rank-deficient):
2×2 Matrix{Float64}:
 1.0  2.0
 0.0  0.0

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, allowsingular = false) -> 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 的分解获得三角形 Cholesky 因子，方法是使用 F.L 和 F.U，其中 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; # 通过迭代解构

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

CholeskyPivoted

矩阵分解类型，适用于稠密对称/厄米正半定矩阵 A 的带主元的 Cholesky 分解。这是 cholesky(_, ::RowMaximum) 的返回类型，对应的矩阵分解函数。

可以通过 F.L 和 F.U 从分解 F::CholeskyPivoted 中获得三角形 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 因子，秩为 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
置换：
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; # 通过迭代解构

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

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

计算稠密对称正定矩阵 A 的 Cholesky 分解，并返回一个 Cholesky 分解。矩阵 A 可以是一个 Symmetric 或 Hermitian AbstractMatrix，或者是一个 完全 对称或 Hermitian 的 AbstractMatrix。

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

对于 Cholesky 对象，提供以下函数：size、\、inv、det、logdet 和 isposdef。

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

当 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，或者是 完全 对称或 Hermitian 的 AbstractMatrix。

可以通过 F.L 和 F.U 从分解 F 中获得三角 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 决定了确定秩的容差。对于负值，容差为机器精度。

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

当 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 求解方程组，但方法 diag、det 和 logdet 也为 F 定义。您还可以使用 F.L 提取单个因子。然而，由于默认情况下启用了主元，因子分解在内部表示为 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 的 LDLt 或 LLt 分解 F 的 A + C*C' 的 LDLt 分解。

返回的因子始终是 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 的 LDLt 或 LLt 分解 F，获取 A + C*C' 的 LDLt 分解。

返回的因子始终是 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

LDLt 分解的矩阵分解类型，适用于实数 SymTridiagonal 矩阵 S，使得 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$ 的元素，即 R = triu(F.factors) 对于一个 QR 对象 F。
  • 次对角部分包含以压缩格式存储的反射器 $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$ 的上三角矩阵 $T_j$ ($j = 1, ..., b-1$) 和一个上梯形的 $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$ 的元素，即 R = triu(F.factors) 对于一个 QR 对象 F。
  • 次对角部分包含反射器 $v_i$，以打包格式存储，使得 V = I + tril(F.factors, -1)。

• T 是一个 $n_b$×$\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$ 的元素，即 R = triu(F.factors) 对于一个 QR 对象 F。
  • 次对角部分包含反射器 $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 的正交矩阵。

QR 分解的块大小可以通过关键字参数 blocksize :: Integer 指定，当 pivot == NoPivot() 且 A isa StridedMatrix{<:BlasFloat} 时。如果 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 因子：3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R 因子：
2×2 Matrix{Float64}:
 -5.0  10.0
  0.0  -1.0

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

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

qr! 与 qr 相同，当 A 是 AbstractMatrix 的子类型时，但通过覆盖输入 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 因子: 2×2 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R 因子:
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 <: 因式分解

矩阵 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 因子:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q 因子: 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; # 通过迭代解构

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 分解，它在计算欠定方程组的最小范数解 lq(A) \ b 时非常有用（A 的列数大于行数，但具有满行秩）。

示例

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 因子:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q 因子: 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; # 通过迭代解构

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

lq!(A) -> LQ

计算 A 的 LQ 分解，使用输入矩阵作为工作区。另见 lq。

BunchKaufman <: Factorization

矩阵分解类型的 Bunch-Kaufman 分解用于对称或厄米矩阵 A，表示为 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 = Float64.([1 2; 2 3])
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  3.0

julia> S = bunchkaufman(A) # A 在内部被 Symmetric(A) 包装
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D 因子:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U 因子:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
置换:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # 通过迭代解构

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

julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D 因子:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L 因子:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
置换:
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 = Float64.([1 2; 2 3])
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  3.0

julia> S = bunchkaufman(A) # A 在内部被 Symmetric(A) 包装
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D 因子:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U 因子:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
置换:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # 通过迭代解构

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 因子:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L 因子:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
置换:
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 的列获取特征向量。（第 k 个特征向量可以通过切片 F.vectors[:, 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; # 通过迭代解构

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

GeneralizedEigen <: Factorization

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

如果 F::GeneralizedEigen 是分解对象，则可以通过 F.values 获取特征值，通过矩阵 F.vectors 的列获取特征向量。（第 k 个特征向量可以通过切片 F.vectors[:, 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 来计算特征值的子集，例如第 2 到第 8 个特征值。

示例

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 是要搜索的特征值 索引 的范围 - 例如，从第 2 个到第 8 个特征值。

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` 不能有复数特征值。
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` 不能有复特征值。
Stacktrace:
[...]

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

返回一个矩阵 M，其列是 A 的特征向量。（第 k 个特征向量可以通过切片 M[:, 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 的特征向量。(kth 特征向量可以通过切片 M[:, 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) -> 矩阵

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

示例

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

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

julia> eigvecs(A, B)
2×2 矩阵{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 是一个特征向量，λ 是一个特征值。(kth 特征向量可以通过切片 F.vectors[:, k] 获得。)

迭代分解会产生组件 F.values 和 F.vectors。

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

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

默认情况下，特征值和特征向量按 (real(λ),imag(λ)) 进行字典序排序。可以将不同的比较函数 by(λ) 传递给 sortby，或者可以传递 sortby=nothing 以保持特征值的任意顺序。一些特殊的矩阵类型（例如 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; # 通过迭代解构

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 是特征向量，λ 是特征值。(kth 广义特征向量可以通过切片 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; # 通过迭代解构

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 <: 因式分解

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。

请注意， shifted factorization 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; # 通过迭代解构

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

hessenberg!(A) -> Hessenberg

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

Schur <: Factorization

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

如果 F::Schur 是分解对象，则 (准) 三角形 Schur 因子可以通过 F.Schur 或 F.T 获得，正交/单位 Schur 向量可以通过 F.vectors 或 F.Z 获得，使得 A = F.vectors * F.Schur * F.vectors'。矩阵 A 的特征值可以通过 F.values 获得。

迭代分解会产生组件 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

广义 Schur 分解的矩阵分解类型，适用于两个矩阵 A 和 B。这是 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'。A 和 B 的广义特征值可以通过 F.α./F.β 获取。

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

schur(A) -> F::Schur

计算矩阵 A 的 Schur 分解。可以通过 F.Schur 或 F.T 从 Schur 对象 F 中获得（准）三角 Schur 因子，正交/单位 Schur 向量可以通过 F.vectors 或 F.Z 获得，从而满足 A = F.vectors * F.Schur * F.vectors'。可以通过 F.values 获得 A 的特征值。

对于实数矩阵 A，Schur 分解是“准三角形”的，这意味着它是上三角的，除了对于任何共轭复特征值的 2×2 对角块；这使得即使存在复特征值，分解也可以完全是实数的。要从实数准三角分解中获得（复数）纯上三角的 Schur 分解，可以使用 Schur{Complex}(schur(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 因子:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z 因子:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
特征值:
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; # 通过迭代解构

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

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

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

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

schur!(A) -> F::Schur

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

示例

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

julia> F = schur!(A)
Schur{Float64, 矩阵{Float64}, 向量{Float64}}
T 因子:
2×2 矩阵{Float64}:
 3.0   9.0
 0.0  -2.0
Z 因子:
2×2 矩阵{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
特征值:
2 元素 向量{Float64}:
  3.0
 -2.0

julia> A
2×2 矩阵{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，并返回一个广义 Schur 对象 F。所选的特征值出现在 F.S 和 F.T 的主对角线上，左侧和右侧的正交/单位 Schur 向量也被重新排序，以便仍然满足 (A, B) = F.Q*(F.S, F.T)*F.Z'，并且仍然可以通过 F.α./F.β 获取 A 和 B 的广义特征值。

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; # 通过迭代解构

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

GeneralizedSVD <: Factorization

广义奇异值分解（SVD）两矩阵 A 和 B 的矩阵分解类型，使得 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 对象。

U、S、V 和 Vt 可以通过因式分解 F 获取，使用 F.U、F.S、F.V 和 F.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); # 存储因式分解对象

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

julia> U, S, V = F; # 通过迭代解构

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

julia> Uonly, = svd(A); # 仅存储 U

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-by-M 的正交矩阵，
• V 是一个 P-by-P 的正交矩阵，
• Q 是一个 N-by-N 的正交矩阵，
• D1 是一个 M-by-(K+L) 的对角矩阵，前 K 个元素为 1，
• D2 是一个 P-by-(K+L) 的矩阵，其右上角的 L-by-L 块是对角的，
• R0 是一个 (K+L)-by-N 的矩阵，其最右侧的 (K+L)-by-(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) -> 广义奇异值分解

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::AbstractMatrix, k::Integer = 0, indstyle::IndexStyle = IndexLinear())
diagind(M::AbstractMatrix, indstyle::IndexStyle = IndexLinear())

一个 AbstractRange，给出矩阵 M 的第 k 条对角线的索引。可以选择性地指定索引样式，以确定返回的范围类型。如果 indstyle isa IndexLinear（默认），则返回 AbstractRange{Integer}。另一方面，如果 indstyle isa IndexCartesian，则返回 AbstractRange{CartesianIndex{2}}。

如果未提供 k，则假定为 0（对应主对角线）。

另请参见: 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

julia> diagind(A, IndexCartesian())
StepRangeLen(CartesianIndex(1, 1), CartesianIndex(1, 1), 3)

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 |$ 是 norm 的 a_i，$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,<:AbstractVector}, q::Real=2)
opnorm(A::Transpose{<:Any,<:AbstractVector}, 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（默认）。

这个量在文献中也被称为 Bauer 条件数、相对条件数或逐分量相对条件数。

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) # 在 Julia 2.0 中将被弃用

计算摩尔-彭若斯伪逆。

对于具有浮点元素的矩阵 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) # 在 Julia 2.0 中将被弃用

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

默认情况下，相对容忍度 `rtol` 是 `n*ϵ`，其中 `n` 是 `M` 最小维度的大小，`ϵ` 是 `M` 的元素类型的 [`eps`](@ref)。

# 示例

jldoctest 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 或实对称矩阵时）。

另见 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$ 且对于所有特征值 $\lambda$，满足 $-\pi < Im(\lambda) < \pi$。如果 A 有非正特征值，则在可能的情况下返回非主矩阵函数。

如果 A 是对称或厄米的，则使用其特征分解（eigen），如果 A 是三角形的，则采用改进的逆缩放和平方方法（见 ^[AH12] 和 ^[AHR13]）。如果 A 是实数且没有负特征值，则计算实施尔形式。否则，计算复施尔形式。然后在上三角（准）三角因子上使用 ^[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 在负实轴上有一个分支切割。

前缀运算符 √ 等同于 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> sqrt(-81 - 0.0im)  # -0.0im 在分支切割下方
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

cbrt(A::AbstractMatrix{<:Real})

计算实值矩阵 A 的实值立方根。如果 T = cbrt(A)，则我们有 T*T*T ≈ A，请参见下面给出的示例。

如果 A 是对称的，即类型为 HermOrSym{<:Real}，则使用 (eigen) 来找到立方根。否则，利用专门的 p 次根算法 ^[S03]，该算法利用实值 Schur 分解 (schur) 来计算立方根。

示例

julia> A = [0.927524 -0.15857; -1.3677 -1.01172]
2×2 Matrix{Float64}:
  0.927524  -0.15857
 -1.3677    -1.01172

julia> T = cbrt(A)
2×2 Matrix{Float64}:
  0.910077  -0.151019
 -1.30257   -0.936818

julia> T*T*T ≈ A
true

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)

计算Sylvester方程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

issuccess(F::LU; allowsingular = false)

测试矩阵的 LU 分解是否成功。默认情况下，产生有效但秩不足的 U 因子的分解被视为失败。通过传递 allowsingular = true 可以更改此行为。

示例

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

julia> issuccess(F)
false

julia> issuccess(F, allowsingular = true)
true

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> c = [1 1 0; 1 1 1; 1 1 1]
3×3 Matrix{Int64}:
 1  1  0
 1  1  1
 1  1  1

julia> istril(c)
false

julia> istril(c, 1)
true

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> c = [1 1 1; 1 1 1; 0 1 1]
3×3 Matrix{Int64}:
 1  1  1
 1  1  1
 0  1  1

julia> istriu(c)
false

julia> istriu(c, -1)
true

isdiag(A) -> Bool

测试一个矩阵是否是对角矩阵，意思是除非 i == j，否则 iszero(A[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 # 转置的转置解包父对象
true

julia> Transpose(B) # 然而，构造函数始终包装其参数
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
 3  2
 0  0

julia> B[1,2] = 4; # 修改 B 将自动修改 A

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) # 返回一个行向量
1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> transpose(v) * v # 计算点积
14

对于矩阵的矩阵，单个块是递归操作的：

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

julia> D = reshape([C, 2C, 3C, 4C], 2, 2) # 构造一个块矩阵
2×2 Matrix{Matrix{Int64}}:
 [1 3; 2 4]  [3 9; 6 12]
 [2 6; 4 8]  [4 12; 8 16]

julia> transpose(D) # 块被递归转置
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，但对于具有实数 eltype 的 Factorization，则返回一个 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 中，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

转置

用于底层线性代数对象的转置视图的惰性包装类型，通常是 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 矩阵{复数{Int64}}:
 3+2im  9+2im
 0+0im  0+0im

julia> B = A' # 等同于 adjoint(A)
2×2 adjoint(::矩阵{复数{Int64}}) 具有元素类型 复数{Int64}:
 3-2im  0+0im
 9-2im  0+0im

julia> B isa Adjoint
true

julia> adjoint(B) === A # 伴随的伴随解开父级
true

julia> Adjoint(B) # 然而，构造函数总是包装其参数
2×2 adjoint(adjoint(::矩阵{复数{Int64}})) 具有元素类型 复数{Int64}:
 3+2im  9+2im
 0+0im  0+0im

julia> B[1,2] = 4 + 5im; # 修改 B 将自动修改 A

julia> A
2×2 矩阵{复数{Int64}}:
 3+2im  9+2im
 4-5im  0+0im

对于实矩阵，adjoint 操作等同于 transpose。

julia> A = reshape([x for x in 1:4], 2, 2)
2×2 矩阵{Int64}:
 1  3
 2  4

julia> A'
2×2 adjoint(::矩阵{Int64}) 具有元素类型 Int64:
 1  2
 3  4

julia> adjoint(A) == transpose(A)
true

AbstractVector 的伴随是行向量：

julia> x = [3, 4im]
2-element 向量{复数{Int64}}:
 3 + 0im
 0 + 4im

julia> x'
1×2 adjoint(::向量{复数{Int64}}) 具有元素类型 复数{Int64}:
 3+0im  0-4im

julia> x'x # 计算点积，等同于 x' * x
25 + 0im

对于矩阵的矩阵，单个块是递归操作的：

julia> A = reshape([x + im*x for x in 1:4], 2, 2)
2×2 矩阵{复数{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> C = reshape([A, 2A, 3A, 4A], 2, 2)
2×2 矩阵{矩阵{复数{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(::矩阵{矩阵{复数{Int64}}}) 具有元素类型 Adjoint{复数{Int64}, 矩阵{复数{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 中，dest 的大小应对应于 (size(src,2),size(src,1))。不支持就地转置，如果 src 和 dest 有重叠的内存区域，将会发生意外结果。

示例

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 矩阵{复数{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> B = zeros(复数{Int64}, 2, 2)
2×2 矩阵{复数{Int64}}:
 0+0im  0+0im
 0+0im  0+0im

julia> adjoint!(B, A);

julia> B
2×2 矩阵{复数{Int64}}:
 3-2im  8-7im
 9-2im  4-6im

julia> A
2×2 矩阵{复数{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

伴随

用于底层线性代数对象的伴随视图的惰性包装类型，通常是 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 线程的数量可以通过 BLAS.set_num_threads(n) 设置。

如果提供了关键字参数 eltype，peakflops 将构造具有类型 eltype 的元素的矩阵以计算峰值浮点运算速率。

默认情况下，peakflops 将使用 3 次试验中的最佳计时。如果提供了关键字参数 ntrials，peakflops 将使用指定的试验次数来选择最佳计时。

如果关键字参数 parallel 设置为 true，peakflops 将在所有工作处理器上并行运行。将返回整个并行计算机的浮点运算速率。在并行运行时，仅使用 1 个 BLAS 线程。参数 n 仍然指的是在每个处理器上解决的问题的大小。

hermitianpart(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

返回方阵 A 的厄米部分，定义为 (A + A') / 2，作为一个 Hermitian 矩阵。对于实矩阵 A，这也被称为 A 的对称部分；有时也称为“算子实部”。可选参数 uplo 控制 Hermitian 视图的相应参数。对于实矩阵，后者等同于 Symmetric 视图。

另请参见 hermitianpart! 以获取相应的就地操作。

hermitianpart!(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

就地覆盖方阵 A 的厄米部分 (A + A') / 2，并返回 Hermitian(A, uplo)。对于实矩阵 A，这也被称为 A 的对称部分。

另请参见 hermitianpart 以获取相应的非就地操作。

copy_adjoint!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

高效地将矩阵 A 的元素复制到 B，并进行伴随操作，如下所示：

B[ir_dest, jr_dest] = adjoint(A)[jr_src, ir_src]

元素 B[ir_dest, jr_dest] 会被覆盖。此外，索引范围参数必须满足 length(ir_dest) == length(jr_src) 和 length(jr_dest) == length(ir_src)。

copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

高效地将矩阵 A 的元素复制到 B，并进行转置，如下所示：

B[ir_dest, jr_dest] = transpose(A)[jr_src, ir_src]

元素 B[ir_dest, jr_dest] 会被覆盖。此外，索引范围参数必须满足 length(ir_dest) == length(jr_src) 和 length(jr_dest) == length(ir_src)。

copy_transpose!(B::AbstractMatrix, ir_dest::AbstractUnitRange, jr_dest::AbstractUnitRange,
                tM::AbstractChar,
                M::AbstractVecOrMat, ir_src::AbstractUnitRange, jr_src::AbstractUnitRange) -> B

高效地将矩阵 M 的元素复制到 B，条件是字符参数 tM 如下：

元素 B[ir_dest, jr_dest] 会被覆盖。此外，索引范围参数必须满足 length(ir_dest) == length(jr_src) 和 length(jr_dest) == length(ir_src)。

另见 copyto! 和 copy_adjoint!。

mul!(Y, A, B) -> Y

计算矩阵-矩阵或矩阵-向量乘积 $A B$ 并将结果存储在 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);

julia> mul!(Y, A, B) === Y
true

julia> Y
2×2 Matrix{Float64}:
 3.0  3.0
 7.0  7.0

julia> Y == A * B
true

实现

对于自定义矩阵和向量类型，建议实现 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> α, β = 100.0, 10.0;

julia> mul!(C, A, B, α, β) === C
true

julia> C
2×2 Matrix{Float64}:
 310.0  320.0
 730.0  740.0

julia> C_original = [1.0 2.0; 3.0 4.0]; # C 的原始值的副本

julia> C == A * B * α + C_original * β
true

lmul!(a::Number, B::AbstractArray)

通过标量 a 缩放数组 B，并就地覆盖 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)

通过标量 b 缩放数组 A，并就地覆盖 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! 进行就地操作），而在性能关键的情况下，通常需要对 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 ≈ A\X
true

ldiv!(A, B)

计算 A \ B，并在原地覆盖 B 以存储结果。

参数 A 不应 是一个矩阵。相反，它应该是一个分解对象（例如，由 factorize 或 cholesky 生成）。这样做的原因是，分解本身既昂贵又通常会分配内存（尽管也可以通过例如 lu! 在原地完成），而在性能关键的情况下，通常需要对 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 ≈ A\Y
true

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

ldiv!(A::Tridiagonal, B::AbstractVecOrMat) -> B

通过带部分主元的高斯消元法就地计算 A \ B，并将结果存储在 B 中，返回结果。在此过程中，A 的对角线也会被覆盖。

rdiv!(A, B)

计算 A / B 并在原地覆盖 A 以存储结果。

参数 B 不应 是一个矩阵。相反，它应该是一个分解对象（例如，由 factorize 或 cholesky 生成）。这样做的原因是，分解本身既昂贵又通常会分配内存（尽管也可以通过例如 lu! 在原地完成），而在性能关键的情况下，通常也需要对 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

BLAS子例程的接口。

set_num_threads(n::Integer)
set_num_threads(::Nothing)

将 BLAS 库应使用的线程数设置为 n::Integer。

也接受 nothing，在这种情况下，julia 会尝试猜测默认的线程数。传递 nothing 不被推荐，主要是出于历史原因。

get_num_threads()

获取BLAS库正在使用的线程数量。

rot!(n, X, incx, Y, incy, c, s)

用 c*X + s*Y 覆盖 X，并用 -conj(s)*X + c*Y 覆盖 Y，针对数组 X 的前 n 个元素，步长为 incx，以及数组 Y 的前 n 个元素，步长为 incy。返回 X 和 Y。

scal!(n, a, X, incx)
scal!(a, X)

用 a*X 覆盖数组 X 的前 n 个元素，步长为 incx。返回 X。

如果未提供 n 和 incx，则使用 length(X) 和 stride(X,1)。

scal(n, a, X, incx)
scal(a, X)

返回 X 的前 n 个元素乘以 a，步长为 incx。

如果未提供 n 和 incx，则使用 length(X) 和 stride(X,1)。

blascopy!(n, X, incx, Y, incy)

将数组 X 中的 n 个元素（步长为 incx）复制到数组 Y 中（步长为 incy）。返回 Y。

dot(n, X, incx, Y, incy)

两个向量的点积，由数组 X 中 n 个元素（步幅为 incx）和数组 Y 中 n 个元素（步幅为 incy）组成。

示例

julia> BLAS.dot(10, fill(1.0, 10), 1, fill(1.0, 20), 2)
10.0

dotu(n, X, incx, Y, incy)

用于两个复数向量的点积函数，包含 n 个元素的数组 X，步长为 incx，以及 n 个元素的数组 Y，步长为 incy。

示例

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)

用于两个复数向量的点积函数，由数组 X 的 n 个元素（步长为 incx）和数组 U 的 n 个元素（步长为 incy）组成，对第一个向量进行共轭。

示例

julia> BLAS.dotc(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
10.0 - 10.0im

nrm2(n, X, incx)

由数组 X 中 n 个元素组成的向量的 2-范数，步长为 incx。

示例

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)

数组 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)

找到 dx 中绝对值最大的元素的索引。n 是 dx 的长度，incx 是步幅。如果未提供 n 和 incx，则假定默认值为 n=length(dx) 和 incx=stride1(dx)。

gemv!(tA, alpha, A, x, beta, y)

更新向量 y 为 alpha*A*x + beta*y 或 alpha*A'x + beta*y，具体取决于 tA。alpha 和 beta 是标量。返回更新后的 y。

gemv(tA, alpha, A, x)

返回 alpha*A*x 或 alpha*A'x，具体取决于 tA。alpha 是一个标量。

gemv(tA, A, x)

根据 tA 返回 A*x 或 A'x。

gbmv!(trans, m, kl, ku, alpha, A, x, beta, y)

根据 trans 更新向量 y 为 alpha*A*x + beta*y 或 alpha*A'*x + beta*y。矩阵 A 是一个维度为 m x size(A,2) 的一般带状矩阵，具有 kl 个下对角线和 ku 个上对角线。alpha 和 beta 是标量。返回更新后的 y。

gbmv(trans, m, kl, ku, alpha, A, x)

根据 trans 返回 alpha*A*x 或 alpha*A'*x。矩阵 A 是一个维度为 m 乘 size(A,2) 的一般带状矩阵，具有 kl 个下对角线和 ku 个上对角线，alpha 是一个标量。

hemv!(ul, alpha, A, x, beta, y)

更新向量 y 为 alpha*A*x + beta*y。假设 A 是厄米的。仅使用 A 的 ul 三角部分。alpha 和 beta 是标量。返回更新后的 y。

hemv(ul, alpha, A, x)

返回 alpha*A*x。假设 A 是厄米的。仅使用 A 的 ul 三角部分。alpha 是一个标量。

hemv(ul, A, x)

返回 A*x。假设 A 是厄米的。仅使用 A 的 ul 三角部分。

hpmv!(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 必须都是 ComplexF32 或 ComplexF64 类型。

返回更新后的 y。

symv!(ul, alpha, A, x, beta, y)

更新向量 y 为 alpha*A*x + beta*y。假设 A 是对称的。仅使用 A 的 ul 三角部分。alpha 和 beta 是标量。返回更新后的 y。

symv(ul, alpha, A, x)

返回 alpha*A*x。假设 A 是对称的。仅使用 A 的 ul 三角部分。alpha 是一个标量。

symv(ul, A, x)

返回 A*x。假设 A 是对称的。仅使用 A 的 ul 三角部分。

sbmv!(uplo, k, alpha, A, x, beta, y)

更新向量 y 为 alpha*A*x + beta*y，其中 A 是一个对称带状矩阵，阶数为 size(A,2)，具有 k 个超对角线，存储在参数 A 中。A 的存储布局在参考 BLAS 模块中描述，级别-2 BLAS 可在 https://www.netlib.org/lapack/explore-html/ 找到。仅使用 uplo 三角形的 A。

返回更新后的 y。

sbmv(uplo, k, alpha, A, x)

返回 alpha*A*x，其中 A 是一个阶数为 size(A,2) 的对称带状矩阵，具有在参数 A 中存储的 k 个超对角线。仅使用 A 的 uplo 三角部分。

sbmv(uplo, k, A, x)

返回 A*x，其中 A 是一个阶数为 size(A,2) 的对称带状矩阵，具有在参数 A 中存储的 k 个超对角线。仅使用 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 类型。

返回更新后的 y。

trmv!(ul, tA, dA, A, b)

返回 op(A)*b，其中 op 由 tA 决定。仅使用 A 的 ul 三角部分。dA 决定是否读取对角线值或假设它们都是一。乘法在 b 上就地进行。

trmv(ul, tA, dA, A, b)

返回 op(A)*b，其中 op 由 tA 确定。仅使用 A 的 ul 三角部分。dA 确定是否读取对角线值或假定它们都是一。

trsv!(ul, tA, dA, A, b)

用 A*x = b 的解覆盖 b，或根据 tA 和 ul 确定的其他两个变体之一。 dA 确定是否读取对角线值或假定它们都是一。 返回更新后的 b。

trsv(ul, tA, dA, A, b)

返回 A*x = b 的解，或由 tA 和 ul 确定的其他两个变体。dA 确定对角线值是被读取还是假定为全为一。

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。

gemmt!(uplo, tA, tB, alpha, A, B, beta, C)

根据 uplo 指定的下三角或上三角部分更新 C，计算为 alpha*A*B + beta*C 或根据 tA 和 tB 的其他变体。返回更新后的 C。

gemmt(uplo, tA, tB, alpha, A, B)

返回由 uplo 指定的 A*B 的下三角或上三角部分，或根据 tA 和 tB 的其他三个变体。

gemmt(uplo, tA, tB, A, B)

返回由 uplo 指定的 A*B 的下三角或上三角部分，或根据 tA 和 tB 的其他三个变体。

gemm!(tA, tB, alpha, A, B, beta, C)

更新 C 为 alpha*A*B + beta*C 或根据 tA 和 tB 的其他三种变体。返回更新后的 C。

gemm(tA, tB, alpha, A, B)

返回 alpha*A*B 或根据 tA 和 tB 的其他三种变体。