Linear Algebra

NoPivot

ピボットは実行されません。これはcholeskyおよびqr因子分解のデフォルト戦略です。ただし、LU因子分解などの他の行列因子分解は、ピボットなしでは失敗する可能性があり、丸め誤差に対して浮動小数点行列に対して数値的に不安定である可能性があります。そのような場合、このピボット戦略は主に教育的目的で有用です。

RowNonZero

残りの行の最初の非ゼロ要素がピボット要素として選ばれます。

浮動小数点行列に対しては、結果として得られるLUアルゴリズムは数値的に不安定であるため注意が必要です。この戦略は、主に手計算（通常この戦略を使用する）との比較や、丸め誤差に影響されない他の代数型（例えば、有理数）に対して有用です。それ以外の場合、ガウス消去法ではデフォルトのRowMaximumピボット戦略が一般的に推奨されます。

行列の要素型は、iszeroメソッドを許容する必要があります。

RowMaximum

行（および潜在的に列）ピボットは、最大の特性に基づいて選択されます。これはLU因子分解およびピボット付きコレスキー因子分解のデフォルト戦略です（ただし、choleskyのデフォルトは[NoPivot]です）。

LUの場合、残りの行の現在の列内で最大の絶対値を持つ要素がピボット要素として選択されます。これは時々「部分ピボティング」アルゴリズムと呼ばれます。この場合、行列の要素型はabsメソッドを許可し、その結果の型は<メソッドを許可しなければなりません。

コレスキーの場合、残りの対角要素の中で最大の要素がピボット要素として選択されます。これは時々「対角ピボティング」アルゴリズムと呼ばれ、完全ピボティング（すなわち、同じ置換による行と列の両方のピボティング）につながります。この場合、行列の（実部の）要素型は<メソッドを許可しなければなりません。

ColumnNorm

最大ノルムを持つ列がその後の計算に使用されます。これはピボットQR因子分解に使用されます。

行列の要素型は、normおよびabsメソッドを許容する必要があり、それぞれの結果型は<メソッドを許容する必要があります。

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

行列の乗算。

例

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

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

3つまたは4つの行列の連鎖乗算は、配列のサイズに基づいて最も効率的な順序で行われます。つまり、3つの密行列を用いた (A * B) * C に必要なスカラー乗算の数が、A * (B * C) のそれと比較され、どちらを実行するかが選択されます。

最後の因子がベクトルであるか、最初の因子が転置ベクトルである場合、これらを最初に処理するのが効率的です。特に x' * B * y は、通常の列優先の B::Matrix に対して (x' * B) * y を意味します。dot(x, B, y) とは異なり、これは中間配列を割り当てます。

最初または最後の因子が数値である場合、これは行列乗算と融合され、5引数の mul! が使用されます。

他に muladd、dot も参照してください。

\(A, B)

ポリアルゴリズムを使用した行列の除算。入力行列 A と B に対して、結果 X は A*X == B となるように、A が正方行列である場合に成り立ちます。使用されるソルバーは A の構造に依存します。A が上三角または下三角（または対角）である場合、A の因数分解は必要なく、前方または後方代入によってシステムが解かれます。非三角形の正方行列の場合、LU因数分解が使用されます。

矩形の A に対して、結果は A のピボットQR因数分解と R 因子に基づく A のランク推定によって計算された最小ノルム最小二乗解です。

A がスパースの場合、同様のポリアルゴリズムが使用されます。非定義行列の場合、LDLt 因数分解は数値因数分解中にピボッティングを使用しないため、可逆行列であっても手続きが失敗する可能性があります。

参照: factorize, pinv.

例

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

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

julia> A * X == B
true

A / B

行列の右除算: A / B は (B' \ A')' に相当し、ここで \ は左除算演算子です。正方行列の場合、結果 X は A == X*B となります。

関連情報: rdiv!.

例

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

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

julia> isapprox(A, X*B)
true

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

SingularException

入力行列に1つ以上のゼロ値の固有値があり、逆行列が存在しない場合にスローされる例外です。このような行列を含む線形解は計算できません。infoフィールドは、(1つの)特異値の位置を示します。

PosDefException

入力行列が正定値でない場合にスローされる例外。一部の線形代数関数や因数分解は正定値行列にのみ適用可能です。infoフィールドは、0以下の（いずれかの）固有値の位置を示します。

ZeroPivotException <: Exception

ピボット（対角）位置にゼロがある場合に行列の因子分解/解決が遭遇し、進行できないときにスローされる例外です。これは行列が特異であることを意味するわけではありません：偽のゼロピボットを排除するために変数を再配置できるピボット付きLUなど、別の因子分解に切り替えることが有益な場合があります。infoフィールドは、ゼロピボットの位置を示します。

RankDeficientException

入力行列がランク欠損であるときにスローされる例外です。コレスキー分解のような一部の線形代数関数は、ランク欠損でない行列にのみ適用可能です。infoフィールドは、行列の計算されたランクを示します。

LAPACKException

一般的なLAPACK例外は、LAPACK関数への直接呼び出し中、またはLAPACK関数を内部で使用する他の関数への呼び出し中に、特別なエラーハンドリングがない場合にスローされます。infoフィールドには、基礎となるエラーに関する追加情報が含まれており、呼び出されたLAPACK関数に依存します。

dot(x, y)
x ⋅ y

2つのベクトル間のドット積を計算します。複素ベクトルの場合、最初のベクトルは共役されます。

dotは、要素に対してdotが定義されている限り、任意の次元の配列を含む任意の反復可能なオブジェクトでも機能します。

dotは、引数が等しい長さであるという追加の制約があることを除いて、sum(dot(vx,vy) for (vx,vy) in zip(x, y))と意味的に同等です。

x ⋅ y（ここで⋅はREPLで\cdotをタブ補完することで入力できます）はdot(x, y)の同義語です。

例

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

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

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

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

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

julia> dot(x, y)
150.0

dot(x, A, y)

二つのベクトル x と y の間で、dot(x, A*y) の一般化された内積を計算します。中間結果 A*y を保存せずに行います。二引数の dot(_,_) と同様に、再帰的に動作します。さらに、複素ベクトルの場合、最初のベクトルは共役されます。

例

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

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

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

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

2つの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)

yをx * α + 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)

yをx * α + 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)

xをc*x + s*yで上書きし、yを-conj(s)*x + c*yで上書きします。xとyを返します。

reflect!(x, y, c, s)

xをc*x + s*yで上書きし、yをconj(s)*x - c*yで上書きします。xとyを返します。

factorize(A)

行列 A の便利な因数分解を計算します。入力行列のタイプに基づいています。A が一般的な行列として渡されると、factorize はそれが対称/三角形/etc. であるかどうかを確認します。この目的のために、factorize は A のすべての要素をチェックして、各特性を確認または除外する場合があります。対称性/三角形構造を除外できるとすぐに短絡します。返り値は、複数のシステムを効率的に解くために再利用できます。例えば: A=factorize(A); x=A\b; y=A\C。

例

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

julia> factorize(A) # factorize は A がすでに因数分解されているかどうかを確認します
5×5 Bidiagonal{Float64, Vector{Float64}}:
 1.0  1.0   ⋅    ⋅    ⋅
  ⋅   1.0  1.0   ⋅    ⋅
  ⋅    ⋅   1.0  1.0   ⋅
  ⋅    ⋅    ⋅   1.0  1.0
  ⋅    ⋅    ⋅    ⋅   1.0

これは 5×5 Bidiagonal{Float64} を返し、これを他の線形代数関数（例えば、固有値ソルバー）に渡すことができ、Bidiagonal タイプのための特化したメソッドが使用されます。

Diagonal(V::AbstractVector)

Vを対角成分とする遅延行列を構築します。

遅延単位行列IについてはUniformScalingを、密行列を作成するための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

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 の主対角線から行列を構築します。入力行列 A は長方形である可能性がありますが、出力は正方形になります。

例

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

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

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

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

Diagonal{T}(undef, n)

長さ n の初期化されていない Diagonal{T} を構築します。undef を参照してください。

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

与えられた対角ベクトル（dv）と副対角ベクトル（ev）を使用して、上三角（uplo=:U）または下三角（uplo=:L）のバイダイアゴナル行列を構築します。結果は Bidiagonal 型であり、効率的な特化型線形ソルバーを提供しますが、convert(Array, _)（または短縮形の Array(_)）を使用して通常の行列に変換することができます。ev の長さは dv の長さよりも1少なくなければなりません。

例

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

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

julia> Bu = Bidiagonal(dv, ev, :U) # ev は最初の上対角にあります
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 ⋅  2  8  ⋅
 ⋅  ⋅  3  9
 ⋅  ⋅  ⋅  4

julia> Bl = Bidiagonal(dv, ev, :L) # ev は最初の下対角にあります
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 7  2  ⋅  ⋅
 ⋅  8  3  ⋅
 ⋅  ⋅  9  4

Bidiagonal(A, uplo::Symbol)

Aの主対角線とその最初の上部対角線（uplo=:Uの場合）または下部対角線（uplo=:Lの場合）からBidiagonal行列を構築します。

例

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

julia> Bidiagonal(A, :U) # Aの主対角線と最初の上部対角線を含む
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  1  ⋅  ⋅
 ⋅  2  2  ⋅
 ⋅  ⋅  3  3
 ⋅  ⋅  ⋅  4

julia> Bidiagonal(A, :L) # Aの主対角線と最初の下部対角線を含む
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 2  2  ⋅  ⋅
 ⋅  3  3  ⋅
 ⋅  ⋅  4  4

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

対角線（dv）と最初の下/上対角線（ev）から対称トリジナル行列を構築します。結果は SymTridiagonal 型であり、効率的な特化型固有値ソルバーを提供しますが、convert(Array, _)（または短縮形の Array(_)）を使用して通常の行列に変換することができます。

SymTridiagonal ブロック行列の場合、dv の要素は対称化されます。引数 ev は上対角線として解釈されます。下対角線からのブロックは、対応する上対角線ブロックの（具現化された）転置です。

例

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

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

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

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

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

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

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

SymTridiagonal(A::AbstractMatrix)

対称行列 A の対角成分と最初の上対角成分から対称トリジオナル行列を構築します。

例

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

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

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

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

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

