線性代數

*(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，結果是基於 R 因數對 A 進行樞紐 QR 分解和秩估計所計算出的最小範數最小平方解。

當 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 欄位指出（其中一個）零樞紐的位置。

dot(x, y)
x ⋅ y

計算兩個向量的點積。對於複數向量，第一個向量會共軛。

dot 也適用於任意可迭代物件，包括任何維度的陣列，只要 dot 在元素上定義即可。

dot 在語義上等於 sum(dot(vx,vy) for (vx,vy) in zip(x, y))，加上參數長度必須相等的限制。

x ⋅ y（其中 ⋅ 可以透過在 REPL 中按 Tab 補齊 \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 的方便分解。如果 A 作為一般矩陣傳遞，factorize 會檢查 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 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 的長度少一。

範例

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

範例

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 檢視。

對稱檢視主要用於實對稱矩陣，其中已啟用專門演算法（例如，用於特徵值問題）以取得 對稱類型。更一般地，另請參閱 Hermitian(A) 以取得 Hermitian 矩陣 A == A'，這對於實矩陣實際上等於 對稱，但對於複雜矩陣也很有用。（而複雜的 對稱矩陣受支援，但幾乎沒有專門演算法。）

若要計算實矩陣的對稱部分，或更一般地計算實或複雜矩陣 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 的回傳型別，對應的矩陣分解函數。

分解 F::LU 的個別組成部分可透過 getproperty 存取

迭代分解會產生組成部分 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 的預設值。如果排列不是以 0 為基礎，則會建立一個以 0 為基礎的副本。

control 向量預設為套件的 UMFPACK 預設組態，但可以透過傳遞長度為 UMFPACK_CONTROL 的向量來變更。請參閱 UMFPACK 手冊以取得可能的組態。對應的變數命名為 JL_UMFPACK_，因為 Julia 使用以 1 為基礎的索引。

分解 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()：關閉主元選擇（如果遇到零輸入，可能會失敗）。

分解 F 的個別組成部分可透過 getproperty 存取

迭代分解會產生組成部分 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 分解，重複使用儲存在 F 中的既有 LU 分解的符號分解。除非將 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 的回傳類型，也就是對應的矩陣分解函式。

三角形的 Cholesky 因子可以透過分解 F::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; # destructuring via iteration

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

CholeskyPivoted

稠密對稱/厄米特正半定矩陣 A 的樞紐 Cholesky 分解的矩陣分解類型。這是 cholesky(_, ::RowMaximum) 的回傳類型，也就是對應的矩陣分解函式。

三角形的 Cholesky 因子可以透過分解 F::CholeskyPivoted 以及 F.L 和 F.U 取得，而排列則可以透過 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，或是一個完全對稱或 Hermitian 的 AbstractMatrix。

三角形 Cholesky 因子可以透過分解 F 經由 F.L 和 F.U 取得，其中 A ≈ F.U' * F.U ≈ F.L * F.L'。

Cholesky 物件可以使用下列函式： size、\、inv、det、logdet 和 isposdef。

如果您有一個矩陣 A，由於其建構中的捨入誤差而略微非 Hermitian，請在傳遞給 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。

三角形 Cholesky 因子可以透過分解 F 經由 F.L 和 F.U 取得，而排列則可以透過 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，由於其建構中的捨入誤差而略微非 Hermitian，請在傳遞給 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 沒有類型標籤，它仍然必須是對稱或 Hermitian。如果未提供 perm，則使用減少填充的排列。F = cholesky(A) 最常使用於使用 F\b 解決方程式組，但方法 diag、det 和 logdet 也定義為 F。您也可以使用 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 沒有類型標籤，它仍然必須是對稱或 Hermitian。

另請參閱 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

實對稱三對角矩陣 S 的 LDLt 因數分解的矩陣因數分解類型，使得 S = L*Diagonal(d)*L'，其中 L 是 UnitLowerTriangular 矩陣，而 d 是向量。LDLt 因數分解 F = ldlt(S) 的主要用途是使用 F\b 來求解線性方程組 Sx = 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) 的主要用途是使用 F\b 來求解線性方程組 Sx = 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 沒有類型標籤，它仍然必須是對稱或 Hermitian。使用減少填充的排列。F = ldlt(A) 最常使用於使用 F\b 解決方程式組 A*x = 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 沒有類型標籤，它仍然必須是對稱或 Hermitian。

另請參閱 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)，其中 F 是 QR 物件。

  • 次對角線部分包含以封裝格式儲存的反射器 $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$ 儲存在精簡 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)，其中 F 是 QR 物件。

  • 次對角線部分包含以封裝格式儲存的反射器 $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$ 的元素，也就是 R = triu(F.factors)，其中 F 是 QR 物件。

  • 次對角線部分包含以封裝格式儲存的反射器 $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。Q 矩陣可以使用 Matrix 轉換為正規矩陣。此操作會傳回「瘦」的 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 分解，且可用於計算欠定方程組的最小範數解 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 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

