Linear Algebra

NoPivot

ピボットは実行されません。LU因子分解などの行列因子分解は、ピボットなしでは失敗する可能性があり、丸め誤差に対して浮動小数点行列に対して数値的に不安定である可能性もあります。このピボット戦略は主に教育的目的で役立ちます。

RowNonZero

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

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

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

RowMaximum

残りの行の中で最大の絶対値を持つ要素がピボット要素として選ばれます。これは浮動小数点行列のLU因子分解のデフォルト戦略であり、時には「部分ピボッティング」アルゴリズムと呼ばれます。

行列の要素型は、absメソッドを許容し、その結果の型は<メソッドを許容しなければなりません。

ColumnNorm

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

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

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

行列の乗算。

例

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

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

3つまたは4つの行列の連鎖乗算は、配列のサイズに基づいて最も効率的な順序で行われます。つまり、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フィールドは、特異値の位置を示します。

PosDefException

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

ZeroPivotException <: Exception

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

RankDeficientException

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

LAPACK例外

直接的に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 の間で、A*y の中間結果を保存せずに一般化された内積 dot(x, 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の便利な因数分解を計算します。factorizeは、Aが一般的な行列として渡された場合、対称/三角形/etc.であるかどうかを確認します。factorizeは、Aの各要素をチェックして、各特性を確認/除外します。対称性/三角形構造を除外できるとすぐに短絡します。返り値は、複数のシステムを効率的に解くために再利用できます。例えば：A=factorize(A); x=A\b; y=A\C。

例えば、factorizeがエルミート正定値行列に対して呼び出されると、factorizeはコレスキー因数分解を返します。

例

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 は A 自体が Hermitian でない限り（例えば A == adjoint(A) の場合） Hlower と等しくなりません。

対角線のすべての非実部は無視されます。

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

LowerTriangular(A::AbstractMatrix)

行列 A の LowerTriangular ビューを構築します。

例

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

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

UpperTriangular(A::AbstractMatrix)

行列 A の UpperTriangular ビューを構築します。

例

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

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

UnitLowerTriangular(A::AbstractMatrix)

行列 A の UnitLowerTriangular ビューを構築します。このようなビューは、A の eltype の oneunit を対角線上に持ちます。

例

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

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

UnitUpperTriangular(A::AbstractMatrix)

行列 A の UnitUpperTriangular ビューを構築します。このようなビューは、A の eltype の oneunit を対角線上に持ちます。

例

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

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

UpperHessenberg(A::AbstractMatrix)

行列 A の UpperHessenberg ビューを構築します。最初の副対角線の下にある A のエントリは無視されます。

H \ b、det(H)、および類似の効率的なアルゴリズムが実装されています。

任意の行列を類似の上部ヘッセンベルク行列に因数分解する hessenberg 関数も参照してください。

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

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

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

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

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

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

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

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

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

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

例

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

julia> F = lu(A);

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

julia> lu!(F, B);

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

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

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

例

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

julia> F = lu!(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L 因子:
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; # destructuring via iteration

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因子のランクは1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
置換:
4要素のベクトル{Int64}:
 4
 2
 3
 1

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

julia> l, u = C; # 反復による分解

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

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

密な対称正定値行列 A のコレスキー分解を計算し、Cholesky 分解を返します。行列 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因子:
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 は、ランクを決定するための許容誤差を決定します。負の値の場合、許容誤差は機械精度です。

構築時の丸め誤差により、行列 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因子のランクは1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
置換:
4要素のベクトル{Int64}:
 4
 2
 3
 1

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

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

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

cholesky(A::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 順序の代わりに）。

例

次の例では、使用されるフィル削減置換は [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 または Symmetric/ Hermitian の SparseMatrixCSC のビューでなければなりません。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 因子:
3×3 UnitLowerTriangular{Float64, SymTridiagonal{Float64, Vector{Float64}}}:
 1.0        ⋅         ⋅
 0.333333  1.0        ⋅
 0.0       0.545455  1.0
D 因子:
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 です。

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

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

ldlt!(S::SymTridiagonal) -> LDLt

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

例

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

julia> ldltS = ldlt!(S);

julia> ldltS === S
false

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

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

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

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

QR <: Factorization

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

\[A = Q R\]

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

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

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

オブジェクトには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)のベクトルで、係数$au_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 因子:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q 因子: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}

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

julia> l, q = S; # 反復による分解

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

lq(A) -> S::LQ

行列 A の LQ 分解を計算します。分解の下三角成分は、LQ オブジェクト S から S.L を介して取得でき、直交/ユニタリ成分は S.Q を介して取得できるため、A ≈ S.L*S.Q となります。

分解を繰り返すことで、成分 S.L と S.Q を得ることができます。

LQ 分解は transpose(A) の QR 分解であり、行数よりも列数が多いが行ランクが完全な方程式系に対して最小ノルム解 lq(A) \ b を計算するために有用です。

例

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 は内部的に Symmetric(A) でラップされます
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D 因子:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U 因子:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
置換:
2-element Vector{Int64}:
 1
 2

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

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

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

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

対称行列またはエルミート行列 A のバンチ-カウフマン <sup>[Bunch1977]</sup> 分解を P'*U*D*U'*P または P'*L*D*L'*P として計算し、A に格納されている三角形に応じて 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; # 反復による分解

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{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の固有値を返します。固有値の下限と上限を指定することで、固有値のサブセットのみを計算することが可能です。

例

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

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 factor: 3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}
H factor:
3×3 UpperHessenberg{Float64, Matrix{Float64}}:
  4.0      -11.3137       -1.41421
 -5.65685    5.0           2.0
   ⋅        -8.88178e-16   1.0

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

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

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

hessenberg!(A) -> ヘッセンベルグ

hessenberg! は hessenberg と同じですが、コピーを作成するのではなく、入力 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因子:
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> 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

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 のシュール分解を計算します。 (準)三角シュール因子は、F という Schur オブジェクトから 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）因子分解を計算します。(準)三角シュール因子は、F という Schur オブジェクトから 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 = DivideAndConquer() の場合、分割統治アルゴリズムが SVD の計算に使用されます。別の（通常は遅いがより正確な）オプションは alg = QRIteration() です。

例

julia> A = rand(4,3);

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

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

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

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

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

julia> Uonly == U
true

svd(A, B) -> GeneralizedSVD

A と B の一般化 SVD を計算し、[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)

行列の上三角部分。

例

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

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

triu(M, k::Integer)

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

例

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

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

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

triu!(M)

行列の上三角を取得し、その過程で M を上書きします。詳細は triu を参照してください。

triu!(M, k::Integer)

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)

行列の下三角部分。

例

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

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

tril(M, k::Integer)

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

例

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

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

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

tril!(M)

行列の下三角を取得し、その過程で M を上書きします。詳細は tril を参照してください。

tril!(M, k::Integer)

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 が IndexLinear (デフォルト) の場合、これは AbstractRange{Integer} を返します。一方、indstyle が IndexCartesian の場合、これは AbstractRange{CartesianIndex{2}} を返します。

k が指定されていない場合、0 (主対角線に対応) と見なされます。

参照: diag, diagm, Diagonal.

例

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

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

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

diag(M, k::Integer=0)

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

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

例

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

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

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

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

`diagm` はフル行列を構築します。ストレージ効率の良いバージョンで高速な算術演算を希望する場合は、[`Diagonal`](@ref)、[`Bidiagonal`](@ref)、[`Tridiagonal`](@ref)、および [`SymTridiagonal`](@ref) を参照してください。

# 例

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

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

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

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

ベクトルの要素を対角要素とする行列を構築します。デフォルトでは、行列は正方形で、そのサイズは length(v) によって与えられますが、最初の引数として m,n を渡すことで非正方形のサイズ m×n を指定することができます。

例

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

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

QR分解のランクを返します。

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

行列 S のランクを QR 分解を用いて計算します。tol より小さい値はゼロと見なされます。SPQR のマニュアルを参照してください。

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

行列の数値的ランクを計算するには、svdvals(A) の出力のうち、max(atol, rtol*σ₁) より大きいものの数を数えます。ここで、σ₁ は A の計算された最大特異値です。atol と rtol はそれぞれ絶対許容誤差と相対許容誤差です。デフォルトの相対許容誤差は n*ϵ であり、ここで n は A の最小次元のサイズ、ϵ は A の要素型の eps です。

例

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

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

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

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

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

norm(A, p::Real=2)

任意の数値（または norm が定義されている任意の要素型）の 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

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)