最初の下対角成分、対角成分、および最初の上対角成分から三重対角行列を構築します。結果は Tridiagonal 型であり、効率的な特化型線形ソルバーを提供しますが、convert(Array, _)（または短縮形の Array(_)）を使用して通常の行列に変換することができます。dl と du の長さは d の長さよりも1少なくなければなりません。

例

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

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

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

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

Tridiagonal(A)

行列 A の最初の下対角成分、対角成分、および最初の上対角成分から三重対角行列を構築します。

例

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

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

Symmetric(A::AbstractMatrix, uplo::Symbol=:U)

行列 A の上三角（uplo = :U の場合）または下三角（uplo = :L の場合）の Symmetric ビューを構築します。

Symmetric ビューは主に実対称行列に対して有用であり、特化したアルゴリズム（例えば、固有値問題用）が Symmetric 型に対して有効になります。より一般的には、実行列に対しては Symmetric と実質的に同等ですが、複素行列にも有用なエルミート行列 A == A' のために Hermitian(A) も参照してください。（複素 Symmetric 行列はサポートされていますが、特化したアルゴリズムはほとんどありません。）

実行列の対称部分、または一般的には実または複素行列 A のエルミート部分 (A + A') / 2 を計算するには、hermitianpart を使用してください。

例

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

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

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

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

Supper は A 自体が対称でない限り（例えば、A == transpose(A) の場合） Slower と等しくなりません。

Hermitian(A::AbstractMatrix, uplo::Symbol=: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

Hupper は Hlower と等しくなりません、A 自体が Hermitian でない限り（例えば、A == adjoint(A) の場合）。

対角線の非実数部分は無視されます。

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 関数も参照してください。

F::Hessenberg が因数分解オブジェクトである場合、ユニタリ行列は F.Q でアクセスでき、ヘッセンベルク行列は F.H でアクセスできます。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

行列因子分解（matrix factorizations）の抽象型。利用可能な行列因子分解のリストについては、オンラインドキュメントを参照してください。

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); # 反復による分解

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

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

スパース行列 A のLU因子分解を計算します。

実数または複素数要素型のスパース A に対して、返り値の型 F は UmfpackLU{Tv, Ti} であり、Tv は Float64 または ComplexF64 でそれぞれ、Ti は整数型（Int32 または Int64）です。

check = true の場合、分解が失敗した場合はエラーが発生します。check = false の場合、分解の有効性を確認する責任はユーザーにあります（issuccess を通じて）。

置換 q は置換ベクトルまたは nothing であることができます。置換ベクトルが提供されない場合や q が nothing の場合、UMFPACKのデフォルトが使用されます。置換がゼロベースでない場合、ゼロベースのコピーが作成されます。

control ベクトルは、UMFPACKのためのJulia SparseArraysパッケージのデフォルト設定にデフォルトで設定されています（注：これは反復精度を無効にするためにUMFPACKのデフォルトから修正されています）が、UMFPACK_CONTROL の長さのベクトルを渡すことで変更できます。可能な設定についてはUMFPACKマニュアルを参照してください。たとえば、反復精度を再有効にするには：

umfpack_control = SparseArrays.UMFPACK.get_umfpack_control(Float64, Int64) # Float64スパース行列のためのJuliaデフォルト設定を読み取る
SparseArrays.UMFPACK.show_umf_ctrl(umfpack_control) # オプション - 値を表示
umfpack_control[SparseArrays.UMFPACK.JL_UMFPACK_IRSTEP] = 2.0 # 反復精度を再有効にする（2はUMFPACKのデフォルトの最大反復精度ステップ数）

Alu = lu(A; control = umfpack_control)
x = Alu \ b   # Ax = b を解く、UMFPACKの反復精度を含む

因子分解 F の個々のコンポーネントにはインデックスを使用してアクセスできます：

F と A の関係は次の通りです。

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

F はさらに以下の関数をサポートしています：

• \
• det

また lu! も参照してください。

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

行列 A の LU 分解を計算します。

check = true の場合、分解が失敗した場合にエラーがスローされます。check = false の場合、分解の有効性を確認する責任はユーザーにあります（issuccess を介して）。

デフォルトでは、check = true の場合、有効な因子が生成されても、上三角因子 U がランク欠損の場合にもエラーがスローされます。これは allowsingular = true を渡すことで変更できます。

ほとんどの場合、A が要素型 T を持ち、+、-、*、および / をサポートする AbstractMatrix{T} のサブタイプ S である場合、戻り値の型は LU{T,S{T}} です。

一般に、LU 分解は行列の行の順序を入れ替えることを含みます（以下に説明する F.p 出力に対応）、これを「ピボット」と呼びます（これは「ピボット」、すなわち F.U の対角成分を含む行を選択することに対応します）。次のいずれかのピボット戦略をオプションの pivot 引数を介して選択できます：

• RowMaximum()（デフォルト）：標準のピボット戦略；ピボットは、残りの因子化される行の中で最大絶対値を持つ要素に対応します。このピボット戦略は、要素型が abs および < をサポートすることを要求します。（これは一般に浮動小数点行列に対して唯一の数値的に安定したオプションです。）
• RowNonZero(): ピボットは、残りの因子化される行の中で最初の非ゼロ要素に対応します。（これは手計算での典型的な選択に対応し、abs や < をサポートしないより一般的な代数数型にも便利です。）
• NoPivot(): ピボットをオフにします（allowsingular = true の場合でも、ピボット位置でゼロエントリに遭遇すると失敗します）。

分解 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 因子:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U 因子:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

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

julia> l, u, p = lu(A); # 反復を介した分解

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

julia> lu([1 2; 1 2], allowsingular = true)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L 因子:
2×2 Matrix{Float64}:
 1.0  0.0
 1.0  1.0
U 因子（ランク欠損）:
2×2 Matrix{Float64}:
 1.0  2.0
 0.0  0.0

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

スパース行列 A のLU分解を計算し、既存のLU分解 F に保存されている符号的分解を再利用します。reuse_symbolic が false に設定されていない限り、スパース行列 A はLU分解 F を作成するために使用された行列と同一の非ゼロパターンを持っている必要があり、そうでない場合はエラーが発生します。A と F のサイズが異なる場合、すべてのベクトルはそれに応じてサイズ変更されます。

check = true の場合、分解が失敗した場合はエラーが発生します。check = false の場合、分解の有効性を確認する責任はユーザーにあります（issuccess を介して）。

置換 q は置換ベクトルまたは nothing である可能性があります。置換ベクトルが提供されない場合や q が nothing の場合、UMFPACK のデフォルトが使用されます。置換がゼロベースでない場合、ゼロベースのコピーが作成されます。

他にも lu を参照してください。

例

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

julia> F = lu(A);

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

julia> lu!(F, B);

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

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

lu! は lu と同じですが、入力 A を上書きすることでスペースを節約します。因子分解が A の要素型で表現できない数を生成した場合、例えば整数型の場合、InexactError 例外がスローされます。

例

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

julia> F = lu!(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L 因子:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U 因子:
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 の返り値の型です。

三角形のコレスキー因子は、因子化 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; # 反復による分解

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

CholeskyPivoted

密な対称/エルミート半正定値行列 A のピボット付きコレスキー分解の行列因子化タイプです。これは、対応する行列因子化関数 cholesky(_, ::RowMaximum) の返り値の型です。

三角形のコレスキー因子は、因子分解 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 分解を返します。行列 A は、Symmetric または Hermitian AbstractMatrix であるか、完全に 対称またはエルミートな AbstractMatrix である必要があります。

三角形のコレスキー因子は、分解 F から F.L と F.U を介して取得でき、A ≈ F.U' * F.U ≈ F.L * F.L' となります。

Cholesky オブジェクトに対して利用可能な関数は次のとおりです: size, \, inv, det, logdet および isposdef。

構築時の丸め誤差により行列 A がわずかに非エルミートである場合は、cholesky に渡す前に Hermitian(A) でラップして、完全にエルミートとして扱います。

check = true の場合、分解が失敗した場合はエラーがスローされます。check = false の場合、分解の有効性を確認する責任（issuccess を介して）はユーザーにあります。

例

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

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

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

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

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

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

密な対称半正定値行列 A のピボット付きコレスキー分解を計算し、CholeskyPivoted 分解を返します。行列 A は、Symmetric または Hermitian AbstractMatrix であるか、完全に 対称またはエルミートな AbstractMatrix である必要があります。

三角形のコレスキー因子は、分解 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 は、ランクを決定するための許容誤差を決定します。負の値の場合、許容誤差は eps()*size(A,1)*maximum(diag(A)) に等しくなります。

構築時の丸め誤差により、行列 A がわずかに非エルミートである場合は、cholesky に渡す前に Hermitian(A) でラップして、完全にエルミートとして扱います。

check = true の場合、分解が失敗した場合はエラーがスローされます。check = false の場合、分解の有効性を確認する責任はユーザーにあります（issuccess を介して）。

例

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

julia> A = X * X';

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

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

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

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

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

スパースの正定値行列 A のコレスキー分解を計算します。A は SparseMatrixCSC であるか、SparseMatrixCSC の Symmetric/Hermitian ビューでなければなりません。A に型タグがなくても、対称またはエルミートである必要があります。perm が指定されていない場合、フィル削減置換が使用されます。F = cholesky(A) は、F\b を使用して方程式系を解くために最も頻繁に使用されますが、diag、det、および logdet のメソッドも F に対して定義されています。また、F から個々の因子を F.L を使用して抽出することもできます。ただし、ピボッティングがデフォルトでオンになっているため、分解は内部的に A == P'*L*L'*P として表現され、置換行列 P が含まれています。P を考慮せずに L のみを使用すると、誤った結果が得られます。置換の効果を含めるには、通常、PtL = F.PtL（P'*L の同等物）や LtP = F.UP（L'*P の同等物）などの「結合」因子を抽出する方が好ましいです。

check = true の場合、分解が失敗した場合にエラーがスローされます。check = false の場合、分解の有効性を確認する責任（issuccess を介して）はユーザーにあります。

オプションの shift キーワード引数を設定すると、A の代わりに A+shift*I の分解が計算されます。perm 引数が提供される場合、それは 1:size(A,1) の置換であり、使用する順序を指定します（CHOLMOD のデフォルトの AMD 順序の代わりに）。

正定値性を必要としない類似の分解については、ldlt を参照してください。ただし、cholesky よりもかなり遅くなる可能性があります。

例

次の例では、使用されるフィル削減置換は [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のコレスキー ($LL'$) 分解を計算し、シンボリック分解 F を再利用します。A は SparseMatrixCSC または SparseMatrixCSC の Symmetric/ Hermitian ビューでなければなりません。A が型タグを持っていなくても、対称またはエルミートである必要があります。

詳細は cholesky を参照してください。

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

ベクトル v で Cholesky 分解 C を更新します。もし A = C.U'C.U ならば CC = cholesky(C.U'C.U + v*v') ですが、CC の計算は O(n^2) の演算のみを使用します。

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

A + C*C' の LDLt 因子分解を、A の LDLt または LLt 因子分解 F に基づいて取得します。

返される因子は常に LDLt 因子分解です。

他にも lowrankupdate!, lowrankdowndate, lowrankdowndate! を参照してください。

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

ベクトル v で Cholesky 分解 C をダウンドデートします。もし A = C.U'C.U ならば CC = cholesky(C.U'C.U - v*v') ですが、CC の計算は O(n^2) の演算のみを使用します。

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

A + C*C' の LDLt 因子分解を、A の LDLt または LLt 因子分解 F に基づいて取得します。

返される因子は常に LDLt 因子分解です。

他にも lowrankdowndate!, lowrankupdate, lowrankupdate! を参照してください。

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

ベクトル v で Cholesky 分解 C を更新します。もし A = C.U'C.U ならば CC = cholesky(C.U'C.U + v*v') ですが、CC の計算は O(n^2) の演算のみを使用します。入力の分解 C はインプレースで更新され、終了時には C == CC となります。ベクトル v は計算中に破棄されます。

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

AのLDLtまたはLLt因子分解FをA + C*C'の因子分解に更新します。

LLt因子分解はLDLtに変換されます。

関連情報としてlowrankupdate、lowrankdowndate、lowrankdowndate!を参照してください。

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

ベクトル v で Cholesky 分解 C をダウンドデートします。もし A = C.U'C.U ならば CC = cholesky(C.U'C.U - v*v') ですが、CC の計算は O(n^2) の操作のみを使用します。入力の分解 C はインプレースで更新され、終了時には C == CC となります。ベクトル v は計算中に破棄されます。

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

AのLDLtまたはLLt因子分解FをA - C*C'の因子分解に更新します。

LLt因子分解はLDLtに変換されます。

lowrankdowndate、lowrankupdate、lowrankupdate!も参照してください。

LDLt <: Factorization

実数の SymTridiagonal 行列 S の LDLt 分解の行列分解タイプで、S = L*Diagonal(d)*L' となります。ここで、L は UnitLowerTriangular 行列であり、d はベクトルです。LDLt 分解 F = ldlt(S) の主な用途は、線形方程式系 Sx = b を F\b で解くことです。これは、対応する行列分解関数 ldlt の戻り値の型です。

分解 F::LDLt の個々のコンポーネントには getproperty を介してアクセスできます：

例

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

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

ldlt(S::SymTridiagonal) -> LDLt

実数対称三重対角行列 S の LDLt（すなわち、$LDL^T$）因子分解を計算します。ここで、S = L*Diagonal(d)*L' となり、L は単位下三角行列、d はベクトルです。LDLt 因子分解 F = ldlt(S) の主な用途は、線形方程式系 Sx = b を F\b で解くことです。

任意の対称またはエルミート行列の類似のピボット付き因子分解については、bunchkaufman を参照してください。

例

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

julia> ldltS = ldlt(S);

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

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

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

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

スパース行列 A の $LDL'$ 因子分解を計算します。A は SparseMatrixCSC または SparseMatrixCSC の Symmetric/Hermitian ビューでなければなりません。A が型タグを持っていなくても、対称またはエルミートである必要があります。フィル削減置換が使用されます。F = ldlt(A) は、方程式系 A*x = b を解くために最も頻繁に使用され、F\b で解を得ます。返される因子分解オブジェクト F は、diag、det、logdet、および inv メソッドもサポートしています。F から個々の因子を F.L を使用して抽出できます。ただし、ピボッティングがデフォルトでオンになっているため、因子分解は内部的に A == P'*L*D*L'*P として表現され、置換行列 P が含まれます。P を考慮せずに単に L を使用すると、誤った結果が得られます。置換の効果を含めるためには、通常、PtL = F.PtL（P'*L の同等物）や LtP = F.UP（L'*P の同等物）などの「結合」因子を抽出する方が好ましいです。サポートされている因子の完全なリストは :L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP です。

関連するコレスキー因子分解とは異なり、$LDL'$ 因子分解は A が正定値である必要はありません。ただし、すべての主小行列が良好に条件付けられている必要があり、これが満たされない場合は失敗します。

check = true の場合、分解が失敗するとエラーがスローされます。check = false の場合、分解の有効性を確認する責任（issuccess を介して）はユーザーにあります。

オプションの shift キーワード引数を設定すると、A の代わりに A+shift*I の因子分解が計算されます。perm 引数が提供される場合、それは使用する順序を示す 1:size(A,1) の置換である必要があります（CHOLMOD のデフォルトの AMD 順序の代わりに）。

ldlt よりも大幅に高速な因子分解については、cholesky を参照してください。ただし、A は正定値である必要があります。

ldlt!(S::SymTridiagonal) -> LDLt

ldltと同様ですが、コピーを作成するのではなく、入力Sを上書きすることでスペースを節約します。

例

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

julia> ldltS = ldlt!(S);

julia> ldltS === S
false

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

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

Aの$LDL'$因子分解を計算し、符号因子分解Fを再利用します。AはSparseMatrixCSCまたはSparseMatrixCSCのSymmetric/Hermitianビューでなければなりません。Aが型タグを持っていなくても、対称またはエルミートである必要があります。

詳細はldltを参照してください。

QR <: Factorization

パック形式で保存されたQR行列因子分解であり、通常はqrから得られます。$A$がm×n行列であるとき、

\[A = Q R\]

ここで、$Q$は直交/ユニタリ行列であり、$R$は上三角行列です。行列$Q$は、Householder反射器$v_i$と係数$\tau_i$の列として保存されます。ここで、

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

分解を繰り返すことで、成分QとRが生成されます。

オブジェクトには2つのフィールドがあります：

• factorsはm×n行列です。

  • 上三角部分には$R$の要素が含まれています。すなわち、R = triu(F.factors)はQRオブジェクトFに対して成り立ちます。
  • 下対角部分には、パック形式で保存された反射器$v_i$が含まれています。ここで、$v_i$は行列V = I + tril(F.factors, -1)の$i$列目です。

• τは長さmin(m,n)のベクトルで、係数$\tau_i$を含んでいます。

QRCompactWY <: Factorization

QR行列因子分解は、通常qrから得られるコンパクトブロック形式で保存されます。$A$がm×n行列であるとき、

\[A = Q R\]

ここで、$Q$は直交/ユニタリ行列であり、$R$は上三角行列です。これはQR形式に似ていますが、直交/ユニタリ行列$Q$はCompact WY形式で保存されています^{[Schreiber1989]}。ブロックサイズ$n_b$に対して、これはm×nの下台形行列$V$と、$b = \lceil \min(m,n) / n_b \rceil$個の上三角行列$T_j$（サイズ$n_b$×$n_b$、$j = 1, ..., b-1$）から構成される行列$T = (T_1 \; T_2 \; ... \; T_{b-1} \; T_b')$として保存され、上台形の$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が生成されます。

このオブジェクトには2つのフィールドがあります：

• factorsは、QR型と同様に、m×n行列です。

  • 上三角部分には$R$の要素が含まれています。つまり、R = triu(F.factors)はQRオブジェクトFに対して成り立ちます。
  • 下対角部分には、パック形式で保存された反射体$v_i$が含まれています。したがって、V = I + tril(F.factors, -1)となります。

• Tは、上記のように説明された$n_b$×$\min(m,n)$行列です。各三角行列$T_j$の下対角要素は無視されます。

QRPivoted <: Factorization

列ピボットを伴うQR行列因子分解で、通常はqrから得られるパック形式です。$A$がm×n行列であるとき、

\[A P = Q R\]

ここで、$P$は置換行列、$Q$は直交/ユニタリ行列、$R$は上三角行列です。行列$Q$はハウスホルダー反射器の列として保存されます：

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

分解を繰り返すことで、成分Q、R、およびpが生成されます。

このオブジェクトには3つのフィールドがあります：

• factorsはm×n行列です。

  • 上三角部分には$R$の要素が含まれています。すなわち、R = triu(F.factors)はQRオブジェクトFに対して成り立ちます。
  • 下対角部分には、パック形式で保存された反射器$v_i$が含まれています。ここで$v_i$は行列V = I + tril(F.factors, -1)の$i$列目です。

• τは長さmin(m,n)のベクトルで、係数$au_i$を含みます。

• jpvtは長さnの整数ベクトルで、置換$P$に対応します。

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

スパース行列 A の QR 因子分解を計算します。フィル削減行と列の置換が使用され、F.R = F.Q'*A[F.prow,F.pcol] となります。このタイプの主な用途は、\ を使用して最小二乗または過剰決定問題を解決することです。この関数は C ライブラリ SPQR^[ACM933] を呼び出します。

例

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

julia> qr(A)
SparseArrays.SPQR.QRSparse{Float64, Int64}
Q 因子:
4×4 SparseArrays.SPQR.QRSparseQ{Float64, Int64}
R 因子:
2×2 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
 -1.41421    ⋅
   ⋅       -1.41421
行の置換:
4-element Vector{Int64}:
 1
 3
 4
 2
列の置換:
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因子を取得するには、F.Q*I または collect(F.Q) を使用します。m<=n の場合、Matrix(F.Q) は m×m の直交行列を生成します。

QR 分解のブロックサイズは、pivot == NoPivot() かつ A isa StridedMatrix{<:BlasFloat} の場合にキーワード引数 blocksize :: Integer で指定できます。blocksize > minimum(size(A)) の場合は無視されます。詳細は QRCompactWY を参照してください。

例

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

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

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

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

qr! は、A が AbstractMatrix のサブタイプである場合、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 因子: 2×2 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R 因子:
2×2 Matrix{Float64}:
 -3.16228  -4.42719
  0.0      -0.632456

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

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

LQ <: 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; # 反復による分解

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を計算するために便利です。

例

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

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

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

julia> l, q = S; # 繰り返しによる分解

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

lq!(A) -> LQ

行列 A の LQ 分解を計算し、入力行列を作業領域として使用します。 lq も参照してください。

BunchKaufman <: Factorization

対称行列またはエルミート行列 A のバンチ-カウフマン因子分解の行列因子化タイプで、P'UDU'P または P'LDL'P の形式を持ち、A に上三角（デフォルト）または下三角が格納されているかに応じて異なります。A が複素対称の場合、U' と L' は共役でない転置を示し、すなわちそれぞれ transpose(U) と transpose(L) です。これは bunchkaufman の戻り値の型であり、対応する行列因子化関数です。

S::BunchKaufman が因子分解オブジェクトである場合、コンポーネントは S.uplo と S.p に応じて適切に S.D、S.U または S.L を介して取得できます。

分解を反復することで、S.uplo と S.p に応じて適切に S.D、S.U または S.L のコンポーネントが得られます。

例

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

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

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

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

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

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

対称行列またはエルミート行列 A のバンチ-カウフマン ^[Bunch1977] 因子分解を P'*U*D*U'*P または P'*L*D*L'*P として計算し、BunchKaufman オブジェクトを返します。A に格納されている三角形に応じて、U' と L' は非共役転置を示します。すなわち、transpose(U) と transpose(L) です。

分解を反復することで、S.uplo に応じて適切なコンポーネント S.D、S.U または S.L、および S.p を得ることができます。

rook が true の場合、ルークピボッティングが使用されます。rook が false の場合、ルークピボッティングは使用されません。

check = true の場合、分解が失敗した場合にエラーがスローされます。check = false の場合、分解の有効性を確認する責任（issuccess を介して）はユーザーにあります。

BunchKaufman オブジェクトに対して利用可能な関数は次のとおりです: size, \, inv, issymmetric, ishermitian, getindex.

例

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

julia> S = bunchkaufman(A) # A は内部で Symmetric(A) にラップされます
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D 因子:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U 因子:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
置換:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # 反復による分解

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

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

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

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

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

bunchkaufman!はbunchkaufmanと同じですが、コピーを作成するのではなく、入力Aを上書きすることでスペースを節約します。

Eigen <: Factorization

行列 A の固有値/スペクトル分解の行列因子化タイプです。これは、対応する行列因子化関数 eigen の戻り値の型です。

F::Eigen が因子化オブジェクトである場合、固有値は F.values を介して取得でき、固有ベクトルは行列 F.vectors の列として取得できます。（k 番目の固有ベクトルはスライス F.vectors[:, k] から取得できます。）

分解を反復すると、成分 F.values と F.vectors が得られます。

例

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

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

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

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

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

GeneralizedEigen <: Factorization

行列 A と B の一般化固有値/スペクトル分解の行列因子化タイプです。これは、2つの行列引数で呼び出されたときの対応する行列因子化関数 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{Hermitian, Symmetric}; alg::Algorithm = default_eigen_alg(A))) -> values

行列 A の固有値を返します。

alg は固有値分解に使用するアルゴリズムとLAPACKメソッドを指定します：

• alg = DivideAndConquer(): LAPACK.syevd! を呼び出します。
• alg = QRIteration(): LAPACK.syev! を呼び出します。
• alg = RobustRepresentations() (デフォルト): 複数の比較的堅牢な表現法、LAPACK.syevr! を呼び出します。

異なるメソッドの精度と性能の比較については、James W. Demmel らの SIAM J. Sci. Comput. 30, 3, 1508 (2008) を参照してください。

将来的に使用されるデフォルトの alg は変更される可能性があります。

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

行列 A の固有値を返します。ソートされた固有値のインデックスをカバーする UnitRange irange を指定することで、固有値のサブセットのみを計算することが可能です。例えば、2番目から8番目の固有値などです。

例

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

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

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

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

Aの固有値を返します。固有値の下限と上限を指定するペアvlとvuを指定することで、固有値のサブセットのみを計算することが可能です。

例

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

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

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

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

eigvals と同じですが、コピーを作成するのではなく、入力 A を上書きすることでスペースを節約します。permute、scale、および sortby キーワードは eigen と同じです。

例

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

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

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

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

eigvals と同様ですが、コピーを作成するのではなく、入力 A（および B）を上書きすることでスペースを節約します。

例

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

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

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

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

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

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

eigvals と同様ですが、コピーを作成するのではなく、入力 A を上書きすることでスペースを節約します。irange は検索する固有値 インデックス の範囲です - 例えば、2番目から8番目の固有値です。

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

eigvals と同様ですが、コピーを作成するのではなく、入力 A を上書きすることでスペースを節約します。vl は固有値を検索するための区間の下限で、vu は上限です。

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

Aの最大固有値を返します。オプションpermute=trueは行列を上三角行列に近づけるために行列を置換し、scale=trueは行列の対角要素によって行列をスケーリングし、行と列のノルムをより等しくします。Aの固有値が複素数の場合、この方法は失敗します。なぜなら、複素数はソートできないからです。

例

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

julia> eigmax(A)
1.0

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

julia> eigmax(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A`は複素固有値を持つことができません。
Stacktrace:
[...]

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

行列 A の最小固有値を返します。オプション permute=true は行列を上三角行列に近づけるように並べ替え、scale=true は行列の対角要素でスケーリングして行と列のノルムをより等しくします。A の固有値が複素数の場合、この方法は失敗します。なぜなら、複素数はソートできないからです。

例

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

julia> eigmin(A)
-1.0

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

julia> eigmin(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` は複素固有値を持つことができません。
Stacktrace:
[...]

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

行列 M を返し、その列は A の固有ベクトルです。(k 番目の固有ベクトルはスライス M[:, k] から取得できます。)

オプションの固有値ベクトル eigvals が指定されている場合、eigvecs は対応する特定の固有ベクトルを返します。

例

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

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

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

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

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

行列 A の固有ベクトルからなる行列 M を返します。(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 を返します。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 の固有値分解を計算し、固有値を F.values に、正規化された固有ベクトルを行列 F.vectors の列に含む Eigen 因子化オブジェクト F を返します。これは、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; # 反復による分解

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

eigen(A, B; sortby) -> GeneralizedEigen

行列 A と B の一般化固有値分解を計算し、一般化固有値を F.values に、一般化固有ベクトルを行列 F.vectors の列に含む GeneralizedEigen 因子化オブジェクト F を返します。これは、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; # 反復による分解

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

eigen(A::Union{Hermitian, Symmetric}; alg::LinearAlgebra.Algorithm = LinearAlgebra.default_eigen_alg(A)) -> Eigen

行列 A の固有値分解を計算し、固有値を F.values に、直交正規固有ベクトルを行列 F.vectors の列に含む Eigen 因子化オブジェクト F を返します。（k 番目の固有ベクトルはスライス F.vectors[:, k] から取得できます。）

分解を反復することで、成分 F.values と F.vectors を得ることができます。

alg は固有値分解に使用するアルゴリズムと LAPACK メソッドを指定します：

• alg = DivideAndConquer(): LAPACK.syevd! を呼び出します。
• alg = QRIteration(): LAPACK.syev! を呼び出します。
• alg = RobustRepresentations()（デフォルト）: 複数の比較的堅牢な表現法、LAPACK.syevr! を呼び出します。

異なるアルゴリズムの精度と性能の比較については、James W. Demmel et al, SIAM J. Sci. Comput. 30, 3, 1508 (2008) を参照してください。

将来的に使用されるデフォルトの alg は変更される可能性があります。

Eigen オブジェクトに対して利用可能な関数は次のとおりです: inv, det, および isposdef.

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

行列 A の固有値分解を計算し、固有値を F.values に、直交正規固有ベクトルを行列 F.vectors の列に含む Eigen 因子化オブジェクト F を返します。（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 の固有値分解を計算し、固有値を F.values に、直交正規固有ベクトルを行列 F.vectors の列に含む Eigen 因子化オブジェクト F を返します。（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オブジェクトを返します。Fが因子化オブジェクトである場合、ユニタリ行列にはF.Q（型LinearAlgebra.HessenbergQ）でアクセスでき、ヘッセンベルグ行列にはF.H（型UpperHessenberg）でアクセスできます。どちらもMatrix(F.H)またはMatrix(F.Q)を使用して通常の行列に変換できます。

AがHermitianまたは実Symmetricである場合、ヘッセンベルグ分解は実対称トリジオナル行列を生成し、F.Hは型SymTridiagonalになります。

シフト因子化A+μI = Q (H+μI) Q'は、UniformScalingオブジェクトIを使用してF + μ*Iで効率的に構築できます。これにより、共有ストレージと修正されたシフトを持つ新しいHessenbergオブジェクトが作成されます。与えられたFのシフトはF.μで取得されます。これは、Fが作成された後に、異なるμおよび/またはbに対して複数のシフト解(F + μ*I) \ 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因子: 3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}
H因子:
3×3 UpperHessenberg{Float64, Matrix{Float64}}:
  4.0      -11.3137       -1.41421
 -5.65685    5.0           2.0
   ⋅        -8.88178e-16   1.0

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

julia> q, h = F; # 反復による分解

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

hessenberg!(A) -> Hessenberg

hessenberg! は hessenberg と同じですが、コピーを作成するのではなく、入力 A を上書きすることでスペースを節約します。

Schur <: Factorization

行列 A のシュール分解の行列因子化タイプです。これは、対応する行列因子化関数 schur(_) の返り値の型です。

F::Schur が因子化オブジェクトである場合、（準）三角シュール因子は F.Schur または F.T を介して取得でき、直交/ユニタリシュールベクトルは F.vectors または F.Z を介して取得できるため、A = F.vectors * F.Schur * F.vectors' となります。行列 A の固有値は F.values で取得できます。

分解を反復することで、成分 F.T、F.Z、および F.values が得られます。

例

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

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

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

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

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

GeneralizedSchur <: Factorization

2つの行列 A と B の一般化シュール因子分解の行列因子化タイプです。これは、対応する行列因子化関数 schur(_, _) の戻り値の型です。

F::GeneralizedSchur が因子分解オブジェクトである場合、(準)三角シュール因子は F.S と F.T を介して取得でき、左ユニタリ/直交シュールベクトルは F.left または F.Q を介して、右ユニタリ/直交シュールベクトルは F.right または F.Z を介して取得でき、A=F.left*F.S*F.right' および B=F.left*F.T*F.right' となります。A と B の一般化固有値は F.α./F.β を使用して取得できます。

分解を反復することで、コンポーネント F.S、F.T、F.Q、F.Z、F.α、および F.β が生成されます。

schur(A) -> F::Schur

行列 A のシュール分解を計算します。 (準)三角シュール因子は、Schur オブジェクト F から F.Schur または F.T を使用して取得でき、直交/ユニタリシュールベクトルは F.vectors または F.Z を使用して取得できるため、A = F.vectors * F.Schur * F.vectors' となります。行列 A の固有値は F.values で取得できます。

実数の A に対して、シュール分解は「準三角形」であり、これは複素固有値の共役対に対して 2×2 の対角ブロックを持つ上三角行列であることを意味します。これにより、複素固有値が存在しても分解が純粋に実数であることが可能です。実数の準三角形因子から (複素) 純上三角シュール分解を取得するには、Schur{Complex}(schur(A)) を使用できます。

分解を繰り返すことで、成分 F.T、F.Z、および F.values が得られます。

例

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

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

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

julia> t, z, vals = F; # 繰り返しによる分解

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

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

行列 A と B の一般化シュール（または QZ）因子分解を計算します。(準)三角シュール因子は、Schur オブジェクト F から F.S と F.T を使って取得でき、左ユニタリ/直交シュールベクトルは F.left または F.Q で取得でき、右ユニタリ/直交シュールベクトルは F.right または F.Z で取得できるため、A=F.left*F.S*F.right' および B=F.left*F.T*F.right' となります。行列 A と B の一般化固有値は F.α./F.β で取得できます。

分解を繰り返すことで、成分 F.S、F.T、F.Q、F.Z、F.α、および F.β を得ることができます。

schur!(A) -> F::Schur

schurと同様ですが、入力引数Aを作業領域として使用します。

例

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

julia> F = schur!(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T因子:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z因子:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
固有値:
2要素 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

行列 A = Z*T*Z' のシュール因子分解 F を論理配列 select に従って再配置し、再配置された因子分解 F オブジェクトを返します。選択された固有値は F.Schur の主対角線に現れ、対応する主列の F.vectors は対応する右不変部分空間の直交/ユニタリ基底を形成します。実数の場合、複素共役の固有値の対は、select を介して両方とも含めるか、両方とも除外する必要があります。

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

行列ペア (A, B) = (Q*S*Z', Q*T*Z') の一般化シュール因子分解 F を論理配列 select に従って再配置し、一般化シュールオブジェクト F を返します。選択された固有値は、F.S と F.T の両方の主対角線に現れ、左および右の直交/ユニタリシュールベクトルも再配置されるため、(A, B) = F.Q*(F.S, F.T)*F.Z' が依然として成り立ち、A と B の一般化固有値は F.α./F.β を用いて依然として取得できます。

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

ordschur と同様ですが、因子分解 F を上書きします。

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

ordschurと同様ですが、因子分解Fを上書きします。

SVD <: Factorization

行列 A の特異値分解 (SVD) の行列因子化タイプです。これは、対応する行列因子化関数 svd(_) の戻り値の型です。

F::SVD が因子化オブジェクトである場合、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; # 反復による分解

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

GeneralizedSVD <: Factorization

2つの行列 A と B の一般化特異値分解 (SVD) の行列因子化タイプであり、A = F.U*F.D1*F.R0*F.Q' および B = F.V*F.D2*F.R0*F.Q' となります。これは svd(_, _) の戻り値の型であり、対応する行列因子化関数です。

M×N 行列 A と P×N 行列 B に対して、

• U は M×M の直交行列です。
• V は P×P の直交行列です。
• Q は N×N の直交行列です。
• D1 は最初の K エントリに 1 がある M×(K+L) の対角行列です。
• D2 は上部右側の L×L ブロックが対角である P×(K+L) の行列です。
• R0 は最右の (K+L)×(K+L) ブロックが非特異上三角である (K+L)×N の行列です。

K+L は行列 [A; B] の有効数値ランクです。

分解を繰り返すことで、成分 U、V、Q、D1、D2、および R0 が生成されます。

F.D1 と F.D2 のエントリは関連しており、一般化 SVD の LAPACK ドキュメントおよびその下で呼び出される xGGSVD3 ルーチンで説明されています (LAPACK 3.6.0 以降)。

例

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

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

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

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

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

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

行列 A の特異値分解 (SVD) を計算し、SVD オブジェクトを返します。

因数分解 F から U、S、V および Vt は 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 は SVD に使用するアルゴリズムと LAPACK メソッドを指定します：

• alg = LinearAlgebra.DivideAndConquer()（デフォルト）：LAPACK.gesdd! を呼び出します。
• alg = LinearAlgebra.QRIteration()：LAPACK.gesvd! を呼び出します（通常は遅いですが、より正確です）。

例

julia> A = rand(4,3);

julia> F = svd(A); # 因数分解オブジェクトを保存

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

julia> U, S, V = F; # 繰り返しによる分解

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

julia> Uonly, = svd(A); # U のみを保存

julia> Uonly == U
true

svd(A, B) -> GeneralizedSVD

A と B の一般化SVDを計算し、[A;B] = [F.U * F.D1; F.V * F.D2] * F.R0 * F.Q' となる GeneralizedSVD 因子分解オブジェクト F を返します。

• U は M-by-M の直交行列です。
• V は P-by-P の直交行列です。
• Q は N-by-N の直交行列です。
• D1 は最初の K エントリに 1 がある M-by-(K+L) の対角行列です。
• D2 は上部右の L-by-L ブロックが対角行列である P-by-(K+L) の行列です。
• R0 は右端の (K+L)-by-(K+L) ブロックが非特異上三角行列である (K+L)-by-N の行列です。

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がないため、G*Aの場合はi2<=size(A,2)、A*G'の場合はi2<=size(A,1)であれば任意のサイズの行列と乗算できます。

詳細は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, k::Integer = 0)

Mの上三角行列をk番目の超対角線から返します。

例

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)

Mのk番目の上対角線から始まる上三角行列を返し、その過程で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, k::Integer = 0)

Mのk番目の上対角線から始まる下三角行列を返します。

例

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)

Mのk番目の上対角線から始まる下三角行列を返し、その過程でMを上書きします。

例

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

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

diagind(M::AbstractMatrix, k::Integer = 0, indstyle::IndexStyle = IndexLinear())
diagind(M::AbstractMatrix, indstyle::IndexStyle = IndexLinear())

行列 M の k 番目の対角線のインデックスを与える AbstractRange。オプションで、返される範囲のタイプを決定するインデックススタイルを指定できます。indstyle isa IndexLinear（デフォルト）の場合、これは AbstractRange{Integer} を返します。一方、indstyle isa IndexCartesian の場合、これは AbstractRange{CartesianIndex{2}} を返します。

k が指定されていない場合、0（主対角線に対応）であると見なされます。

参照: diag, diagm, Diagonal.

例

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

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

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

diag(M, k::Integer=0)

行列の k 番目の対角線をベクトルとして返します。

関連項目としては diagm, diagind, Diagonal, isdiag があります。

例

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

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

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

Pairの対角線とベクトルから行列を構築します。ベクトルkv.secondはkv.firstの対角線に配置されます。デフォルトでは行列は正方形で、そのサイズはkvから推測されますが、必要に応じてゼロでパディングされた非正方形のサイズm×nを最初の引数として渡すことで指定できます。繰り返しの対角線インデックス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

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

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

rank(S::SVD{<:Any, T}; atol::Real=0, rtol::Real=min(n,m)*ϵ) where {T}

SVDオブジェクトSの数値的ランクを計算します。これは、最大特異値σ₁（計算された特異値の中で最も大きい値）よりも大きい特異値の数を数えることによって行われます。これは、既存のSVD因子分解を再利用する点を除いて、デフォルトのrank(::AbstractMatrix)メソッドと同等です。atolとrtolはそれぞれ絶対許容誤差と相対許容誤差です。デフォルトの相対許容誤差はn*ϵであり、ここでnはUΣV'の最小次元のサイズ、ϵはSの要素型のepsです。

rank(A::QRPivoted{<:Any, T}; atol::Real=0, rtol::Real=min(n,m)*ϵ) where {T}

QR因子分解Aの数値的ランクを計算するには、A.factorsの対角エントリのうち、max(atol, rtol*Δ₁)より大きいものがいくつあるかを数えます。ここで、Δ₁は計算された最大のそのエントリです。これは、行列因子分解からの（数値的に）非ゼロ係数の数を数える点で、rank(::AbstractMatrix)メソッドに似ていますが、デフォルトのメソッドはQR因子分解ではなくSVDを使用します。rank(::SVD)と同様に、このメソッドも既存の行列因子分解を再利用します。

ランクを計算するためにQR因子分解を使用することは、通常、SVDを使用するのと同じ結果を生成しますが、行列が条件が悪い場合にはランクを過大評価する可能性が高くなります。また、QR因子分解を計算する方がSVDを計算するよりも一般的に速いため、パフォーマンスが懸念される場合にはこのメソッドが好まれることがあります。

atolとrtolは、それぞれ絶対許容誤差と相対許容誤差です。デフォルトの相対許容誤差はn*ϵであり、ここでnはAの最小次元のサイズ、ϵはAの要素型のepsです。

norm(A, p::Real=2)

任意の数値の iterable コンテナ A（任意の次元の配列を含む）に対して、p-ノルム（デフォルトは p=2）を計算します。これは A が対応する長さのベクトルであるかのように扱われます。

p-ノルムは次のように定義されます。

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

ここで、$a_i$ は A のエントリ、$| a_i |$ は norm の a_i のノルム、$n$ は A の長さです。p-ノルムは A のエントリの norm を使用して計算されるため、p != 2 の場合、ベクトルのベクトルの p-ノルムはブロックベクトルとしての解釈と互換性がありません。

p は任意の数値を取ることができます（すべての値が数学的に有効なベクトルノルムを生成するわけではありません）。特に、norm(A, Inf) は abs.(A) の中で最大の値を返し、norm(A, -Inf) は最小の値を返します。A が行列で p=2 の場合、これはフロベニウスノルムに相当します。

第二引数 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,<:AbstractVector}, q::Real=2)
opnorm(A::Transpose{<:Any,<:AbstractVector}, q::Real=2)