對稱或 Hermitian 矩陣 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

計算對稱或 Hermitian 矩陣 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 為 false，則不會使用城堡換位。

當 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 的欄位。（第 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; # destructuring via iteration

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` 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 的特徵向量。（第 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 的特徵向量。（第 k 個特徵向量可從切片 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) -> Matrix

傳回矩陣 M，其欄位是 A 和 B 的廣義特徵向量。（第 k 個特徵向量可從切片 M[:, 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 是特徵向量，而 λ 是特徵值。（第 k 個特徵向量可從切片 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; # 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' 可以使用 UniformScaling 物件 I 有效地透過 F + μ*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'。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

兩個矩陣 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 對角區塊；這允許分解在存在複數特徵值時仍為純實數。若要從實數準三角形分解取得（複數）純上三角形 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 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 取得（準）三角 Schur 因數，方法為使用 F.S 和 F.T，可使用 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，並傳回廣義 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 是分解物件，則 U、S、V 和 Vt 可透過 F.U、F.S、F.V 和 F.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-by-N 矩陣 A 和 P-by-N 矩陣 B，

• 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。

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); # 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，傳回一個廣義 SVD 分解物件 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) -> 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)

提供矩陣 M 的第 k 個對角線索引的 AbstractRange。

另請參閱：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 計算弗羅貝尼烏斯範數。

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

對於共軛/轉置包裝的向量，傳回 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) # 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 是對稱或 Hermitian，則使用其特徵分解（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 是實對稱或 Hermitian，其特徵分解 (eigen) 用於計算平方根。對於此類矩陣，由於捨入誤差而看起來略微為負的特徵值 λ 會被視為零。更精確地說，所有特徵值 ≥ -rtol*(max |λ|) 的矩陣會被視為半正定（產生一個 Hermitian 平方根），負特徵值則視為零。rtol 是 sqrt（僅在 Hermitian/實對稱的情況下）的關鍵字參數，其預設值為機器精度乘以 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 是對稱或 Hermitian，其特徵分解 (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 是對稱或 Hermitian，其特徵分解 (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 是對稱或 Hermitian，則其特徵分解 (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 是對稱或 Hermitian，其特徵分解 (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 是對稱或 Hermitian，其特徵分解 (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

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 分解來測試矩陣是否正定（和 Hermitian）。

另請參閱 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 分解來測試矩陣是否正定（和 Hermitian），在此過程中覆寫 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

測試從第 k 個超對角線開始的 A 是否為下三角矩陣。

範例

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

測試從第 k 個超對角線開始的 A 是否為上三角矩陣。

範例

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

測試矩陣是否為 Hermitian 矩陣。

範例

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，但對於 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 中，其大小應對應於 (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 執行緒數目可以使用 BLAS.set_num_threads(n) 設定。

如果提供了關鍵字引數 eltype，peakflops 會建構元素類型為 eltype 的矩陣，以計算峰值浮點運算速率。

預設情況下，peakflops 會從 3 次試驗中使用最佳計時。如果提供了 ntrials 關鍵字引數，peakflops 會使用這些試驗來挑選最佳計時。

如果關鍵字引數 parallel 設為 true，peakflops 會在所有工作處理器上並行執行。傳回整個平行電腦的浮點運算速率。在並行執行時，只會使用 1 個 BLAS 執行緒。引數 n 仍然是指在每個處理器上求解的問題大小。

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

傳回方陣 A 的 Hermitian 部分，定義為 (A + A') / 2，為 Hermitian 矩陣。對於實數矩陣 A，這也稱為 A 的對稱部分；有時也稱為「算子實數部分」。選用參數 uplo 控制 Hermitian 檢視的對應參數。對於實數矩陣，後者等於 Symmetric 檢視。

另請參閱 hermitianpart! 以取得對應的原位操作。

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

以其 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)

使用純量 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! 就地完成），而需要 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

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)

使用陣列 X 的前 n 個元素（步幅為 incx）和陣列 Y 的前 n 個元素（步幅為 incy），覆寫 X 為 c*X + s*Y，覆寫 Y 為 -conj(s)*X + c*Y。傳回 X 和 Y。

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

以陣列 X 的前 n 個元素的 a*X 覆寫 X，其跨距為 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)

兩個複數向量的點函數，包含陣列 X 的 n 個元素，其跨距為 incx，以及陣列 Y 的 n 個元素，其跨距為 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)

一個向量的 2-範數，包含陣列 X 的 n 個元素，其跨距為 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)

根據 tA 將向量 y 更新為 alpha*A*x + beta*y 或 alpha*A'x + beta*y。alpha 和 beta 是純量。傳回更新後的 y。

gemv(tA, alpha, A, x)

根據 tA 傳回 alpha*A*x 或 alpha*A'x。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 乘以 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 是 Hermitian。只使用 A 的 ul 三角形。alpha 和 beta 是純量。傳回更新後的 y。

hemv(ul, alpha, A, x)

傳回 alpha*A*x。假設 A 是 Hermitian。只使用 A 的 ul 三角形。alpha 是純量。

hemv(ul, A, x)

傳回 A*x。假設 A 為 Hermitian。僅使用 A 的 ul 三角形。

hpmv!(uplo, α, AP, x, β, y)

將向量 y 更新為 α*A*x + β*y，其中 A 為以封裝格式 AP 提供的 Hermitian 矩陣。

當 uplo = 'U' 時，陣列 AP 必須包含 Hermitian 矩陣的上三角形，以逐欄順序封裝，因此 AP[1] 包含 A[1, 1]，AP[2] 和 AP[3] 分別包含 A[1, 2] 和 A[2, 2]，依此類推。

當 uplo = 'L' 時，陣列 AP 必須包含 Hermitian 矩陣的下三角形，以逐欄順序封裝，因此 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 所述：http://www.netlib.org/lapack/explore-html/。只使用 A 的 uplo 三角形。

傳回已更新的 y。

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

傳回 alpha*A*x，其中 A 為階數為 size(A,2) 的對稱帶狀矩陣，且 k 個超對角線儲存在參數 A 中。只使用 A 的 uplo 三角形。

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 類型。

傳回已更新的 y。

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)

用 A*x = b 或由 tA 和 ul 決定之其他兩個變體的解覆寫 b。 dA 決定是否讀取對角線值或假設所有值都為一。傳回更新後的 b。

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

傳回 A*x = b 或由 tA 和 ul 決定之其他兩個變體的解。 dA 決定是否讀取對角線值或假設所有值都為一。

ger!(alpha, x, y, A)

使用向量 x 和 y 將矩陣 A 更新為秩 1，作為 alpha*x*y' + A。

her!(uplo, alpha, x, A)

僅適用於複數陣列的方法。使用向量 x 將 Hermitian 矩陣 A 更新為秩 1，作為 alpha*x*x' + A。 uplo 控制更新 A 的哪個三角形。傳回 A。

syr!(uplo, alpha, x, A)

使用向量 x 將對稱矩陣 A 更新為秩 1，作為 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 為 Hermitian。只使用 A 的 ul 三角形。傳回已更新的 C。

hemm(side, ul, alpha, A, B)

根據 side 傳回 alpha*A*B 或 alpha*B*A。假設 A 為 Hermitian。只使用 A 的 ul 三角形。

hemm(side, ul, A, B)

根據 side 傳回 A*B 或 B*A。假設 A 為 Hermitian。只使用 A 的 ul 三角形。

syrk!(uplo, trans, alpha, A, beta, C)

根據 trans 將對稱矩陣 C 的秩 k 更新為 alpha*A*transpose(A) + beta*C 或 alpha*transpose(A)*A + beta*C。只使用 C 的 uplo 三角形。傳回 C。

syrk(uplo, trans, alpha, A)

根據 uplo 傳回 A 的上三角形或下三角形，根據 trans 傳回 alpha*A*transpose(A) 或 alpha*transpose(A)*A。

herk!(uplo, trans, alpha, A, beta, C)

僅限複數陣列的方法。根據 trans 將 Hermitian 矩陣 C 的秩 k 更新為 alpha*A*A' + beta*C 或 alpha*A'*A + beta*C。僅更新 C 的 uplo 三角形。傳回 C。

herk(uplo, trans, alpha, A)

僅限複數陣列的方法。根據 trans 傳回 alpha*A*A' 或 alpha*A'*A 的 uplo 三角形。

syr2k!(uplo, trans, alpha, A, B, beta, C)

根據 trans 將對稱矩陣 C 的秩 2k 更新為 alpha*A*transpose(B) + alpha*B*transpose(A) + beta*C 或 alpha*transpose(A)*B + alpha*transpose(B)*A + beta*C。僅使用 C 的 uplo 三角形。傳回 C。

syr2k(uplo, trans, alpha, A, B)

根據 trans 傳回 alpha*A*transpose(B) + alpha*B*transpose(A) 或 alpha*transpose(A)*B + alpha*transpose(B)*A 的 uplo 三角形。

syr2k(uplo, trans, A, B)

根據 trans 傳回 A*transpose(B) + B*transpose(A) 或 transpose(A)*B + transpose(B)*A 的 uplo 三角形。

her2k!(uplo, trans, alpha, A, B, beta, C)

根據 trans 將 Hermitian 矩陣 C 的秩 2k 更新為 alpha*A*B' + alpha*B*A' + beta*C 或 alpha*A'*B + alpha*B'*A + beta*C。純量 beta 必須為實數。僅使用 C 的 uplo 三角形。傳回 C。

her2k(uplo, trans, alpha, A, B)

傳回 uplo 三角形，根據 trans，傳回 alpha*A*B' + alpha*B*A' 或 alpha*A'*B + alpha*B'*A。

her2k(uplo, trans, A, B)

傳回 uplo 三角形，根據 trans，傳回 A*B' + B*A' 或 A'*B + B'*A。

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)

使用 A*X = alpha*B 的解或由 side 和 tA 決定的其他三個變體之一覆寫 B。僅使用 A 的 ul 三角形。dA 決定是否讀取對角線值或假設它們全為 1。傳回已更新的 B。

trsm(side, ul, tA, dA, alpha, A, B)

傳回 A*X = alpha*B 的解或由 side 和 tA 決定的其他三個變體之一。僅使用 A 的 ul 三角形。dA 決定是否讀取對角線值或假設它們全為 1。

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)

在計算特徵系統或 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，其中包含參數化分解基本反射器的純量。

geqlf!(A, tau)

計算 A 的 QL 分解，A = QL。tau 包含參數化分解基本反射器的純量。tau 的長度必須大於或等於 A 的最小維度。

傳回原地修改的 A 和 tau。

geqlf!(A) -> (A, tau)

計算 A 的 QL 分解，A = QL。

傳回原地修改的 A，以及 tau，其中包含參數化分解基本反射器的純量。

geqrf!(A, tau)

計算 A 的 QR 分解，A = QR。tau 包含參數化分解的初等反射器的純量。tau 的長度必須大於或等於 A 的最小維度。

傳回原地修改的 A 和 tau。

geqrf!(A) -> (A, tau)

計算 A 的 QR 分解，A = QR。

傳回原地修改的 A，以及 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，其中包含參數化分解基本反射器的純量。

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 之間，也就是 A 的第二個維度。

傳回修改原地的 A，以及 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，其中包含參數化分解基本反射器的上三角區塊反射器。

getrf!(A) -> (A, ipiv, info)

計算 A 的樞紐 LU 分解，A = LU。

傳回修改原地的 A、樞紐資訊 ipiv，以及指示成功（info = 0）、U 中的奇異值（info = i，其中 U[i,i] 為奇異值）或錯誤碼（info < 0）的 info 碼。

tzrzf!(A) -> (A, tau)

將上梯形矩陣 A 轉換為上三角形式。傳回 A 和 tau，也就是轉換基本反射器的純量參數。

ormrz!(side, trans, A, tau, C)

使用 tzrzf! 提供的轉換將矩陣 C 乘以 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 的 LU 因式分解來求解線性方程式 A * X = B，其中 A 是方陣。A 會覆寫為其 LU 因式分解，而 B 會覆寫為解 X。ipiv 包含 A 的 LU 因式分解的樞紐資訊。

getrs!(trans, A, ipiv, B)

求解線性方程式 A * X = B、transpose(A) * X = B 或 adjoint(A) * X = B，其中 A 為方陣。使用解修改矩陣/向量 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' 的列，並分別傳回。

gesvd!(jobu, jobvt, A) -> (U, S, VT)

找出 A 的奇異值分解，A = U * S * V'。如果 jobu = A，則會計算 U 的所有欄。如果 jobvt = A，則會計算 V' 的所有列。如果 jobu = N，則不會計算 U 的任何欄。如果 jobvt = N，則不會計算 V' 的任何列。如果 jobu = O，則會用（瘦）U 的欄覆寫 A。如果 jobvt = O，則會用（瘦）V' 的列覆寫 A。如果 jobu = S，則會計算（瘦）U 的欄並分別傳回。如果 jobvt = S，則會計算（瘦）V' 的列並分別傳回。jobu 和 jobvt 不能同時為 O。