行列の逆行列。行列 M と N の積が単位行列 I になるような行列 N を計算します。これは左除算 N = M \ I を解くことによって計算されます。

例

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

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

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

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

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

浮動小数点要素を持つ行列 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 をスローします。代わりに複素数の負の引数を使用してください。sqrt は負の実数軸に沿った分岐切断を持つことに注意してください。

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

関連項目: hypot。

例

julia> sqrt(big(81))
9.0

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

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

julia> sqrt(-81 - 0.0im)  # -0.0im は分岐切断の下にあります
0.0 - 9.0im

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

sqrt(A::AbstractMatrix)

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

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

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

例

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 根アルゴリズム ^[S03] が利用され、実数値シュール分解 (schur) を利用して立方根を計算します。

例

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

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

julia> T*T*T ≈ A
true

cos(A::AbstractMatrix)

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

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

例

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

sin(A::AbstractMatrix)

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

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

例

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

sincos(A::AbstractMatrix)

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

例

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

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

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

tan(A::AbstractMatrix)

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

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

例

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

sec(A::AbstractMatrix)

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

csc(A::AbstractMatrix)

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

cot(A::AbstractMatrix)

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

cosh(A::AbstractMatrix)

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

sinh(A::AbstractMatrix)

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

tanh(A::AbstractMatrix)

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