Adjoint/Transposeでラップされたベクトルの場合、Aの演算子$q$-ノルムを返します。これは、値が$p = q/(q-1)$のp-ノルムに相当します。p = q = 2のときに一致します。Aをベクトルとしてpノルムを計算するにはnormを使用してください。

ベクトル空間とその双対の間のノルムの違いは、双対性と内積の関係を保持するために生じ、結果は$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 のスキール条件数 $\kappa_S$ は、ベクトル x に関してオプションで、演算子 p-ノルムを使用して計算されます。 $\left\vert M \right\vert$ は $M$ の（要素ごとの）絶対値の行列を示し、$\left\vert M \right\vert_{ij} = \left\vert M_{ij} \right\vert$ です。 p の有効な値は 1、2、および Inf（デフォルト）です。

この量は文献ではバウアー条件数、相対条件数、または成分ごとの相対条件数としても知られています。

tr(M)

行列のトレース。Mの対角要素を合計します。

例

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

julia> tr(A)
5

det(M)

行列式。

参照: logdet および logabsdet。

例

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

julia> det(M)
2.0

一般に、det は行列式の浮動小数点近似を計算します。整数行列に対しても、通常はガウス消去法を通じて行います。Julia には整数行列式のための正確なアルゴリズム（バレイスアルゴリズム）が含まれていますが、デフォルトでは BigInt 行列に対してのみ使用されます（行列式はすぐに固定整数精度をオーバーフローするため）：

julia> det(BigInt[1 0; 2 2]) # 正確な整数行列式
2

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 を解くことで計算されます。

M が数値的逆行列を持たない場合、SingularException がスローされます。

例

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

ムーア・ペンローズ擬似逆行列を計算します。

浮動小数点要素を持つ行列 M に対しては、σ₁ が M の最大特異値であるとき、max(atol, rtol*σ₁) より大きい特異値のみを反転することによって擬似逆行列を計算することが便利です。

絶対許容誤差（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

Mのヌル空間の基底を計算します。これは、Mの特異値のうち、絶対値がmax(atol, rtol*σ₁)より小さい特異ベクトルを含むもので、ここでσ₁は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)

2つのベクトル、行列、または数のクロネッカー積を計算します。

実ベクトル v と w に対して、クロネッカー積は外積に関連しており、kron(v,w) == vec(w * transpose(v)) または w * transpose(v) == reshape(kron(v,w), (length(w), length(v))) となります。これらの式の左側と右側で v と w の順序が異なることに注意してください（列優先ストレージのため）。複素ベクトルの場合、外積 w * v' も v の共役によって異なります。

例

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

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

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

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

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

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

kron!(C, A, B)

AとBのクロネッカー積を計算し、結果をCに格納します。これはCの既存の内容を上書きします。これはkronのインプレースバージョンです。