sech(A::AbstractMatrix)

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

csch(A::AbstractMatrix)

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

coth(A::AbstractMatrix)

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

acos(A::AbstractMatrix)

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

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

例

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

asin(A::AbstractMatrix)

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

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

例

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

atan(A::AbstractMatrix)

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

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

例

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

asec(A::AbstractMatrix)

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

acsc(A::AbstractMatrix)

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

acot(A::AbstractMatrix)

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

acosh(A::AbstractMatrix)

正方行列 A の逆双曲線行列コサインを計算します。この関数を計算するために使用される理論と対数式については、^[AH16_4]を参照してください。

asinh(A::AbstractMatrix)

正方行列 A の逆双曲線行列サインを計算します。この関数を計算するために使用される理論と対数式については、^[AH16_5]を参照してください。

atanh(A::AbstractMatrix)

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

asech(A::AbstractMatrix)

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

acsch(A::AbstractMatrix)

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

acoth(A::AbstractMatrix)

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

lyap(A, C)

連続リャプノフ方程式 AX + XA' + C = 0 の解 X を計算します。ここで、A の固有値の実部がゼロでないこと、かつ二つの固有値が負の複素共役でないことが条件です。

例

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

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

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

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

sylvester(A, B, C)

シルベスター方程式 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

随伴

基になる線形代数オブジェクト、通常は 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> X = [1; 2.5; 3];

julia> Y = zero(X);

julia> ldiv!(Y, qr(A), X);

julia> Y ≈ A\X
true

ldiv!(A, B)

A \ B をインプレースで計算し、結果を B に上書きします。

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

例

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

julia> X = [1; 2.5; 3];

julia> Y = copy(X);

julia> ldiv!(qr(A), X);

julia> X ≈ A\Y
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をc*X + s*Yで上書きし、Yを-conj(s)*X + c*Yで上書きします。これは、ストライドincxを持つ配列Xの最初のn要素と、ストライドincyを持つ配列Yの最初のn要素に対して行われます。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 でスケーリングします。

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

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

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

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

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)

複素ベクトルの2つのドット関数で、配列 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)

alpha*A*x または alpha*A'*x を trans に従って返します。行列 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)

bをA*x = 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 です。

her!(uplo, alpha, x, A)

複素配列専用のメソッド。ベクトル x を用いてエルミート行列 A のランク1更新を行います。更新は alpha*x*x' + A です。uplo は A のどちらの三角形が更新されるかを制御します。A を返します。

syr!(uplo, alpha, x, A)

ベクトル x を用いて対称行列 A のランク1更新を行います。これは alpha*x*transpose(x) + A です。uplo は A のどちらの三角形が更新されるかを制御します。A を返します。

spr!(uplo, α, x, AP)

行列 A を A+α*x*x' として更新します。ここで、A はパック形式の対称行列であり、x はベクトルです。

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

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

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

配列入力 x と AP はすべて Float32 または Float64 型でなければなりません。更新された AP を返します。

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

指定された uplo の C の下三角または上三角部分を alpha*A*B + beta*C または tA と tB に応じた他のバリアントで更新します。更新された C を返します。

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

指定された uplo の A*B の下三角または上三角部分、または tA と tB に応じた他の3つのバリアントを返します。

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

指定された uplo の A*B の下三角または上三角部分、または tA と tB に応じた他の3つのバリアントを返します。