exp(A::AbstractMatrix)

行列 A の行列指数関数を計算します。定義は次の通りです。

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

対称行列またはエルミート行列 A の場合は、固有分解（eigen）が使用され、それ以外の場合はスケーリングと平方化アルゴリズムが選択されます（[^\H05]を参照）。

例

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

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

cis(A::AbstractMatrix)

平方行列 A の exp(im*A) のより効率的な方法（特に A が Hermitian または実対称行列の場合）。

他にも cispi, sincos, exp を参照してください。

例

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

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

行列の累乗、$\exp(p\log(A))$に相当します。

例

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

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

行列の指数関数、$\exp(\log(b)A)$に相当します。

例

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

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

log(A::AbstractMatrix)

もし A に負の実固有値がない場合、A の主行列対数を計算します。すなわち、$e^X = A$ であり、すべての固有値 $\lambda$ に対して $-\pi < Im(\lambda) < \pi$ となる唯一の行列 $X$ を求めます。もし A に非正の固有値がある場合、可能な限り非主行列関数が返されます。

A が対称またはエルミートの場合、その固有分解（eigen）が使用され、A が三角行列の場合は、逆スケーリングと平方根法の改良版が使用されます（[^\AH12] および [^\AHR13] を参照）。もし A が負の固有値を持たない実数の場合、実シュア形式が計算されます。そうでない場合、複素シュア形式が計算されます。その後、[^\AHR13] の上部（準）三角アルゴリズムが上部（準）三角因子に対して使用されます。

[^\AH12]: Awad H. Al-Mohy と Nicholas J. Higham, "Improved inverse scaling and squaring algorithms for the matrix logarithm", SIAM Journal on Scientific Computing, 34(4), 2012, C153-C169. doi:10.1137/110852553

[^\AHR13]: Awad H. Al-Mohy, Nicholas J. Higham と Samuel D. Relton, "Computing the Fréchet derivative of the matrix logarithm and estimating the condition number", SIAM Journal on Scientific Computing, 35(4), 2013, C394-C410. doi:10.1137/120885991

例

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 をスローします。代わりに Complex の負の引数を使用して Complex の結果を得てください。

接頭辞演算子 √ は sqrt と同等です。

関連情報: hypot。

例

julia> sqrt(big(81))
9.0

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

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

julia> sqrt(-81 - 0.0im)  # -0.0im は分岐切断の下
0.0 - 9.0im

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

sqrt(A::AbstractMatrix)

もし A に負の実固有値がない場合、A の主な行列平方根を計算します。つまり、$X^2 = A$ となるような、正の実部を持つ固有値を持つ一意の行列 $X$ です。それ以外の場合、非主成分の平方根が返されます。

A が実対称行列またはエルミート行列である場合、その固有分解（eigen）を使用して平方根を計算します。このような行列に対して、丸め誤差のためにわずかに負に見える固有値 λ は、ゼロであるかのように扱われます。より正確には、すべての固有値が ≥ -rtol*(max |λ|) である行列は半正定値として扱われ（エルミート平方根を生成）、負の固有値はゼロと見なされます。rtol は sqrt へのキーワード引数（エルミート/実対称の場合のみ）で、size(A,1) にスケーリングされたマシン精度がデフォルトです。

それ以外の場合、平方根はBjörck-Hammarling法 <sup>[BH83]</sup> によって決定され、複素シュール形式（schur）を計算し、その後三角因子の複素平方根を計算します。実平方根が存在する場合は、実シュール形式を計算し、その後準三角因子の実平方根を計算するこの方法の拡張 <sup>[H87]</sup> が代わりに使用されます。

例

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

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

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

実数値行列 A の実数値立方根を計算します。もし T = cbrt(A) であれば、T*T*T ≈ A となります。以下に示す例を参照してください。

A が対称である場合、すなわち HermOrSym{<:Real} 型である場合は、(eigen) を使用して立方根を求めます。それ以外の場合は、p-th ルートアルゴリズムの特化版 <sup>[S03]</sup> が利用され、実数値シュール分解 (schur) を利用して立方根を計算します。

例

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

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

julia> T*T*T ≈ A
true

cos(A::AbstractMatrix)

正方行列 A の行列コサインを計算します。

A が対称またはエルミートの場合、その固有分解（eigen）を使用してコサインを計算します。それ以外の場合、コサインは exp を呼び出すことによって決定されます。

例

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

sin(A::AbstractMatrix)

正方行列 A の行列サインを計算します。

A が対称またはエルミートの場合、その固有分解（eigen）を使用してサインを計算します。そうでない場合、サインは exp を呼び出すことによって決定されます。

例

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

sincos(A::AbstractMatrix)

正方行列 A の行列サインとコサインを計算します。

例

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

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

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

tan(A::AbstractMatrix)

正方行列 A の行列タンジェントを計算します。

A が対称またはエルミートの場合、その固有分解（eigen）を使用してタンジェントを計算します。それ以外の場合、タンジェントは exp を呼び出すことによって決定されます。

例

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

sec(A::AbstractMatrix)

正方行列 A の行列セカントを計算します。

csc(A::AbstractMatrix)

正方行列 A の行列コセカントを計算します。

cot(A::AbstractMatrix)

正方行列 A の行列コタンジェントを計算します。

cosh(A::AbstractMatrix)

正方行列 A の行列双曲線コサインを計算します。

sinh(A::AbstractMatrix)

正方行列 A の行列双曲線正弦を計算します。

tanh(A::AbstractMatrix)

正方行列 A の行列双曲線正接を計算します。

sech(A::AbstractMatrix)

正方行列 A の行列双曲線セカントを計算します。

csch(A::AbstractMatrix)

正方行列 A の行列双曲線余割を計算します。

coth(A::AbstractMatrix)

正方行列 A の行列双曲線コタンジェントを計算します。

acos(A::AbstractMatrix)

正方行列 A の逆行列コサインを計算します。

A が対称またはエルミートの場合、その固有分解（eigen）を使用して逆コサインを計算します。そうでない場合、逆コサインは log と sqrt を使用して決定されます。この関数を計算するために使用される理論と対数式については、<sup>[AH16_1]</sup> を参照してください。

例

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

asin(A::AbstractMatrix)

正方行列 A の逆行列サインを計算します。

A が対称またはエルミートの場合、その固有分解（eigen）を使用して逆サインを計算します。そうでない場合、逆サインは log と sqrt を使用して決定されます。この関数を計算するために使用される理論と対数式については、<sup>[AH16_2]</sup> を参照してください。

例

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

atan(A::AbstractMatrix)

正方行列 A の逆行列タンジェントを計算します。

A が対称またはエルミートの場合、その固有分解（eigen）を使用して逆タンジェントを計算します。そうでない場合、逆タンジェントは log を使用して決定されます。この関数を計算するために使用される理論と対数式については、<sup>[AH16_3]</sup> を参照してください。

例

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 の逆双曲線行列サインを計算します。この関数を計算するために使用される理論と対数式については、<sup>[AH16_5]</sup>を参照してください。

atanh(A::AbstractMatrix)

正方行列 A の逆双曲線行列タンジェントを計算します。この関数を計算するために使用される理論と対数式については、<sup>[AH16_6]</sup>を参照してください。

asech(A::AbstractMatrix)

行列 A の逆行列双曲線セカントを計算します。

acsch(A::AbstractMatrix)

行列 A の逆行列双曲線余弦の計算を行います。

acoth(A::AbstractMatrix)

行列 A の逆行列双曲線コタンジェントを計算します。

lyap(A, C)

連続リャプノフ方程式 AX + XA' + C = 0 の解 X を計算します。ここで、A の固有値の実部はゼロではなく、2つの固有値が負の複素共役であることはありません。

例

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

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

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

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

sylvester(A, B, C)

シルベスター方程式 AX + XB + C = 0 の解 X を計算します。ここで、A、B、C は互換性のある次元を持ち、A と -B は実部が等しい固有値を持たない必要があります。

例

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

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

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

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

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

issuccess(F::Factorization)

行列の因数分解が成功したかどうかをテストします。

例

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

julia> issuccess(F)
true

issuccess(F::LU; allowsingular = false)

LU因子分解が成功したかどうかをテストします。デフォルトでは、有効だがランクが不足しているU因子を生成する因子分解は失敗と見なされます。これはallowsingular = trueを渡すことで変更できます。

例

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

julia> issuccess(F)
false

julia> issuccess(F, allowsingular = true)
true

issymmetric(A) -> Bool

行列が対称であるかどうかをテストします。

例

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

julia> issymmetric(a)
true

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

julia> issymmetric(b)
false

isposdef(A) -> Bool

行列が正定値（およびエルミート）であるかどうかを、Aのコレスキー分解を試みることでテストします。

関連情報として、isposdef!、choleskyも参照してください。

例

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

julia> isposdef(A)
true

isposdef!(A) -> Bool

行列が正定値（およびエルミート）であるかどうかを、Aのコレスキー因子分解を試みることでテストします。この過程でAが上書きされます。詳細はisposdefを参照してください。

例

julia> A = [1. 2.; 2. 50.];

julia> isposdef!(A)
true

julia> A
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  6.78233

istril(A::AbstractMatrix, k::Integer = 0) -> Bool

A が k 番目の上対角線から始まる下三角行列であるかどうかをテストします。

例

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

julia> istril(a)
false

julia> istril(a, 1)
true

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

julia> istril(c)
false

julia> istril(c, 1)
true

istriu(A::AbstractMatrix, k::Integer = 0) -> Bool

A が k 番目のスーパー対角線から始まる上三角行列であるかどうかをテストします。

例

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

julia> istriu(a)
false

julia> istriu(a, -1)
true

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

julia> istriu(c)
false

julia> istriu(c, -1)
true

isdiag(A) -> Bool

行列が対角行列であるかどうかをテストします。すなわち、iszero(A[i,j]) が i == j でない限り真であることを確認します。A が正方行列である必要はありません。正方行列であることも確認したい場合は、size(A, 1) == size(A, 2) をチェックする必要があります。

例

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

julia> isdiag(a)
false

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

julia> isdiag(b)
true

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

julia> isdiag(c)
true

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

julia> isdiag(d)
false

ishermitian(A) -> Bool

行列がエルミートかどうかをテストします。

例

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

julia> ishermitian(a)
true

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

julia> ishermitian(b)
true

transpose(A)

遅延転置。返されたオブジェクトを変更すると、適切に A が変更されます。しばしば、しかし常にではなく、Transpose(A) を返します。ここで Transpose は遅延転置ラッパーです。この操作は再帰的であることに注意してください。

この操作は線形代数の使用を意図しています - 一般的なデータ操作については permutedims を参照してください。これは再帰的ではありません。

例

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

julia> B = transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 3  0
 2  0

julia> B isa Transpose
true

julia> transpose(B) === A # 転置の転置は親をアンラップします
true

julia> Transpose(B) # ただし、コンストラクタは常にその引数をラップします
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
 3  2
 0  0

julia> B[1,2] = 4; # Bを変更するとAも自動的に変更されます

julia> A
2×2 Matrix{Int64}:
 3  2
 4  0

複素行列の場合、adjoint 操作は共役転置に相当します。

julia> A = reshape([Complex(x, x) for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

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

AbstractVector の transpose は行ベクトルです：

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

julia> transpose(v) # 行ベクトルを返します
1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> transpose(v) * v # 内積を計算します
14

行列の行列の場合、個々のブロックは再帰的に操作されます：

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

julia> D = reshape([C, 2C, 3C, 4C], 2, 2) # ブロック行列を構築します
2×2 Matrix{Matrix{Int64}}:
 [1 3; 2 4]  [3 9; 6 12]
 [2 6; 4 8]  [4 12; 8 16]

julia> transpose(D) # ブロックは再帰的に転置されます
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 2; 3 4]   [2 4; 6 8]
 [3 6; 9 12]  [4 8; 12 16]

transpose(F::Factorization)

因子分解 F の遅延転置。デフォルトでは TransposeFactorization を返しますが、実数の eltype を持つ Factorization の場合は AdjointFactorization を返します。

transpose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

行列 A を転置し、行列 X に格納します。size(X) は size(transpose(A)) と等しくなければなりません。必要に応じて、X の rowval と nzval のサイズ変更以外に追加のメモリは割り当てられません。

halfperm! を参照してください。

transpose!(dest,src)

配列 src を転置し、その結果を事前に確保された配列 dest に格納します。dest のサイズは (size(src,2),size(src,1)) に対応している必要があります。インプレースの転置はサポートされておらず、src と dest が重複するメモリ領域を持つ場合、予期しない結果が生じる可能性があります。

例

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

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
 0+0im  0+0im
 0+0im  0+0im

julia> transpose!(B, A);

julia> B
2×2 Matrix{Complex{Int64}}:
 3+2im  8+7im
 9+2im  4+6im

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

転置

基になる線形代数オブジェクト、通常は AbstractVector/AbstractMatrix の転置ビューのための遅延ラッパー型です。通常、Transpose コンストラクタは直接呼び出すべきではなく、代わりに transpose を使用してください。ビューを具現化するには copy を使用します。

この型は線形代数の使用を意図しています - 一般的なデータ操作については permutedims を参照してください。

例

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

julia> Transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 2  0
 3  0

TransposeFactorization

基になる Factorization オブジェクトの転置のための遅延ラッパー型。通常、TransposeFactorization コンストラクタは直接呼び出すべきではなく、代わりに transpose(:: Factorization) を使用してください。

A'
adjoint(A)

遅延随伴（共役転置）。adjointは要素に再帰的に適用されることに注意してください。

数値型の場合、adjointは複素共役を返し、したがって実数に対しては恒等関数と同等です。

この操作は線形代数の使用を意図しています - 一般的なデータ操作についてはpermutedimsを参照してください。

例

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

julia> B = A' # 同等に 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 # 随伴の随伴は親を解きほぐす
true

julia> Adjoint(B) # ただし、コンストラクタは常にその引数をラップします
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; # Bを変更するとAも自動的に変更されます

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 # 内積を計算します、同等に 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 に格納します。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の2つのFloat64行列を掛け算します。ここで、n = 4096です。基盤となるBLASが複数のスレッドを使用している場合、より高いフロップレートが実現されます。BLASスレッドの数はBLAS.set_num_threads(n)で設定できます。

キーワード引数eltypeが提供されると、peakflopsはピークフロップレートを計算するためにeltype型の要素を持つ行列を構築します。

デフォルトでは、peakflopsは3回の試行から最良のタイミングを使用します。ntrialsキーワード引数が提供されると、peakflopsはその数の試行を使用して最良のタイミングを選択します。

キーワード引数parallelがtrueに設定されている場合、peakflopsはすべてのワーカープロセッサで並列に実行されます。全体の並列コンピュータのフロップレートが返されます。並列で実行する際は、1つのBLASスレッドのみが使用されます。引数nは、各プロセッサで解決される問題のサイズを指します。

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

正方行列 A のエルミート部分を返します。これは (A + A') / 2 と定義され、Hermitian 行列として返されます。実数行列 A に対しては、これは A の対称部分としても知られています。また、時には「演算子の実部」とも呼ばれます。オプションの引数 uplo は、Hermitian ビューの対応する引数を制御します。実数行列の場合、後者は Symmetric ビューに相当します。

対応するインプレース操作については、hermitianpart! も参照してください。

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

正方行列 A をそのエルミート部分 (A + A') / 2 でインプレースで上書きし、Hermitian(A, uplo) を返します。実数行列 A に対して、これは A の対称部分としても知られています。

対応するアウトオブプレース操作については、hermitianpart を参照してください。

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

行列 A の要素を隣接転置を用いて B に効率的にコピーします:

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

要素 B[ir_dest, jr_dest] は上書きされます。さらに、インデックス範囲パラメータは length(ir_dest) == length(jr_src) および length(jr_dest) == length(ir_src) を満たす必要があります。

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

行列 A の要素を転置しながら B に効率的にコピーします:

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

要素 B[ir_dest, jr_dest] は上書きされます。さらに、インデックス範囲のパラメータは length(ir_dest) == length(jr_src) および length(jr_dest) == length(ir_src) を満たす必要があります。

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

行列 M の要素を、文字パラメータ tM に基づいて B に効率的にコピーします。

要素 B[ir_dest, jr_dest] は上書きされます。さらに、インデックス範囲パラメータは length(ir_dest) == length(jr_src) および length(jr_dest) == length(ir_src) を満たす必要があります。

また、copyto! および copy_adjoint! も参照してください。

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

行列-行列または行列-ベクトルの積 $A B$ を計算し、その結果を Y に格納し、既存の Y の値を上書きします。Y は A または B とエイリアスされてはいけません。

例

julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; Y = similar(B);

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

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

julia> Y == A * B
true

実装

カスタム行列およびベクトルタイプの場合、可能であれば3引数の mul! を直接実装するのではなく、5引数の mul! を実装することをお勧めします。

mul!(C, A, B, α, β) -> C

行列-行列または行列-ベクトルの組み合わせのインプレース乗算加算 $A B α + C β$。結果は C に上書きされて保存されます。 C は A または B とエイリアスされてはいけません。

例

julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; C = [1.0 2.0; 3.0 4.0];

julia> α, β = 100.0, 10.0;

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

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

julia> C_original = [1.0 2.0; 3.0 4.0]; # C の元の値のコピー

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

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

スカラー a で配列 B をスケーリングし、B をその場で上書きします。スカラーを右から掛けるには rmul! を使用してください。スケーリング操作は、a と B の要素との間の乗算 * の意味論を尊重します。特に、これは NaN や ±Inf のような非有限数を含む乗算にも適用されます。

例

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

julia> lmul!(2, B)
2×2 Matrix{Int64}:
 2  4
 6  8

julia> lmul!(0.0, [Inf])
1-element Vector{Float64}:
 NaN

lmul!(A, B)

行列の積 $AB$ を計算し、B を上書きして結果を返します。ここで、A は特別な行列タイプでなければならず、例えば Diagonal、UpperTriangular または LowerTriangular、または何らかの直交タイプである必要があります。詳細は QR を参照してください。

例

julia> B = [0 1; 1 0];

julia> A = UpperTriangular([1 2; 0 3]);

julia> lmul!(A, B);

julia> B
2×2 Matrix{Int64}:
 2  1
 3  0

julia> B = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> lmul!(F.Q, B)
2×2 Matrix{Float64}:
 3.0  4.0
 1.0  2.0

rmul!(A::AbstractArray, b::Number)

スカラー b で配列 A をスケーリングし、A をその場で上書きします。スカラーを左から掛けるには lmul! を使用してください。スケーリング操作は、A の要素と b の間の乗算 * の意味論を尊重します。特に、これは NaN や ±Inf のような非有限数を含む乗算にも適用されます。

例

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

julia> rmul!(A, 2)
2×2 Matrix{Int64}:
 2  4
 6  8

julia> rmul!([NaN], 0.0)
1-element Vector{Float64}:
 NaN

rmul!(A, B)

行列の積 $AB$ を計算し、A を上書きして結果を返します。ここで、B は特別な行列タイプでなければなりません。例えば、Diagonal、UpperTriangular または LowerTriangular のような、または QR のような何らかの直交タイプです。

例

julia> A = [0 1; 1 0];

julia> B = UpperTriangular([1 2; 0 3]);

julia> rmul!(A, B);

julia> A
2×2 Matrix{Int64}:
 0  3
 1  2

julia> A = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> rmul!(A, F.Q)
2×2 Matrix{Float64}:
 2.0  1.0
 4.0  3.0

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

A \ Bをインプレースで計算し、結果をYに格納して返します。

引数Aは行列であってはなりません。むしろ、行列の代わりに因子分解オブジェクト（例えば、factorizeやcholeskyによって生成されたもの）である必要があります。これは、因子分解自体が高コストであり、通常はメモリを割り当てるためです（ただし、lu!などを介してインプレースで行うことも可能です）。ldiv!を必要とするパフォーマンスクリティカルな状況では、通常、Aの因子分解に対する細かい制御も必要です。

例

julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];

julia> B = [1, 2.5, 3];

julia> Y = similar(B); # 読み取る必要がないため、similarを使用

julia> ldiv!(Y, qr(A), B); # さらに割り当てを減らすためにqr!(A)を試すこともできます

julia> Y ≈ A \ B
true

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> B = [1, 2.5, 3];

julia> B0 = copy(B); # テストを容易にするためのバックアップコピー

julia> ldiv!(lu(A), B); # より少ない割り当てを実現するためにlu!(A)を試すこともできます

julia> B ≈ A \ B0
true

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

スカラー a で配列 B の各エントリを割り算し、B をその場で上書きします。スカラーを右から割り算するには rdiv! を使用してください。

例

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

julia> ldiv!(2.0, B)
2×2 Matrix{Float64}:
 0.5  1.0
 1.5  2.0

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

A \ Bをガウス消去法による部分ピボットを用いてインプレースで計算し、結果をBに格納して返します。この過程で、Aの対角成分も上書きされます。

rdiv!(A, B)

A / Bをインプレースで計算し、結果を格納するためにAを上書きします。

引数Bは行列であってはなりません。むしろ、行列の代わりに因子分解オブジェクト（例えば、factorizeやcholeskyによって生成されたもの）であるべきです。これは、因子分解自体が高コストであり、通常はメモリを割り当てるためです（ただし、例えばlu!を介してインプレースで行うことも可能です）。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 要素を c*X + s*Y で上書きし、配列 Y の最初の n 要素を -conj(s)*X + c*Y で上書きします。ストライドはそれぞれ incx と incy です。X と Y を返します。

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

配列 X の最初の n 要素を a*X で上書きし、ストライドは incx です。X を返します。

n と incx が指定されていない場合は、length(X) と stride(X,1) が使用されます。

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

配列 X の最初の n 要素をストライド incx で a でスケーリングした X を返します。

n と incx が指定されていない場合、length(X) と stride(X,1) が使用されます。

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

ストライド incx を持つ配列 X の n 要素をストライド incy を持つ配列 Y にコピーします。Y を返します。

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

incxのストライドを持つ配列Xのn要素と、incyのストライドを持つ配列Yのn要素からなる2つのベクトルのドット積。

例

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)

2つの複素ベクトルのためのドット関数で、ストライド incx を持つ配列 X の n 要素と、ストライド incy を持つ配列 U の n 要素から成り、最初のベクトルを共役します。

例

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

nrm2(n, X, incx)

配列 X の n 要素からなるベクトルの 2-ノルムで、ストライドは incx です。

例

julia> BLAS.nrm2(4, fill(1.0, 8), 2)
2.0

julia> BLAS.nrm2(1, fill(1.0, 8), 2)
1.0

asum(n, X, incx)

配列 X の最初の n 要素の大きさの合計で、ストライドは incx です。

実数配列の場合、大きさは絶対値です。複素数配列の場合、大きさは実部の絶対値と虚部の絶対値の合計です。

例

julia> BLAS.asum(5, fill(1.0im, 10), 2)
5.0

julia> BLAS.asum(2, fill(1.0im, 10), 5)
2.0

iamax(n, dx, incx)
iamax(dx)

dxの最大絶対値を持つ要素のインデックスを見つけます。nはdxの長さで、incxはストライドです。nとincxが指定されていない場合、デフォルト値n=length(dx)およびincx=stride1(dx)が仮定されます。

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

ベクトル y を alpha*A*x + beta*y または alpha*A'x + beta*y に更新します tA。alpha と beta はスカラーです。更新された y を返します。

gemv(tA, alpha, A, x)

alpha*A*x または alpha*A'x を tA に従って返します。alpha はスカラーです。

gemv(tA, A, x)

A*x または A'x を tA に従って返します。

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

ベクトル y を alpha*A*x + beta*y または alpha*A'*x + beta*y に更新します。これは trans に従います。行列 A は、kl の下三角成分と ku の上三角成分を持つ、次元 m と size(A,2) の一般的なバンド行列です。alpha と beta はスカラーです。更新された y を返します。

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

trans に従って alpha*A*x または alpha*A'*x を返します。行列 A は、kl の下三角対角線と ku の上三角対角線を持つ、次元 m と size(A,2) の一般的なバンド行列であり、alpha はスカラーです。

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

ベクトル y を alpha*A*x + beta*y として更新します。A はエルミート行列であると仮定します。A の ul 三角部分のみが使用されます。alpha と beta はスカラーです。更新された y を返します。

hemv(ul, alpha, A, x)

alpha*A*xを返します。Aはエルミート行列であると仮定されます。Aのul三角部分のみが使用されます。alphaはスカラーです。

hemv(ul, A, x)

A*xを返します。Aはエルミート行列であると仮定されます。Aのul三角部分のみが使用されます。

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

ベクトル y を α*A*x + β*y として更新します。ここで、A はパック形式 AP で提供されるエルミート行列です。

uplo = 'U' の場合、配列 AP はエルミート行列の上三角部分を列ごとに順番に格納している必要があります。したがって、AP[1] には A[1, 1] が含まれ、AP[2] と AP[3] にはそれぞれ A[1, 2] と A[2, 2] が含まれます。

uplo = 'L' の場合、配列 AP はエルミート行列の下三角部分を列ごとに順番に格納している必要があります。したがって、AP[1] には A[1, 1] が含まれ、AP[2] と AP[3] にはそれぞれ A[2, 1] と A[3, 1] が含まれます。

スカラー入力 α と β は複素数または実数でなければなりません。

配列入力 x、y、および AP はすべて ComplexF32 または ComplexF64 型でなければなりません。

更新された y を返します。

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

ベクトル y を alpha*A*x + beta*y として更新します。A は対称であると仮定されます。A の ul 三角形のみが使用されます。alpha と beta はスカラーです。更新された y を返します。

symv(ul, alpha, A, x)

alpha*A*xを返します。Aは対称であると仮定されます。Aのul三角形のみが使用されます。alphaはスカラーです。

symv(ul, A, x)

A*xを返します。Aは対称であると仮定されます。Aのul三角形のみが使用されます。

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

ベクトル y を alpha*A*x + beta*y として更新します。ここで、A は引数 A に格納された k 個の上対角線を持つ対称バンド行列で、次数は size(A,2) です。A のストレージレイアウトは、https://www.netlib.org/lapack/explore-html/ の参照 BLAS モジュール、レベル 2 BLAS で説明されています。A の uplo 三角形のみが使用されます。

更新された y を返します。

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

alpha*A*xを返します。ここで、Aは引数Aに格納されたk個の上対角線を持つ順対称バンド行列で、順序はsize(A,2)です。Aのuplo三角形のみが使用されます。

sbmv(uplo, k, A, x)

A*xを返します。ここで、Aは引数Aに格納されたk個の上対角線を持つ対称バンド行列で、次数はsize(A,2)です。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 の解である b を上書きするか、tA と ul によって決定される他の2つのバリアントのいずれかを上書きします。 dA は、対角値が読み取られるか、すべてが1であると仮定されるかを決定します。 更新された b を返します。

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

A*x = b の解、または tA と ul によって決定される他の2つのバリアントのいずれかを返します。 dA は、対角値が読み取られるか、すべてが1であると仮定されるかを決定します。

ger!(alpha, x, y, A)

ベクトル x と y を用いて行列 A のランク-1 更新を行います。式は alpha*x*y' + A です。