Linear Algebra
多次元配列のサポートに加えて、Juliaは多くの一般的で便利な線形代数操作のネイティブ実装を提供しており、using LinearAlgebra
で読み込むことができます。tr
、det
、およびinv
などの基本操作がすべてサポートされています。
julia> A = [1 2 3; 4 1 6; 7 8 1]
3×3 Matrix{Int64}:
1 2 3
4 1 6
7 8 1
julia> tr(A)
3
julia> det(A)
104.0
julia> inv(A)
3×3 Matrix{Float64}:
-0.451923 0.211538 0.0865385
0.365385 -0.192308 0.0576923
0.240385 0.0576923 -0.0673077
固有値や固有ベクトルを見つけるなど、他の便利な操作もあります:
julia> A = [-4. -17.; 2. 2.]
2×2 Matrix{Float64}:
-4.0 -17.0
2.0 2.0
julia> eigvals(A)
2-element Vector{ComplexF64}:
-1.0 - 5.0im
-1.0 + 5.0im
julia> eigvecs(A)
2×2 Matrix{ComplexF64}:
0.945905-0.0im 0.945905+0.0im
-0.166924+0.278207im -0.166924-0.278207im
さらに、Juliaは多くの factorizations を提供しており、これを使用することで線形方程式の解法や行列の指数計算などの問題を、パフォーマンスやメモリの理由からより適した形に前因子分解することで高速化できます。詳細については、factorize
のドキュメントを参照してください。例として:
julia> A = [1.5 2 -4; 3 -1 -6; -10 2.3 4]
3×3 Matrix{Float64}:
1.5 2.0 -4.0
3.0 -1.0 -6.0
-10.0 2.3 4.0
julia> factorize(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
3×3 Matrix{Float64}:
1.0 0.0 0.0
-0.15 1.0 0.0
-0.3 -0.132196 1.0
U factor:
3×3 Matrix{Float64}:
-10.0 2.3 4.0
0.0 2.345 -3.4
0.0 0.0 -5.24947
A
がエルミートでなく、対称でも三角行列でもトリディアゴナルでもバイダイゴナルでもないため、LU因子分解が私たちができる最善の方法かもしれません。次と比較してください:
julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Matrix{Float64}:
1.5 2.0 -4.0
2.0 -1.0 -3.0
-4.0 -3.0 5.0
julia> factorize(B)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
3×3 Tridiagonal{Float64, Vector{Float64}}:
-1.64286 0.0 ⋅
0.0 -2.8 0.0
⋅ 0.0 5.0
U factor:
3×3 UnitUpperTriangular{Float64, Matrix{Float64}}:
1.0 0.142857 -0.8
⋅ 1.0 -0.6
⋅ ⋅ 1.0
permutation:
3-element Vector{Int64}:
1
2
3
ここで、JuliaはB
が実際に対称であることを検出し、より適切な因子分解を使用しました。特定の性質を持つことが知られている行列に対して、より効率的なコードを書くことが可能な場合がよくあります。例えば、それが対称であるか、または三重対角である場合です。Juliaは、これらの特性を持つ行列に「タグ」を付けるための特別な型を提供しています。例えば:
julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Matrix{Float64}:
1.5 2.0 -4.0
2.0 -1.0 -3.0
-4.0 -3.0 5.0
julia> sB = Symmetric(B)
3×3 Symmetric{Float64, Matrix{Float64}}:
1.5 2.0 -4.0
2.0 -1.0 -3.0
-4.0 -3.0 5.0
sB
は (実数) 対称行列としてタグ付けされているため、固有因子分解や行列ベクトル積の計算など、後で行う可能性のある操作において、半分だけを参照することで効率を見出すことができます。例えば:
julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Matrix{Float64}:
1.5 2.0 -4.0
2.0 -1.0 -3.0
-4.0 -3.0 5.0
julia> sB = Symmetric(B)
3×3 Symmetric{Float64, Matrix{Float64}}:
1.5 2.0 -4.0
2.0 -1.0 -3.0
-4.0 -3.0 5.0
julia> x = [1; 2; 3]
3-element Vector{Int64}:
1
2
3
julia> sB\x
3-element Vector{Float64}:
-1.7391304347826084
-1.1086956521739126
-1.4565217391304346
\
演算子はここで線形解を実行します。左除算演算子は非常に強力で、あらゆる種類の線形方程式系を解決するのに十分柔軟で、コンパクトで読みやすいコードを書くのが簡単です。
Special matrices
Matrices with special symmetries and structures は線形代数でよく見られ、さまざまな行列因子分解に頻繁に関連しています。Juliaは、特定の行列タイプに特化したルーチンを使用して高速計算を可能にする特別な行列タイプの豊富なコレクションを特徴としています。
以下の表は、Juliaで実装されている特別な行列の種類と、それらに対するLAPACKのさまざまな最適化されたメソッドへのフックが利用可能かどうかをまとめたものです。
Type | Description |
---|---|
Symmetric | Symmetric matrix |
Hermitian | Hermitian matrix |
UpperTriangular | Upper triangular matrix |
UnitUpperTriangular | Upper triangular matrix with unit diagonal |
LowerTriangular | Lower triangular matrix |
UnitLowerTriangular | Lower triangular matrix with unit diagonal |
UpperHessenberg | Upper Hessenberg matrix |
Tridiagonal | Tridiagonal matrix |
SymTridiagonal | Symmetric tridiagonal matrix |
Bidiagonal | Upper/lower bidiagonal matrix |
Diagonal | Diagonal matrix |
UniformScaling | Uniform scaling operator |
Elementary operations
Matrix type | + | - | * | \ | Other functions with optimized methods |
---|---|---|---|---|---|
Symmetric | MV | inv , sqrt , cbrt , exp | |||
Hermitian | MV | inv , sqrt , cbrt , exp | |||
UpperTriangular | MV | MV | inv , det , logdet | ||
UnitUpperTriangular | MV | MV | inv , det , logdet | ||
LowerTriangular | MV | MV | inv , det , logdet | ||
UnitLowerTriangular | MV | MV | inv , det , logdet | ||
UpperHessenberg | MM | inv , det | |||
SymTridiagonal | M | M | MS | MV | eigmax , eigmin |
Tridiagonal | M | M | MS | MV | |
Bidiagonal | M | M | MS | MV | |
Diagonal | M | M | MV | MV | inv , det , logdet , / |
UniformScaling | M | M | MVS | MVS | / |
伝説:
Key | Description |
---|---|
M (matrix) | An optimized method for matrix-matrix operations is available |
V (vector) | An optimized method for matrix-vector operations is available |
S (scalar) | An optimized method for matrix-scalar operations is available |
Matrix factorizations
Matrix type | LAPACK | eigen | eigvals | eigvecs | svd | svdvals |
---|---|---|---|---|---|---|
Symmetric | SY | ARI | ||||
Hermitian | HE | ARI | ||||
UpperTriangular | TR | A | A | A | ||
UnitUpperTriangular | TR | A | A | A | ||
LowerTriangular | TR | A | A | A | ||
UnitLowerTriangular | TR | A | A | A | ||
SymTridiagonal | ST | A | ARI | AV | ||
Tridiagonal | GT | |||||
Bidiagonal | BD | A | A | |||
Diagonal | DI | A |
伝説:
Key | Description | Example |
---|---|---|
A (all) | An optimized method to find all the characteristic values and/or vectors is available | e.g. eigvals(M) |
R (range) | An optimized method to find the il th through the ih th characteristic values are available | eigvals(M, il, ih) |
I (interval) | An optimized method to find the characteristic values in the interval [vl , vh ] is available | eigvals(M, vl, vh) |
V (vectors) | An optimized method to find the characteristic vectors corresponding to the characteristic values x=[x1, x2,...] is available | eigvecs(M, x) |
The uniform scaling operator
UniformScaling
演算子はスカラーと単位演算子 λ*I
を表します。単位演算子 I
は定数として定義され、UniformScaling
のインスタンスです。これらの演算子のサイズは一般的であり、バイナリ演算 +
、-
、*
、および \
の他の行列と一致します。A+I
および A-I
の場合、A
は正方行列でなければなりません。単位演算子 I
との乗算はノーオップであり(スケーリング係数が1であることを確認することを除いて)、したがってほとんどオーバーヘッドがありません。
UniformScaling
演算子の動作を確認するには:
julia> U = UniformScaling(2);
julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> a + U
2×2 Matrix{Int64}:
3 2
3 6
julia> a * U
2×2 Matrix{Int64}:
2 4
6 8
julia> [a U]
2×4 Matrix{Int64}:
1 2 2 0
3 4 0 2
julia> b = [1 2 3; 4 5 6]
2×3 Matrix{Int64}:
1 2 3
4 5 6
julia> b - U
ERROR: DimensionMismatch: matrix is not square: dimensions are (2, 3)
Stacktrace:
[...]
同じ A
に対して異なる μ
の形 (A+μI)x = b
の多くのシステムを解く必要がある場合、最初に hessenberg
関数を介して A
のヘッセンバーグ因子分解 F
を計算することが有益かもしれません。 F
が得られたら、Julia は (F+μ*I) \ b
(これは (A+μ*I)x \ b
と同等)や行列式のような関連操作のための効率的なアルゴリズムを使用します。
Matrix factorizations
Matrix factorizations (a.k.a. matrix decompositions) 行列の因子分解は、行列を行列の積に分解することであり、(数値的)線形代数の中心的な概念の一つです。
以下の表は、Juliaで実装されている行列因子分解の種類をまとめたものです。それらに関連するメソッドの詳細は、線形代数ドキュメントの Standard functions セクションで確認できます。
Type | Description |
---|---|
BunchKaufman | Bunch-Kaufman factorization |
Cholesky | Cholesky factorization |
CholeskyPivoted | Pivoted Cholesky factorization |
LDLt | LDL(T) factorization |
LU | LU factorization |
QR | QR factorization |
QRCompactWY | Compact WY form of the QR factorization |
QRPivoted | Pivoted QR factorization |
LQ | QR factorization of transpose(A) |
Hessenberg | Hessenberg decomposition |
Eigen | Spectral decomposition |
GeneralizedEigen | Generalized spectral decomposition |
SVD | Singular value decomposition |
GeneralizedSVD | Generalized SVD |
Schur | Schur decomposition |
GeneralizedSchur | Generalized Schur decomposition |
Factorization
オブジェクトの随伴と転置は、それぞれ AdjointFactorization
および TransposeFactorization
オブジェクトに遅延ラップされます。一般に、実数の Factorization
の転置は AdjointFactorization
としてラップされます。
Orthogonal matrices (AbstractQ
)
いくつかの行列因子分解は、直交行列またはユニタリ行列の「行列」因子を生成します。これらの因子分解には、qr
、すなわち QR
、QRCompactWY
、および QRPivoted
から得られるQR関連の因子分解、hessenberg
から得られるヘッセンベルグ因子分解、そして lq
から得られるLQ因子分解が含まれます。これらの直交行列/ユニタリ行列因子は行列表現を持ちますが、その内部表現はパフォーマンスとメモリの理由から異なります。したがって、これらはむしろ行列に基づいた関数ベースの線形演算子として見るべきです。特に、例えばその行列表現の列を読み取るには、「行列」-ベクトル乗算コードを実行する必要があり、単にメモリからデータを読み出すだけではありません(場合によってはベクトルの一部を構造的ゼロで埋めることになります)。他の非三角行列型との明確な違いは、基礎となる乗算コードが乗算中にインプレースでの修正を許可することです。さらに、4d61726b646f776e2e436f64652822222c202271722229_40726566
、4d61726b646f776e2e436f64652822222c202268657373656e626572672229_40726566
、および 4d61726b646f776e2e436f64652822222c20226c712229_40726566
を介して作成された特定の AbstractQ
サブタイプのオブジェクトは、文脈に応じて正方行列または長方行列のように振る舞うことができます。
julia> using LinearAlgebra
julia> Q = qr(rand(3,2)).Q
3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
julia> Matrix(Q)
3×2 Matrix{Float64}:
-0.320597 0.865734
-0.765834 -0.475694
-0.557419 0.155628
julia> Q*I
3×3 Matrix{Float64}:
-0.320597 0.865734 -0.384346
-0.765834 -0.475694 -0.432683
-0.557419 0.155628 0.815514
julia> Q*ones(2)
3-element Vector{Float64}:
0.5451367118802273
-1.241527373086654
-0.40179067589600226
julia> Q*ones(3)
3-element Vector{Float64}:
0.16079054743832022
-1.674209978965636
0.41372375588835797
julia> ones(1,2) * Q'
1×3 Matrix{Float64}:
0.545137 -1.24153 -0.401791
julia> ones(1,3) * Q'
1×3 Matrix{Float64}:
0.160791 -1.67421 0.413724
この密なまたは構造化された行列との区別により、抽象型 AbstractQ
は AbstractMatrix
のサブタイプではなく、独自の型階層を持っています。 AbstractQ
をサブタイプとするカスタム型は、次のインターフェースが満たされている場合、ジェネリックフォールバックに依存できます。例えば、
struct MyQ{T} <: LinearAlgebra.AbstractQ{T}
# required fields
end
オーバーロードを提供する
Base.size(Q::MyQ) # size of corresponding square matrix representation
Base.convert(::Type{AbstractQ{T}}, Q::MyQ) # eltype promotion [optional]
LinearAlgebra.lmul!(Q::MyQ, x::AbstractVecOrMat) # left-multiplication
LinearAlgebra.rmul!(A::AbstractMatrix, Q::MyQ) # right-multiplication
eltype
の昇格が興味の対象でない場合、convert
メソッドは不要です。なぜなら、デフォルトで convert(::Type{AbstractQ{T}}, Q::AbstractQ{T})
は Q
自体を返すからです。AbstractQ
型のオブジェクトの随伴は、AdjointQ
ラッパー型で遅延ラップされ、独自の LinearAlgebra.lmul!
および LinearAlgebra.rmul!
メソッドが必要です。この一連のメソッドにより、任意の Q::MyQ
は行列のように使用でき、特に乗算の文脈で好まれます:スカラー、ベクトル、行列との左および右からの *
による乗算、Matrix(Q)
(または Q*I
)を介しての Q
の行列表現の取得、行列表現へのインデックス付けがすべて機能します。対照的に、加算や減算、さらには行列表現の要素に対するブロードキャストは失敗します。なぜなら、それは非常に非効率的だからです。そのような使用ケースでは、事前に行列表現を計算し、将来の再利用のためにキャッシュすることを検討してください。
Pivoting Strategies
ジュリアの matrix factorizations のいくつかは pivoting をサポートしており、これを使用することで数値的安定性を向上させることができます。実際、LU因子分解などのいくつかの行列因子分解は、ピボットなしでは失敗する可能性があります。
In pivoting, first, a pivot element with good numerical properties is chosen based on a pivoting strategy. Next, the rows and columns of the original matrix are permuted to bring the chosen element in place for subsequent computation. Furthermore, the process is repeated for each stage of the factorization.
したがって、従来の行列因子に加えて、ピボット因子化スキームの出力には置換行列も含まれます。
以下に、Juliaで実装されているピボット戦略について簡単に説明します。すべての行列因子分解がこれらをサポートしているわけではないことに注意してください。サポートされているピボット戦略の詳細については、該当する matrix factorization のドキュメントを参照してください。
関連情報は LinearAlgebra.ZeroPivotException
を参照してください。
LinearAlgebra.NoPivot
— TypeNoPivot
ピボットは実行されません。LU因子分解などの行列因子分解は、ピボットなしでは失敗する可能性があり、丸め誤差に対して浮動小数点行列に対して数値的に不安定である可能性もあります。このピボット戦略は主に教育的目的で役立ちます。
LinearAlgebra.RowNonZero
— TypeRowNonZero
残りの行の最初の非ゼロ要素がピボット要素として選ばれます。
浮動小数点行列に対しては、結果として得られるLUアルゴリズムは数値的に不安定であるため注意が必要です。この戦略は、主に手計算(通常この戦略を使用する)との比較や、丸め誤差に影響されない他の代数型(例えば、有理数)に対して有用です。それ以外の場合、ガウス消去法ではデフォルトのRowMaximum
ピボット戦略が一般的に推奨されます。
LinearAlgebra.RowMaximum
— TypeRowMaximum
残りの行の中で最大の絶対値を持つ要素がピボット要素として選ばれます。これは浮動小数点行列のLU因子分解のデフォルト戦略であり、時には「部分ピボッティング」アルゴリズムと呼ばれます。
LinearAlgebra.ColumnNorm
— TypeColumnNorm
最大ノルムを持つ列がその後の計算に使用されます。これはピボットQR因子分解に使用されます。
行列の要素型は、norm
およびabs
メソッドを許容する必要があり、それぞれの結果型は<
メソッドを許容する必要があります。
Standard functions
ジュリアの線形代数関数は、主に LAPACK から関数を呼び出すことで実装されています。スパース行列の因子分解は、 SuiteSparse から関数を呼び出します。他のスパースソルバーは、ジュリアパッケージとして利用可能です。
Base.:*
— Method*(A::AbstractMatrix, B::AbstractMatrix)
行列の乗算。
例
julia> [1 1; 0 1] * [1 0; 1 1]
2×2 Matrix{Int64}:
2 1
1 1
Base.:*
— Method*(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!
が使用されます。
Base.:\
— Method\(A, B)
ポリアルゴリズムを使用した行列の除算。入力行列 A
と B
に対して、結果 X
は A*X == B
となるように、A
が正方行列である場合に求められます。使用されるソルバーは A
の構造に依存します。A
が上三角または下三角(または対角)である場合、A
の因数分解は必要なく、前方または後方代入によってシステムが解かれます。非三角形の正方行列の場合、LU因数分解が使用されます。
矩形の A
に対して、結果は A
のピボットQR因数分解と R
因子に基づく A
のランク推定によって計算された最小ノルム最小二乗解です。
A
がスパースである場合、同様のポリアルゴリズムが使用されます。非定義行列の場合、LDLt
因数分解は数値因数分解中にピボティングを使用しないため、可逆行列であっても手続きが失敗する可能性があります。
例
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
Base.:/
— MethodA / 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
LinearAlgebra.SingularException
— TypeSingularException
入力行列に1つ以上のゼロ値の固有値があり、逆行列が存在しない場合にスローされる例外です。このような行列を含む線形方程式の解は計算できません。info
フィールドは、特異値の位置を示します。
LinearAlgebra.PosDefException
— TypePosDefException
入力行列が正定値でない場合にスローされる例外。一部の線形代数関数や因数分解は正定値行列にのみ適用可能です。info
フィールドは、0以下の(いずれかの)固有値の位置を示します。
LinearAlgebra.ZeroPivotException
— TypeZeroPivotException <: Exception
ピボット(対角)位置にゼロがある場合に行列の因子分解/解決が発生し、進行できないときにスローされる例外です。これは行列が特異であることを意味するわけではありません:偽のゼロピボットを排除するために変数を再配置できるピボットLUなどの別の因子分解に切り替えることが有益な場合があります。info
フィールドはゼロピボットの位置を示します。
LinearAlgebra.RankDeficientException
— TypeRankDeficientException
入力行列がランク欠損であるときにスローされる例外です。コレスキー分解のような一部の線形代数関数は、ランク欠損でない行列にのみ適用可能です。info
フィールドは、行列の計算されたランクを示します。
LinearAlgebra.LAPACKException
— TypeLAPACK例外
直接的にLAPACK関数を呼び出す際、または内部でLAPACK関数を使用する他の関数を呼び出す際に、特別なエラーハンドリングがない場合にスローされる一般的なLAPACK例外です。info
フィールドには、基礎となるエラーに関する追加情報が含まれており、呼び出されたLAPACK関数に依存します。
LinearAlgebra.dot
— Functiondot(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
LinearAlgebra.dot
— Methoddot(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
LinearAlgebra.cross
— Functioncross(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
LinearAlgebra.axpy!
— Functionaxpy!(α, 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
LinearAlgebra.axpby!
— Functionaxpby!(α, 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
LinearAlgebra.rotate!
— Functionrotate!(x, y, c, s)
x
をc*x + s*y
で上書きし、y
を-conj(s)*x + c*y
で上書きします。x
とy
を返します。
LinearAlgebra.reflect!
— Functionreflect!(x, y, c, s)
x
をc*x + s*y
で上書きし、y
をconj(s)*x - c*y
で上書きします。x
とy
を返します。
LinearAlgebra.factorize
— Functionfactorize(A)
入力行列のタイプに基づいて、A
の便利な因数分解を計算します。factorize
は、A
が一般的な行列として渡された場合、対称/三角形/etc.であるかどうかを確認します。factorize
は、A
の各要素をチェックして、各特性を確認/除外します。対称性/三角形構造を除外できるとすぐに短絡します。返り値は、複数のシステムを効率的に解くために再利用できます。例えば:A=factorize(A); x=A\b; y=A\C
。
A の特性 | 因数分解のタイプ |
---|---|
正定値 | コレスキー (see cholesky ) |
密な対称/エルミート行列 | バンチ-カウフマン (see bunchkaufman ) |
スパース対称/エルミート行列 | LDLt (see ldlt ) |
三角行列 | 三角行列 |
対角行列 | 対角行列 |
双対角行列 | 双対角行列 |
三重対角行列 | LU (see lu ) |
対称実三重対角行列 | LDLt (see ldlt ) |
一般的な正方行列 | LU (see lu ) |
一般的な非正方行列 | QR (see qr ) |
例えば、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
タイプのための特化したメソッドが使用されます。
LinearAlgebra.Diagonal
— TypeDiagonal(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
を参照してください。
LinearAlgebra.Bidiagonal
— TypeBidiagonal(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
LinearAlgebra.SymTridiagonal
— TypeSymTridiagonal(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]
LinearAlgebra.Tridiagonal
— TypeTridiagonal(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
LinearAlgebra.Symmetric
— TypeSymmetric(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
と等しくなりません。
LinearAlgebra.Hermitian
— TypeHermitian(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)
LinearAlgebra.LowerTriangular
— TypeLowerTriangular(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
LinearAlgebra.UpperTriangular
— TypeUpperTriangular(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
LinearAlgebra.UnitLowerTriangular
— TypeUnitLowerTriangular(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
LinearAlgebra.UnitUpperTriangular
— TypeUnitUpperTriangular(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
LinearAlgebra.UpperHessenberg
— TypeUpperHessenberg(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
LinearAlgebra.UniformScaling
— TypeUniformScaling{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
LinearAlgebra.I
— ConstantI
任意のサイズの単位行列を表す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
LinearAlgebra.UniformScaling
— Method(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
— TypeLinearAlgebra.Factorization
行列因子分解(matrix factorizations)の抽象型。利用可能な行列因子分解のリストについては、オンラインドキュメントを参照してください。
LinearAlgebra.LU
— TypeLU <: Factorization
正方行列 A
の LU
分解の行列分解型です。これは、対応する行列分解関数 lu
の戻り値の型です。
分解 F::LU
の個々のコンポーネントには、getproperty
を介してアクセスできます:
コンポーネント | 説明 |
---|---|
F.L | LU の L (単位下三角)部分 |
F.U | LU の U (上三角)部分 |
F.p | (右)置換 Vector |
F.P | (右)置換 Matrix |
分解を反復すると、コンポーネント 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
LinearAlgebra.lu
— Functionlu(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
の個々のコンポーネントにはインデックスを使用してアクセスできます:
コンポーネント | 説明 |
---|---|
L | LU の下三角部分 L |
U | LU の上三角部分 U |
p | 右置換 Vector |
q | 左置換 Vector |
Rs | スケーリングファクターの Vector |
: | (L,U,p,q,Rs) コンポーネント |
F
と A
の関係は次の通りです。
F.L*F.U == (F.Rs .* A)[F.p, F.q]
F
はさらに以下の関数をサポートしています:
また lu!
も参照してください。
lu(A::AbstractSparseMatrixCSC)
は、SuiteSparse の一部であるUMFPACK[ACM832]ライブラリを使用します。このライブラリは、Float64
または ComplexF64
要素を持つスパース行列のみをサポートしているため、lu
は A
を SparseMatrixCSC{Float64}
または SparseMatrixCSC{ComplexF64}
型のコピーに変換します。
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 | LU の L (下三角)部分 |
F.U | LU の U (上三角)部分 |
F.p | (右)置換 Vector |
F.P | (右)置換 Matrix |
分解を反復すると、コンポーネント F.L
、F.U
、および F.p
が得られます。
F
と A
の関係は次の通りです。
F.L*F.U == A[F.p, :]
F
はさらに次の関数をサポートします:
サポートされる関数 | LU | LU{T,Tridiagonal{T}} |
---|---|---|
/ | ✓ | |
\ | ✓ | ✓ |
inv | ✓ | ✓ |
det | ✓ | ✓ |
logdet | ✓ | ✓ |
logabsdet | ✓ | ✓ |
size | ✓ | ✓ |
例
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
LinearAlgebra.lu!
— Functionlu!(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
を参照してください。
lu!(F::UmfpackLU, A::AbstractSparseMatrixCSC)
は SuiteSparse の一部である UMFPACK ライブラリを使用します。このライブラリは Float64
または ComplexF64
要素を持つスパース行列のみをサポートしているため、lu!
は自動的にLU因子分解によって設定された型または適切な SparseMatrixCSC{ComplexF64}
に型を変換します。
例
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:
[...]
LinearAlgebra.Cholesky
— TypeCholesky <: 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
LinearAlgebra.CholeskyPivoted
— TypeCholeskyPivoted
密な対称/エルミート半正定値行列 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
LinearAlgebra.cholesky
— Functioncholesky(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
このメソッドは、SuiteSparse の CHOLMOD[ACM887][DavisHager2009] ライブラリを使用しています。CHOLMOD は、単精度または倍精度の実数または複素数型のみをサポートしています。これらの要素型でない入力行列は、適切にこれらの型に変換されます。
CHOLMOD からの他の多くの関数はラップされていますが、Base.SparseArrays.CHOLMOD
モジュールからはエクスポートされていません。
LinearAlgebra.cholesky!
— Functioncholesky!(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
を参照してください。
LinearAlgebra.lowrankupdate
— Functionlowrankupdate(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!
を参照してください。
LinearAlgebra.lowrankdowndate
— Functionlowrankdowndate(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!
を参照してください。
LinearAlgebra.lowrankupdate!
— Functionlowrankupdate!(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!
も参照してください。
LinearAlgebra.lowrankdowndate!
— Functionlowrankdowndate!(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!
も参照してください。
LinearAlgebra.LDLt
— TypeLDLt <: Factorization
実数の SymTridiagonal
行列 S
の LDLt
因子分解の行列因子分解タイプで、S = L*Diagonal(d)*L'
となります。ここで、L
は UnitLowerTriangular
行列で、d
はベクトルです。LDLt
因子分解 F = ldlt(S)
の主な用途は、線形方程式系 Sx = b
を F\b
で解くことです。これは、対応する行列因子分解関数 ldlt
の戻り値の型です。
因子分解 F::LDLt
の個々のコンポーネントには getproperty
を介してアクセスできます:
コンポーネント | 説明 |
---|---|
F.L | LDLt の L (単位下三角)部分 |
F.D | LDLt の D (対角)部分 |
F.Lt | LDLt の Lt (単位上三角)部分 |
F.d | D の対角値を持つ Vector |
例
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
LinearAlgebra.ldlt
— Functionldlt(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 順序の代わりに)。
このメソッドは、SuiteSparse の CHOLMOD[ACM887][DavisHager2009] ライブラリを使用しています。CHOLMOD は、単精度または倍精度の実数または複素数型のみをサポートしています。これらの要素型でない入力行列は、適切にこれらの型に変換されます。
CHOLMOD の他の多くの関数はラップされていますが、Base.SparseArrays.CHOLMOD
モジュールからはエクスポートされていません。
LinearAlgebra.ldlt!
— Functionldlt!(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
を参照してください。
このメソッドは、SuiteSparseのCHOLMODライブラリを使用しており、これは単精度または倍精度の実数または複素数型のみをサポートしています。これらの要素型でない入力行列は、適切にこれらの型に変換されます。
LinearAlgebra.QR
— TypeQR <: 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$番目の列です。
- 上三角部分には$R$の要素が含まれています。すなわち、
τ
は長さmin(m,n)
のベクトルで、係数$au_i$を含みます。
LinearAlgebra.QRCompactWY
— TypeQRCompactWY <: 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)
となります。
- 上三角部分には$R$の要素が含まれ、すなわち
T
は、上記のように$n_b$×$\min(m,n)$行列です。各三角行列$T_j$の下対角要素は無視されます。
この形式は、古いWY表現[Bischof1987]と混同しないでください。
LinearAlgebra.QRPivoted
— TypeQRPivoted <: 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$番目の列です。
- 上三角部分には$R$の要素が含まれています。すなわち、
τ
は長さmin(m,n)
のベクトルで、係数$au_i$を含みます。jpvt
は長さn
の整数ベクトルで、置換$P$に対応します。
LinearAlgebra.qr
— Functionqr(A::SparseMatrixCSC; tol=_default_tol(A), ordering=ORDERING_DEFAULT) -> QRSparse
スパース行列 A
の QR
分解を計算します。フィル削減行と列の置換が使用され、F.R = F.Q'*A[F.prow,F.pcol]
となります。このタイプの主な用途は、\
を使用して最小二乗または過剰決定問題を解決することです。この関数は C ライブラリ SPQR[ACM933] を呼び出します。
qr(A::SparseMatrixCSC)
は SuiteSparse の一部である SPQR ライブラリを使用します。このライブラリは Float64
または ComplexF64
要素を持つスパース行列のみをサポートしているため、Julia v1.4 以降、qr
は A
を SparseMatrixCSC{Float64}
または SparseMatrixCSC{ComplexF64}
型のコピーに変換します。
例
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
の個々のコンポーネントはプロパティアクセサを介して取得できます:
分解を反復することで、コンポーネント 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
は複数の型を返します。なぜなら、LAPACK はハウスホルダー基本反射の積のメモリストレージ要件を最小限に抑えるためにいくつかの表現を使用するため、Q
と R
行列を2つの別々の密行列としてではなく、コンパクトに格納できるからです。
```
LinearAlgebra.qr!
— Functionqr!(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:
[...]
LinearAlgebra.LQ
— TypeLQ <: 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
LinearAlgebra.lq
— Functionlq(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
LinearAlgebra.lq!
— FunctionLinearAlgebra.BunchKaufman
— TypeBunchKaufman <: 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
LinearAlgebra.bunchkaufman
— Functionbunchkaufman(A, rook::Bool=false; check = true) -> S::BunchKaufman
対称行列またはエルミート行列 A
のバンチ-カウフマン [Bunch1977] 分解を 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
LinearAlgebra.bunchkaufman!
— Functionbunchkaufman!(A, rook::Bool=false; check = true) -> BunchKaufman
bunchkaufman!
は bunchkaufman
と同じですが、コピーを作成するのではなく、入力 A
を上書きすることでスペースを節約します。
LinearAlgebra.Eigen
— TypeEigen <: 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
LinearAlgebra.GeneralizedEigen
— TypeGeneralizedEigen <: 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
LinearAlgebra.eigvals
— Functioneigvals(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
LinearAlgebra.eigvals!
— Functioneigvals!(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
は上限です。
LinearAlgebra.eigmax
— Functioneigmax(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:
[...]
LinearAlgebra.eigmin
— Functioneigmin(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:
[...]
LinearAlgebra.eigvecs
— Functioneigvecs(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
LinearAlgebra.eigen
— Functioneigen(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
は上限です。
```
LinearAlgebra.eigen!
— Functioneigen!(A; permute, scale, sortby)
eigen!(A, B; sortby)
eigen
と同様ですが、コピーを作成するのではなく、入力 A
(および B
)を上書きすることでスペースを節約します。
LinearAlgebra.Hessenberg
— TypeHessenberg <: 因数分解
Hessenberg
オブジェクトは、正方行列のヘッセンベルグ因数分解QHQ'
、またはそのシフトQ(H+μI)Q'
を表し、これはhessenberg
関数によって生成されます。
LinearAlgebra.hessenberg
— Functionhessenberg(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
LinearAlgebra.hessenberg!
— Functionhessenberg!(A) -> ヘッセンベルグ
hessenberg!
は hessenberg
と同じですが、コピーを作成するのではなく、入力 A
を上書きすることでスペースを節約します。
LinearAlgebra.Schur
— TypeSchur <: 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
LinearAlgebra.GeneralizedSchur
— TypeGeneralizedSchur <: 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.β
が生成されます。
LinearAlgebra.schur
— Functionschur(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.β
が得られます。
LinearAlgebra.schur!
— Functionschur!(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
を作業領域として使用します。
LinearAlgebra.ordschur
— Functionordschur(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.β
で依然として取得できます。
LinearAlgebra.ordschur!
— Functionordschur!(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur
ordschur
と同様ですが、因子分解 F
を上書きします。
ordschur!(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur
ordschur
と同様ですが、因子分解F
を上書きします。
LinearAlgebra.SVD
— TypeSVD <: 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
LinearAlgebra.GeneralizedSVD
— TypeGeneralizedSVD <: 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
LinearAlgebra.svd
— Functionsvd(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
LinearAlgebra.svd!
— Functionsvd!(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD
svd!
は svd
と同じですが、コピーを作成するのではなく、入力 A
を上書きすることでスペースを節約します。詳細については svd
のドキュメントを参照してください。
LinearAlgebra.svdvals
— Functionsvdvals(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
LinearAlgebra.svdvals!
— FunctionLinearAlgebra.Givens
— TypeLinearAlgebra.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
を参照してください。
LinearAlgebra.givens
— Functiongivens(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
を参照してください。 ```
LinearAlgebra.triu
— Functiontriu(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
LinearAlgebra.triu!
— Functiontriu!(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
LinearAlgebra.tril
— Functiontril(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
LinearAlgebra.tril!
— Functiontril!(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
LinearAlgebra.diagind
— Functiondiagind(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
(主対角線に対応) と見なされます。
例
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)
LinearAlgebra.diag
— Functiondiag(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
LinearAlgebra.diagm
— Functiondiagm(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
LinearAlgebra.rank
— Functionrank(::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
です。
数値的ランクは、特異値が閾値許容誤差 max(atol, rtol*σ₁)
に近い条件の悪い行列の敏感で不正確な特性を示すことがあります。そのような場合、特異値計算や行列へのわずかな摂動が、1つまたは複数の特異値を閾値を越えさせることによって rank
の結果を変える可能性があります。これらの変動は、異なるJuliaのバージョン、アーキテクチャ、コンパイラ、またはオペレーティングシステム間の浮動小数点誤差の変化によっても発生することがあります。
atol
と rtol
のキーワード引数は、少なくともJulia 1.1が必要です。Julia 1.0では rtol
は位置引数として利用可能ですが、これはJulia 2.0で非推奨になります。
例
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
LinearAlgebra.norm
— Functionnorm(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
LinearAlgebra.opnorm
— Functionopnorm(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
LinearAlgebra.normalize!
— Functionnormalize!(a::AbstractArray, p::Real=2)
配列 a
をインプレースで正規化し、その p
-ノルムが1に等しくなるようにします。すなわち、norm(a, p) == 1
です。詳細は normalize
および norm
を参照してください。
LinearAlgebra.normalize
— Functionnormalize(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
LinearAlgebra.cond
— Functioncond(M, p::Real=2)
行列 M
の条件数で、演算子 p
-ノルムを使用して計算されます。p
の有効な値は 1
、2
(デフォルト)、または Inf
です。
LinearAlgebra.condskeel
— Functioncondskeel(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
(デフォルト)です。
この量は文献ではバウアー条件数、相対条件数、または成分ごとの相対条件数としても知られています。
LinearAlgebra.tr
— Functiontr(M)
行列のトレース。M
の対角要素を合計します。
例
julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> tr(A)
5
LinearAlgebra.det
— Functiondet(M)
行列式。
例
julia> M = [1 0; 2 2]
2×2 Matrix{Int64}:
1 0
2 2
julia> det(M)
2.0
LinearAlgebra.logdet
— Functionlogdet(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
LinearAlgebra.logabsdet
— Functionlogabsdet(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)
Base.inv
— Methodinv(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
LinearAlgebra.pinv
— Functionpinv(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
LinearAlgebra.nullspace
— Functionnullspace(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
Base.kron
— Functionkron(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
Base.kron!
— Functionkron!(C, A, B)
A
とB
のクロネッカー積を計算し、その結果をC
に格納し、C
の既存の内容を上書きします。これはkron
のインプレースバージョンです。
Base.exp
— Methodexp(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
Base.cis
— Methodcis(A::AbstractMatrix)
平方行列 A
の exp(im*A)
のより効率的な方法(特に A
が Hermitian
または実対称行列の場合)。
例
julia> cis([π 0; 0 π]) ≈ -I
true
Base.:^
— Method^(A::AbstractMatrix, p::Number)
行列の累乗、$\exp(p\log(A))$に相当します。
例
julia> [1 2; 0 3]^3
2×2 Matrix{Int64}:
1 26
0 27
Base.:^
— Method^(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
Base.log
— Methodlog(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
Base.sqrt
— Methodsqrt(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
Base.Math.cbrt
— Methodcbrt(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
Base.cos
— Methodcos(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
Base.sin
— Methodsin(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
Base.Math.sincos
— Methodsincos(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
Base.tan
— Methodtan(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
Base.Math.sec
— Methodsec(A::AbstractMatrix)
正方行列 A
の行列セカントを計算します。
Base.Math.csc
— Methodcsc(A::AbstractMatrix)
正方行列 A
の行列コセカントを計算します。
Base.Math.cot
— Methodcot(A::AbstractMatrix)
正方行列 A
の行列コタンジェントを計算します。
Base.cosh
— Methodcosh(A::AbstractMatrix)
正方行列 A
の行列双曲線コサインを計算します。
Base.sinh
— Methodsinh(A::AbstractMatrix)
正方行列 A
の行列双曲線正弦を計算します。
Base.tanh
— Methodtanh(A::AbstractMatrix)
正方行列 A
の行列双曲線正接を計算します。
Base.Math.sech
— Methodsech(A::AbstractMatrix)
行列 A
の行列双曲線セカントを計算します。
Base.Math.csch
— Methodcsch(A::AbstractMatrix)
行列 A
の行列双曲線余割を計算します。
Base.Math.coth
— Methodcoth(A::AbstractMatrix)
行列 A
の行列双曲線コタンジェントを計算します。
Base.acos
— Methodacos(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
Base.asin
— Methodasin(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
Base.atan
— Methodatan(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
Base.Math.asec
— Methodasec(A::AbstractMatrix)
行列 A
の逆行列セカントを計算します。
Base.Math.acsc
— Methodacsc(A::AbstractMatrix)
行列 A
の逆行列コセカントを計算します。
Base.Math.acot
— Methodacot(A::AbstractMatrix)
行列 A
の逆行列コタンジェントを計算します。
Base.acosh
— Methodacosh(A::AbstractMatrix)
正方行列 A
の逆双曲線行列コサインを計算します。この関数を計算するために使用される理論と対数式については、[AH16_4]を参照してください。
Base.asinh
— Methodasinh(A::AbstractMatrix)
正方行列 A
の逆双曲線行列サインを計算します。この関数を計算するために使用される理論と対数式については、[AH16_5]を参照してください。
Base.atanh
— Methodatanh(A::AbstractMatrix)
正方行列 A
の逆双曲線行列タンジェントを計算します。この関数を計算するために使用される理論と対数式については、[AH16_6]を参照してください。
Base.Math.asech
— Methodasech(A::AbstractMatrix)
行列 A
の逆行列双曲線セカントを計算します。
Base.Math.acsch
— Methodacsch(A::AbstractMatrix)
行列 A
の逆行列双曲線余弦の計算を行います。
Base.Math.acoth
— Methodacoth(A::AbstractMatrix)
行列 A
の逆行列双曲線コタンジェントを計算します。
LinearAlgebra.lyap
— Functionlyap(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
LinearAlgebra.sylvester
— Functionsylvester(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
LinearAlgebra.issuccess
— Functionissuccess(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
LinearAlgebra.issymmetric
— Functionissymmetric(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
LinearAlgebra.isposdef
— Functionisposdef(A) -> Bool
行列が正定値(およびエルミート)であるかどうかを、A
のコレスキー分解を試みることでテストします。
例
julia> A = [1 2; 2 50]
2×2 Matrix{Int64}:
1 2
2 50
julia> isposdef(A)
true
LinearAlgebra.isposdef!
— Functionisposdef!(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
LinearAlgebra.istril
— Functionistril(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
LinearAlgebra.istriu
— Functionistriu(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
LinearAlgebra.isdiag
— Functionisdiag(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
LinearAlgebra.ishermitian
— Functionishermitian(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
Base.transpose
— Functiontranspose(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
を返します。
LinearAlgebra.transpose!
— Functiontranspose!(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
LinearAlgebra.Transpose
— Type転置
基礎となる線形代数オブジェクト、通常は 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
LinearAlgebra.TransposeFactorization
— TypeTransposeFactorization
基になる Factorization
オブジェクトの転置のための遅延ラッパー型です。通常、TransposeFactorization
コンストラクタは直接呼び出すべきではなく、代わりに transpose(:: Factorization)
を使用してください。
Base.adjoint
— FunctionA'
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
ラッパーを返します。
LinearAlgebra.adjoint!
— Functionadjoint!(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
LinearAlgebra.Adjoint
— Type随伴
基になる線形代数オブジェクト、通常は 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
LinearAlgebra.AdjointFactorization
— TypeAdjointFactorization
基になる Factorization
オブジェクトの随伴のための遅延ラッパー型です。通常、AdjointFactorization
コンストラクタは直接呼び出すべきではなく、代わりに adjoint(:: Factorization)
を使用してください。
Base.copy
— Methodcopy(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
LinearAlgebra.stride1
— Functionstride1(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
— FunctionLinearAlgebra.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
— FunctionLinearAlgebra.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
は、各プロセッサで解決される問題のサイズを指します。
LinearAlgebra.hermitianpart
— Functionhermitianpart(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian
正方行列 A
のエルミート部分を返します。これは (A + A') / 2
と定義され、Hermitian
行列として返されます。実数行列 A
に対しては、これは A
の対称部分としても知られています。また、時には「演算子の実部」とも呼ばれます。オプションの引数 uplo
は、Hermitian
ビューの対応する引数を制御します。実数行列の場合、後者は Symmetric
ビューに相当します。
対応するインプレース操作については、hermitianpart!
も参照してください。
LinearAlgebra.hermitianpart!
— Functionhermitianpart!(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian
正方行列 A
をそのエルミート部分 (A + A') / 2
でインプレースで上書きし、Hermitian(A, uplo)
を返します。実数行列 A
に対して、これは A
の対称部分としても知られています。
対応するアウトオブプレース操作については、hermitianpart
を参照してください。
LinearAlgebra.copy_adjoint!
— Functioncopy_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)
を満たす必要があります。
LinearAlgebra.copy_transpose!
— Functioncopy_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
に効率的にコピーします。以下のように条件付けられます:
tM | 宛先 | ソース |
---|---|---|
'N' | B[ir_dest, jr_dest] | transpose(M)[jr_src, ir_src] |
'T' | B[ir_dest, jr_dest] | M[jr_src, ir_src] |
'C' | B[ir_dest, jr_dest] | conj(M)[jr_src, ir_src] |
要素 B[ir_dest, jr_dest]
は上書きされます。さらに、インデックス範囲パラメータは length(ir_dest) == length(jr_src)
および length(jr_dest) == length(ir_src)
を満たす必要があります。
さらに copyto!
および copy_adjoint!
を参照してください。
Low-level matrix operations
多くの場合、事前に割り当てられた出力ベクトルや行列を提供できる行列演算のインプレースバージョンがあります。これは、繰り返しの割り当てのオーバーヘッドを回避するために、重要なコードを最適化する際に便利です。これらのインプレース操作は、通常のJuliaの慣例に従って、以下のように!
で終わります(例:mul!
)。
LinearAlgebra.mul!
— Functionmul!(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
LinearAlgebra.lmul!
— Functionlmul!(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
LinearAlgebra.rmul!
— Functionrmul!(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
LinearAlgebra.ldiv!
— Functionldiv!(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
の対角成分も上書きされます。
LinearAlgebra.rdiv!
— Functionrdiv!(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 functions
ジュリア(多くの科学計算と同様に)では、密な線形代数操作は LAPACK library に基づいており、これは基本的な線形代数のビルディングブロックである BLAS の上に構築されています。すべてのコンピュータアーキテクチャに対して利用可能な高度に最適化されたBLASの実装があり、高性能な線形代数ルーチンではBLAS関数を直接呼び出すことが有用な場合があります。
LinearAlgebra.BLAS
は、いくつかの BLAS 関数のラッパーを提供します。入力配列のいずれかを上書きする BLAS 関数は、名前が '!'
で終わります。通常、BLAS 関数には、Float32
、Float64
、ComplexF32
、および ComplexF64
配列に対して4つのメソッドが定義されています。
BLAS character arguments
多くのBLAS関数は、引数が転置されるかどうかを決定する引数(trans
)、行列のどの三角形を参照するかを決定する引数(uplo
またはul
)、三角行列の対角線がすべて1であると仮定できるかどうかを決定する引数(dA
)、および行列の乗算のどの側に入力引数が属するかを決定する引数(side
)を受け入れます。可能性は次のとおりです:
Multiplication order
side | Meaning |
---|---|
'L' | The argument goes on the left side of a matrix-matrix operation. |
'R' | The argument goes on the right side of a matrix-matrix operation. |
Triangle referencing
uplo /ul | Meaning |
---|---|
'U' | Only the upper triangle of the matrix will be used. |
'L' | Only the lower triangle of the matrix will be used. |
Transposition operation
trans /tX | Meaning |
---|---|
'N' | The input matrix X is not transposed or conjugated. |
'T' | The input matrix X will be transposed. |
'C' | The input matrix X will be conjugated and transposed. |
Unit diagonal
diag /dX | Meaning |
---|---|
'N' | The diagonal values of the matrix X will be read. |
'U' | The diagonal of the matrix X is assumed to be all ones. |
LinearAlgebra.BLAS
— ModuleBLASサブルーチンへのインターフェース。
LinearAlgebra.BLAS.set_num_threads
— Functionset_num_threads(n::Integer)
set_num_threads(::Nothing)
BLASライブラリが使用するスレッドの数をn::Integer
に設定します。
また、nothing
を受け入れます。この場合、juliaはデフォルトのスレッド数を推測しようとします。nothing
を渡すことは推奨されず、主に歴史的な理由から存在します。
LinearAlgebra.BLAS.get_num_threads
— FunctionBLAS関数は、最初に提案された時期、入力パラメータの種類、および操作の複雑さに応じて、3つのグループ、つまり3つのレベルに分けることができます。
Level 1 BLAS functions
レベル1 BLAS関数は[(Lawson, 1979)][Lawson-1979]で初めて提案され、スカラーとベクトルの間の演算を定義します。
[Lawson-1979]: https://dl.acm.org/doi/10.1145/355841.355847
LinearAlgebra.BLAS.rot!
— Functionrot!(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
を返します。
LinearAlgebra.BLAS.scal!
— Functionscal!(n, a, X, incx)
scal!(a, X)
配列 X
の最初の n
要素を a*X
で上書きします。ストライドは incx
です。X
を返します。
n
と incx
が指定されていない場合、length(X)
と stride(X,1)
が使用されます。
LinearAlgebra.BLAS.scal
— Functionscal(n, a, X, incx)
scal(a, X)
配列 X
の最初の n
要素をストライド incx
で a
でスケーリングします。
n
と incx
が指定されていない場合は、length(X)
と stride(X,1)
が使用されます。
LinearAlgebra.BLAS.blascopy!
— Functionblascopy!(n, X, incx, Y, incy)
配列 X
の n
要素をストライド incx
で配列 Y
にストライド incy
でコピーします。Y
を返します。
LinearAlgebra.BLAS.dot
— Functiondot(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
LinearAlgebra.BLAS.dotu
— Functiondotu(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
LinearAlgebra.BLAS.dotc
— Functiondotc(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
LinearAlgebra.BLAS.nrm2
— Functionnrm2(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
LinearAlgebra.BLAS.asum
— Functionasum(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
LinearAlgebra.BLAS.iamax
— Functioniamax(n, dx, incx)
iamax(dx)
dx
の最大絶対値を持つ要素のインデックスを見つけます。n
はdx
の長さで、incx
はストライドです。n
とincx
が指定されていない場合、デフォルト値n=length(dx)
およびincx=stride1(dx)
が仮定されます。
Level 2 BLAS functions
レベル2 BLAS関数は[(Dongarra, 1988)][Dongarra-1988]で発表され、行列-ベクトル演算を定義しています。
[Dongarra-1988]: https://dl.acm.org/doi/10.1145/42288.42291
ベクトルを返す
LinearAlgebra.BLAS.gemv!
— Functiongemv!(tA, alpha, A, x, beta, y)
ベクトル y
を alpha*A*x + beta*y
または alpha*A'x + beta*y
に更新します tA
。alpha
と beta
はスカラーです。更新された y
を返します。
LinearAlgebra.BLAS.gemv
— Methodgemv(tA, alpha, A, x)
alpha*A*x
または alpha*A'x
を tA
に従って返します。alpha
はスカラーです。
LinearAlgebra.BLAS.gemv
— Methodgemv(tA, A, x)
A*x
または A'x
を tA
に従って返します。
LinearAlgebra.BLAS.gbmv!
— Functiongbmv!(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
を返します。
LinearAlgebra.BLAS.gbmv
— Functiongbmv(trans, m, kl, ku, alpha, A, x)
alpha*A*x
または alpha*A'*x
を trans
に従って返します。行列 A
は、kl
の下三角成分と ku
の上三角成分を持つ、次元 m
と size(A,2)
の一般的なバンド行列であり、alpha
はスカラーです。
LinearAlgebra.BLAS.hemv!
— Functionhemv!(ul, alpha, A, x, beta, y)
ベクトル y
を alpha*A*x + beta*y
として更新します。A
はエルミート行列であると仮定します。A
の ul
三角形のみが使用されます。alpha
と beta
はスカラーです。更新された y
を返します。
LinearAlgebra.BLAS.hemv
— Methodhemv(ul, alpha, A, x)
返す alpha*A*x
。A
はエルミート行列であると仮定されます。A
の ul
三角部分のみが使用されます。alpha
はスカラーです。
LinearAlgebra.BLAS.hemv
— Methodhemv(ul, A, x)
A*x
を返します。A
はエルミート行列であると仮定されます。A
のul
三角部分のみが使用されます。
LinearAlgebra.BLAS.hpmv!
— Functionhpmv!(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
を返します。
LinearAlgebra.BLAS.symv!
— Functionsymv!(ul, alpha, A, x, beta, y)
ベクトル y
を alpha*A*x + beta*y
として更新します。A
は対称であると仮定されます。A
の ul
三角形のみが使用されます。alpha
と beta
はスカラーです。更新された y
を返します。
LinearAlgebra.BLAS.symv
— Methodsymv(ul, alpha, A, x)
返す alpha*A*x
。A
は対称であると仮定されます。A
の ul
三角形のみが使用されます。alpha
はスカラーです。
LinearAlgebra.BLAS.symv
— Methodsymv(ul, A, x)
A*x
を返します。A
は対称であると仮定されます。A
のul
三角形のみが使用されます。
LinearAlgebra.BLAS.sbmv!
— Functionsbmv!(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
を返します。
LinearAlgebra.BLAS.sbmv
— Methodsbmv(uplo, k, alpha, A, x)
alpha*A*x
を返します。ここで、A
は引数A
に格納されたk
の上部対角線を持つ順序size(A,2)
の対称バンド行列です。A
のuplo
三角形のみが使用されます。
LinearAlgebra.BLAS.sbmv
— Methodsbmv(uplo, k, A, x)
A*x
を返します。ここで、A
は引数A
に格納されたk
個の上対角線を持つ順対称バンド行列で、順序はsize(A,2)
です。A
のuplo
三角形のみが使用されます。
LinearAlgebra.BLAS.spmv!
— Functionspmv!(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
を返します。
LinearAlgebra.BLAS.trmv!
— Functiontrmv!(ul, tA, dA, A, b)
op(A)*b
を返します。ここで、op
はtA
によって決定されます。A
のul
三角形のみが使用されます。dA
は対角値が読み取られるか、すべて1であると仮定されるかを決定します。乗算はb
に対してインプレースで行われます。
LinearAlgebra.BLAS.trmv
— Functiontrmv(ul, tA, dA, A, b)
op(A)*b
を返します。ここで、op
はtA
によって決定されます。A
のul
三角形のみが使用されます。dA
は、対角値が読み取られるか、すべて1であると仮定されるかを決定します。
LinearAlgebra.BLAS.trsv!
— Functiontrsv!(ul, tA, dA, A, b)
b
をA*x = b
の解で上書きするか、tA
およびul
によって決定される他の2つのバリアントのいずれかで上書きします。dA
は対角値が読み取られるか、すべて1であると仮定されるかを決定します。更新されたb
を返します。
LinearAlgebra.BLAS.trsv
— Functiontrsv(ul, tA, dA, A, b)
A*x = b
の解を返すか、tA
と ul
によって決定される他の2つのバリアントのいずれかを返します。dA
は対角値が読み取られるか、すべて1であると仮定されるかを決定します。
行列を返す
LinearAlgebra.BLAS.ger!
— Functionger!(alpha, x, y, A)
ベクトル x
と y
を用いて行列 A
のランク-1 更新を行います。式は alpha*x*y' + A
です。
LinearAlgebra.BLAS.her!
— Functionher!(uplo, alpha, x, A)
複素配列専用のメソッド。ベクトル x
を用いてエルミート行列 A
のランク1更新を行います。更新は alpha*x*x' + A
です。uplo
は A
のどちらの三角形が更新されるかを制御します。A
を返します。
LinearAlgebra.BLAS.syr!
— Functionsyr!(uplo, alpha, x, A)
ベクトル x
を用いて対称行列 A
のランク1更新を行います。これは alpha*x*transpose(x) + A
です。uplo
は A
のどちらの三角形が更新されるかを制御します。A
を返します。
LinearAlgebra.BLAS.spr!
— Functionspr!(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
を返します。
Level 3 BLAS functions
レベル3 BLAS関数は[(Dongarra, 1990)][Dongarra-1990]で発表され、行列-行列演算を定義します。
[Dongarra-1990]: https://dl.acm.org/doi/10.1145/77626.79170
LinearAlgebra.BLAS.gemmt!
— Functiongemmt!(uplo, tA, tB, alpha, A, B, beta, C)
指定された uplo
の C
の下三角または上三角部分を alpha*A*B + beta*C
または tA
と tB
に応じた他のバリアントで更新します。更新された C
を返します。
LinearAlgebra.BLAS.gemmt
— MethodLinearAlgebra.BLAS.gemmt
— MethodLinearAlgebra.BLAS.gemm!
— Functiongemm!(tA, tB, alpha, A, B, beta, C)
C
をalpha*A*B + beta*C
またはtA
とtB
に応じた他の3つのバリアントに従って更新します。更新されたC
を返します。
LinearAlgebra.BLAS.gemm
— Methodgemm(tA, tB, alpha, A, B)
alpha*A*B
または tA
と tB
に応じた他の3つのバリアントを返します。
LinearAlgebra.BLAS.gemm
— Methodgemm(tA, tB, A, B)
A*B
または tA
と tB
に応じた他の3つのバリアントを返します。
LinearAlgebra.BLAS.symm!
— Functionsymm!(side, ul, alpha, A, B, beta, C)
C
をalpha*A*B + beta*C
またはalpha*B*A + beta*C
として更新します。これはside
に従います。A
は対称であると仮定されます。A
のul
三角形のみが使用されます。更新されたC
を返します。
LinearAlgebra.BLAS.symm
— Methodsymm(side, ul, alpha, A, B)
alpha*A*B
または alpha*B*A
を side
に従って返します。A
は対称であると仮定されます。A
のみ ul
三角形が使用されます。
LinearAlgebra.BLAS.symm
— MethodLinearAlgebra.BLAS.hemm!
— Functionhemm!(side, ul, alpha, A, B, beta, C)
C
をalpha*A*B + beta*C
またはalpha*B*A + beta*C
として更新します。これはside
に従います。A
はエルミート行列であると仮定します。A
のul
三角形のみが使用されます。更新されたC
を返します。
LinearAlgebra.BLAS.hemm
— Methodhemm(side, ul, alpha, A, B)
alpha*A*B
または alpha*B*A
を side
に従って返します。A
はエルミート行列であると仮定します。A
の ul
三角形のみが使用されます。
LinearAlgebra.BLAS.hemm
— MethodLinearAlgebra.BLAS.syrk!
— Functionsyrk!(uplo, trans, alpha, A, beta, C)
対称行列 C
のランク-k 更新を alpha*A*transpose(A) + beta*C
または alpha*transpose(A)*A + beta*C
の形で行います。これは trans
に従います。C
の uplo
三角形のみが使用されます。C
を返します。
LinearAlgebra.BLAS.syrk
— Functionsyrk(uplo, trans, alpha, A)
A
の上三角または下三角を、uplo
に従って返します。alpha*A*transpose(A)
またはalpha*transpose(A)*A
を、trans
に従って返します。
LinearAlgebra.BLAS.herk!
— Functionherk!(uplo, trans, alpha, A, beta, C)
複素配列専用のメソッド。エルミート行列 C
のランク-k 更新を alpha*A*A' + beta*C
または alpha*A'*A + beta*C
の形で行います。これは trans
に従います。C
の uplo
三角部分のみが更新されます。C
を返します。
LinearAlgebra.BLAS.herk
— FunctionLinearAlgebra.BLAS.syr2k!
— Functionsyr2k!(uplo, trans, alpha, A, B, beta, C)
対称行列 C
のランク-2k 更新を alpha*A*transpose(B) + alpha*B*transpose(A) + beta*C
または alpha*transpose(A)*B + alpha*transpose(B)*A + beta*C
として行います。これは trans
に従います。C
の uplo
三角形のみが使用されます。C
を返します。
LinearAlgebra.BLAS.syr2k
— Functionsyr2k(uplo, trans, alpha, A, B)
uplo
の三角行列 alpha*A*transpose(B) + alpha*B*transpose(A)
または alpha*transpose(A)*B + alpha*transpose(B)*A
を、trans
に従って返します。
syr2k(uplo, trans, A, B)
uplo
の三角行列を返します A*transpose(B) + B*transpose(A)
または transpose(A)*B + transpose(B)*A
、trans
に従って。
LinearAlgebra.BLAS.her2k!
— Functionher2k!(uplo, trans, alpha, A, B, beta, C)
エルミート行列 C
のランク-2k 更新を alpha*A*B' + alpha*B*A' + beta*C
または alpha*A'*B + alpha*B'*A + beta*C
の形で行います。これは trans
に従います。スカラー beta
は実数でなければなりません。C
の uplo
三角形のみが使用されます。C
を返します。
LinearAlgebra.BLAS.her2k
— Functionher2k(uplo, trans, alpha, A, B)
uplo
の三角行列を返します。これは alpha*A*B' + alpha*B*A'
または alpha*A'*B + alpha*B'*A
であり、trans
に応じて異なります。
LinearAlgebra.BLAS.trmm!
— Functiontrmm!(side, ul, tA, dA, alpha, A, B)
B
をalpha*A*B
またはside
とtA
によって決定される他の3つのバリアントのいずれかで更新します。A
のul
三角形のみが使用されます。dA
は対角値が読み取られるか、すべて1であると仮定されるかを決定します。更新されたB
を返します。
LinearAlgebra.BLAS.trmm
— Functiontrmm(side, ul, tA, dA, alpha, A, B)
alpha*A*B
または side
と tA
によって決定される他の3つのバリアントのいずれかを返します。A
の ul
三角形のみが使用されます。dA
は対角値が読み取られるか、すべてが1であると仮定されるかを決定します。
LinearAlgebra.BLAS.trsm!
— Functiontrsm!(side, ul, tA, dA, alpha, A, B)
B
をA*X = alpha*B
の解で上書きするか、side
とtA
によって決定される他の3つのバリアントのいずれかで上書きします。A
のul
三角形のみが使用されます。dA
は、対角値が読み取られるか、すべて1であると見なされるかを決定します。更新されたB
を返します。
LinearAlgebra.BLAS.trsm
— Functiontrsm(side, ul, tA, dA, alpha, A, B)
A*X = alpha*B
の解を返すか、side
とtA
によって決定される他の3つのバリアントのいずれかを返します。A
のul
三角形のみが使用されます。dA
は、対角値が読み取られるか、すべて1であると見なされるかを決定します。
LAPACK functions
LinearAlgebra.LAPACK
は、線形代数のためのいくつかのLAPACK関数のラッパーを提供します。入力配列の1つを上書きする関数は、名前が'!'
で終わります。
通常、関数には4つのメソッドが定義されており、それぞれ Float64
、Float32
、ComplexF64
および ComplexF32
配列に対応しています。
LAPACK APIはJuliaによって提供されており、将来的に変更される可能性があります。このAPIはユーザー向けではないため、将来のリリースでこの特定の関数セットをサポートまたは非推奨にすることに対するコミットメントはありません。
LinearAlgebra.LAPACK
— ModuleLAPACKサブルーチンへのインターフェース。
LinearAlgebra.LAPACK.gbtrf!
— Functiongbtrf!(kl, ku, m, AB) -> (AB, ipiv)
バンド行列 AB
のLU因子分解を計算します。kl
は非ゼロバンドを含む最初の下対角線、ku
はそれを含む最後の上対角線、m
は行列 AB
の最初の次元です。LU因子分解をインプレースで返し、使用されたピボットのベクトル ipiv
を返します。
LinearAlgebra.LAPACK.gbtrs!
— Functiongbtrs!(trans, kl, ku, m, AB, ipiv, B)
方程式 AB * X = B
を解きます。trans
は AB
の向きを決定します。N
(転置なし)、T
(転置)、または C
(共役転置)のいずれかです。kl
は非ゼロバンドを含む最初の下対角線、ku
はそれを含む最後の上対角線、m
は行列 AB
の最初の次元です。ipiv
は gbtrf!
から返されるピボットのベクトルです。ベクトルまたは行列 X
を返し、B
をその場で上書きします。
LinearAlgebra.LAPACK.gebal!
— Functiongebal!(job, A) -> (ilo, ihi, scale)
行列 A
の固有系またはシュア分解を計算する前に、行列をバランスします。job
は N
(A
は順序変更またはスケーリングされない)、P
(A
は順序変更のみ)、S
(A
はスケーリングのみ)、または B
(A
は順序変更およびスケーリングされる)のいずれかです。A
をインプレースで変更し、ilo
、ihi
、および scale
を返します。順序変更が有効な場合、A[i,j] = 0
となります(j > i
かつ 1 < j < ilo
または j > ihi
の場合)。scale
には、実行されたスケーリング/順序変更に関する情報が含まれています。
LinearAlgebra.LAPACK.gebak!
— Functiongebak!(job, side, ilo, ihi, scale, V)
gebal!
を使用してバランスされた行列の固有ベクトルV
を元の行列のスケールされていない/順序が変更されていない固有ベクトルに変換します。V
はインプレースで修正されます。side
はL
(左固有ベクトルが変換される)またはR
(右固有ベクトルが変換される)にすることができます。
LinearAlgebra.LAPACK.gebrd!
— Functiongebrd!(A) -> (A, d, e, tauq, taup)
行列 A
をインプレースで二重対角行列の形 A = QBP'
に変換します。返されるのは、二重対角行列 B
を含む A
、B
の対角要素を含む d
、B
の非対角要素を含む e
、Q
を表す基本反射体を含む tauq
、および P
を表す基本反射体を含む taup
です。
LinearAlgebra.LAPACK.gelqf!
— Functiongelqf!(A, tau)
行列 A
の LQ
因子分解を計算します。A = LQ
です。tau
には因子分解の基本反射をパラメータ化するスカラーが含まれています。tau
の長さは A
の最小次元以上でなければなりません。
A
と tau
はインプレースで変更されて返されます。
gelqf!(A) -> (A, tau)
行列 A
の LQ
分解を計算します。A = LQ
。
インプレースで変更された A
と、分解の基本反射をパラメータ化するスカラーを含む tau
を返します。
LinearAlgebra.LAPACK.geqlf!
— Functiongeqlf!(A, tau)
A
のQL
因子分解を計算します。A = QL
。tau
は因子分解の基本反射体をパラメータ化するスカラーを含みます。tau
はA
の最小次元以上の長さでなければなりません。
A
とtau
はインプレースで変更されて返されます。
geqlf!(A) -> (A, tau)
行列 A
の QL
因子分解を計算します。A = QL
。
A
をインプレースで変更し、因子分解の基本反射をパラメータ化するスカラーを含む tau
を返します。
LinearAlgebra.LAPACK.geqrf!
— Functiongeqrf!(A, tau)
行列 A
の QR
分解を計算します。A = QR
です。tau
には分解の基本反射体をパラメータ化するスカラーが含まれています。tau
の長さは A
の最小次元以上でなければなりません。
A
と tau
をインプレースで変更して返します。
geqrf!(A) -> (A, tau)
行列 A
の QR
分解を計算します。A = QR
。
インプレースで変更された A
と、分解の基本反射体をパラメータ化するスカラーを含む tau
を返します。
LinearAlgebra.LAPACK.geqp3!
— Functiongeqp3!(A, [jpvt, tau]) -> (A, tau, jpvt)
行列 A
のピボット付き QR
分解を計算します。AP = QR
を BLAS レベル 3 を使用して行います。P
はピボット行列で、jpvt
によって表されます。tau
は基本反射体を格納します。引数 jpvt
と tau
はオプションで、事前に割り当てられた配列を渡すことができます。渡された場合、jpvt
は A
が (m x n)
行列である場合、長さが n
以上でなければならず、tau
は A
の最小次元以上の長さでなければなりません。エントリ時に、jpvt[j]
がゼロでない場合、A
の j
番目の列は AP
の先頭に置き換えられます。
A
、jpvt
、および tau
はインプレースで変更されます。
LinearAlgebra.LAPACK.gerqf!
— Functiongerqf!(A, tau)
行列 A
の RQ
因子分解を計算します。A = RQ
です。tau
には因子分解の基本反射のパラメータとなるスカラーが含まれています。tau
の長さは A
の最小次元以上でなければなりません。
A
と tau
はインプレースで変更されて返されます。
gerqf!(A) -> (A, tau)
行列 A
の RQ
因子分解を計算します。すなわち、A = RQ
です。
A
をその場で修正し、因子分解の基本反射体をパラメータ化するスカラーを含む tau
を返します。
LinearAlgebra.LAPACK.geqrt!
— Functiongeqrt!(A, T)
行列 A
のブロック QR
分解を計算します。A = QR
です。T
には、分解の基本反射をパラメータ化する上三角ブロック反射が含まれています。T
の最初の次元はブロックサイズを設定し、1 と n
の間でなければなりません。T
の2番目の次元は A
の最小次元と等しくなければなりません。
A
と T
はインプレースで変更されて返されます。
geqrt!(A, nb) -> (A, T)
行列 A
のブロック QR
分解を計算します。A = QR
。nb
はブロックサイズを設定し、A
の第二次元である n
の間で1以上でなければなりません。
インプレースで変更された A
と、分解の基本反射をパラメータ化する上三角ブロック反射子を含む T
を返します。
LinearAlgebra.LAPACK.geqrt3!
— Functiongeqrt3!(A, T)
再帰的にブロック QR
分解を計算します。A = QR
。T
には、分解の基本反射をパラメータ化する上三角ブロック反射が含まれています。T
の最初の次元はブロックサイズを設定し、1 と n
の間でなければなりません。T
の2番目の次元は A
の最小次元と等しくなければなりません。
A
と T
をインプレースで変更して返します。
geqrt3!(A) -> (A, T)
行列 A
のブロック QR
分解を再帰的に計算します。A = QR
。
インプレースで変更された A
と、分解の基本反射をパラメータ化する上三角ブロック反射子を含む T
を返します。
LinearAlgebra.LAPACK.getrf!
— Functiongetrf!(A, ipiv) -> (A, ipiv, info)
行列 A
のピボット付き LU
分解を計算します。A = LU
。ipiv
にはピボット情報が含まれ、info
には成功を示すコード(info = 0
)、U
に特異値がある場合のコード(info = i
、この場合 U[i,i]
は特異)、またはエラーコード(info < 0
)が含まれます。
getrf!(A) -> (A, ipiv, info)
行列 A
のピボット付き LU
分解を計算します。A = LU
。
A
をインプレースで変更し、ピボティング情報 ipiv
と成功を示す info
コードを返します(info = 0
)、U
に特異値がある場合(info = i
の場合、U[i,i]
は特異)、またはエラーコード(info < 0
)。
LinearAlgebra.LAPACK.tzrzf!
— Functiontzrzf!(A) -> (A, tau)
上三角行列 A
をその場で上三角形の形に変換します。変換のための基本反射体のスカラーパラメータ tau
とともに A
を返します。
LinearAlgebra.LAPACK.ormrz!
— Functionormrz!(side, trans, A, tau, C)
行列 C
を、tzrzf!
によって供給された変換からの Q
で乗算します。side
または trans
に応じて、乗算は左側(side = L, Q*C
)または右側(side = R, C*Q
)で行われ、Q
は変更されない(trans = N
)、転置される(trans = T
)、または共役転置される(trans = C
)ことがあります。乗算の結果でインプレースで変更された行列 C
を返します。
LinearAlgebra.LAPACK.gels!
— Functiongels!(trans, A, B) -> (F, B, ssr)
線形方程式 A * X = B
、transpose(A) * X = B
、または adjoint(A) * X = B
を QR または LQ 因数分解を使用して解決します。解を持つ行列/ベクトル B
をその場で修正します。A
はその QR
または LQ
因数分解で上書きされます。trans
は N
(変更なし)、T
(転置)、または C
(共役転置)のいずれかである可能性があります。gels!
は最小ノルム/最小二乗解を検索します。A
は過小または過剰に決定されている可能性があります。解は B
に返されます。
LinearAlgebra.LAPACK.gesv!
— Functiongesv!(A, B) -> (B, A, ipiv)
線形方程式 A * X = B
を解きます。ここで A
は正方行列で、A
の LU
分解を使用します。A
はその LU
分解で上書きされ、B
は解 X
で上書きされます。ipiv
には A
の LU
分解のピボット情報が含まれています。
LinearAlgebra.LAPACK.getrs!
— Functiongetrs!(trans, A, ipiv, B)
線形方程式 A * X = B
、transpose(A) * X = B
、または adjoint(A) * X = B
を正方行列 A
に対して解きます。解を持つ行列/ベクトル B
をその場で修正します。A
は getrf!
からの LU
因子分解で、ipiv
はピボット情報です。trans
は N
(変更なし)、T
(転置)、または C
(共役転置)のいずれかです。
LinearAlgebra.LAPACK.getri!
— Functiongetri!(A, ipiv)
A
の逆行列を計算します。これはgetrf!
によって見つかったLU
因子分解を使用します。ipiv
は出力されたピボット情報であり、A
はgetrf!
のLU
因子分解を含んでいます。A
はその逆行列で上書きされます。
LinearAlgebra.LAPACK.gesvx!
— Functiongesvx!(fact, trans, A, AF, ipiv, equed, R, C, B) -> (X, equed, R, C, B, rcond, ferr, berr, work)
線形方程式 A * X = B
(trans = N
)、transpose(A) * X = B
(trans = T
)、または adjoint(A) * X = B
(trans = C
) を A
の LU
因数分解を使用して解きます。fact
は E
である場合、A
は平衡化されて AF
にコピーされます; F
である場合、AF
と ipiv
は以前の LU
因数分解からの入力です; または N
である場合、A
は AF
にコピーされ、その後因数分解されます。fact = F
の場合、equed
は N
であり、これは A
が平衡化されていないことを意味します; R
は A
が左から Diagonal(R)
で乗算されたことを意味します; C
は A
が右から Diagonal(C)
で乗算されたことを意味します; または B
は A
が左から Diagonal(R)
で、右から Diagonal(C)
で乗算されたことを意味します。fact = F
で equed = R
または B
の場合、R
の要素はすべて正でなければなりません。fact = F
で equed = C
または B
の場合、C
の要素はすべて正でなければなりません。
解 X
を返します; equed
は fact
が N
でない場合の出力であり、実行された平衡化を説明します; R
は行の平衡化対角行列; C
は列の平衡化対角行列; B
はその平衡化された形 Diagonal(R)*B
で上書きされる可能性があります(trans = N
かつ equed = R,B
の場合)または Diagonal(C)*B
(trans = T,C
かつ equed = C,B
の場合); rcond
は平衡化後の A
の逆条件数; ferr
は X
の各解ベクトルの前方誤差境界; berr
は X
の各解ベクトルの前方誤差境界; および work
は逆ピボット成長因子です。
gesvx!(A, B)
gesvx!
の非スケーリング、非転置の簡略化。
LinearAlgebra.LAPACK.gelsd!
— Functiongelsd!(A, B, rcond) -> (B, rnk)
A * X = B
の最小ノルム解を計算します。これは A
の SVD
因子分解を見つけ、その後問題を分割して解決します。B
は解 X
で上書きされます。rcond
以下の特異値はゼロとして扱われます。解は B
に返され、A
の有効ランクは rnk
に返されます。
LinearAlgebra.LAPACK.gelsy!
— Functiongelsy!(A, B, rcond) -> (B, rnk)
行列 A * X = B
の最小ノルム解を計算します。これは、A
の完全な QR
分解を見つけ、その後問題を分割して解決することによって行われます。B
は解 X
で上書きされます。特異値が rcond
未満の場合はゼロとして扱われます。解は B
に返され、A
の有効ランクは rnk
に返されます。
LinearAlgebra.LAPACK.gglse!
— Functiongglse!(A, c, B, d) -> (X,res)
方程式 A * x = c
を解きます。ここで x
は等式制約 B * x = d
に従います。式 ||c - A*x||^2 = 0
を使用して解決します。X
と残差の二乗和を返します。
LinearAlgebra.LAPACK.geev!
— Functiongeev!(jobvl, jobvr, A) -> (W, VL, VR)
行列 A
の固有系を求めます。jobvl = N
の場合、A
の左固有ベクトルは計算されません。jobvr = N
の場合、A
の右固有ベクトルは計算されません。jobvl = V
または jobvr = V
の場合、対応する固有ベクトルが計算されます。固有値は W
に、右固有ベクトルは VR
に、左固有ベクトルは VL
に返されます。
LinearAlgebra.LAPACK.gesdd!
— Functiongesdd!(job, A) -> (U, S, VT)
行列 A
の特異値分解を見つけます。A = U * S * V'
の形で、分割統治法を使用します。job = A
の場合、U
のすべての列と V'
のすべての行が計算されます。job = N
の場合、U
の列や V'
の行は計算されません。job = O
の場合、A
は (薄い) U
の列と (薄い) V'
の行で上書きされます。job = S
の場合、(薄い) U
の列と (薄い) V'
の行が計算され、別々に返されます。
LinearAlgebra.LAPACK.gesvd!
— Functiongesvd!(jobu, jobvt, A) -> (U, S, VT)
A
の特異値分解を見つけます。A = U * S * V'
。jobu = A
の場合、U
のすべての列が計算されます。jobvt = A
の場合、V'
のすべての行が計算されます。jobu = N
の場合、U
の列は計算されません。jobvt = N
の場合、V'
の行は計算されません。jobu = O
の場合、A
は(薄い)U
の列で上書きされます。jobvt = O
の場合、A
は(薄い)V'
の行で上書きされます。jobu = S
の場合、(薄い)U
の列が計算され、別々に返されます。jobvt = S
の場合、(薄い)V'
の行が計算され、別々に返されます。jobu
とjobvt
は両方ともO
にすることはできません。
U
、S
、およびVt
を返します。ここで、S
はA
の特異値です。
LinearAlgebra.LAPACK.ggsvd!
— Functionggsvd!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)
A
と B
の一般化特異値分解を見つけます。U'*A*Q = D1*R
および V'*B*Q = D2*R
です。D1
の対角には alpha
があり、D2
の対角には beta
が存在します。jobu = U
の場合、直交/ユニタリ行列 U
が計算されます。jobv = V
の場合、直交/ユニタリ行列 V
が計算されます。jobq = Q
の場合、直交/ユニタリ行列 Q
が計算されます。jobu
、jobv
または jobq
が N
の場合、その行列は計算されません。この関数は LAPACK バージョン 3.6.0 より前のバージョンでのみ利用可能です。
LinearAlgebra.LAPACK.ggsvd3!
— Functionggsvd3!(jobu, jobv, jobq, A, B) -> (U, V, Q, alpha, beta, k, l, R)
A
とB
の一般化特異値分解を見つけます。U'*A*Q = D1*R
およびV'*B*Q = D2*R
です。D1
の対角にはalpha
があり、D2
の対角にはbeta
があります。jobu = U
の場合、直交/ユニタリ行列U
が計算されます。jobv = V
の場合、直交/ユニタリ行列V
が計算されます。jobq = Q
の場合、直交/ユニタリ行列Q
が計算されます。jobu
、jobv
、またはjobq
がN
の場合、その行列は計算されません。この関数はLAPACK 3.6.0を必要とします。
LinearAlgebra.LAPACK.geevx!
— Functiongeevx!(balanc, jobvl, jobvr, sense, A) -> (A, w, VL, VR, ilo, ihi, scale, abnrm, rconde, rcondv)
行列 A
の固有系を行列バランシングを用いて求めます。jobvl = N
の場合、A
の左固有ベクトルは計算されません。jobvr = N
の場合、A
の右固有ベクトルは計算されません。jobvl = V
または jobvr = V
の場合、対応する固有ベクトルが計算されます。balanc = N
の場合、バランシングは行われません。balanc = P
の場合、A
は順序が変更されますが、スケーリングは行われません。balanc = S
の場合、A
はスケーリングされますが、順序は変更されません。balanc = B
の場合、A
は順序が変更され、スケーリングされます。sense = N
の場合、逆条件数は計算されません。sense = E
の場合、固有値のみに対して逆条件数が計算されます。sense = V
の場合、右固有ベクトルのみに対して逆条件数が計算されます。sense = B
の場合、右固有ベクトルと固有ベクトルの両方に対して逆条件数が計算されます。sense = E,B
の場合、右および左の固有ベクトルが計算される必要があります。
LinearAlgebra.LAPACK.ggev!
— Functionggev!(jobvl, jobvr, A, B) -> (alpha, beta, vl, vr)
A
とB
の一般化固有分解を求めます。jobvl = N
の場合、左固有ベクトルは計算されません。jobvr = N
の場合、右固有ベクトルは計算されません。jobvl = V
またはjobvr = V
の場合、対応する固有ベクトルが計算されます。
LinearAlgebra.LAPACK.ggev3!
— Functionggev3!(jobvl, jobvr, A, B) -> (alpha, beta, vl, vr)
A
と B
の一般化固有分解をブロックアルゴリズムを使用して求めます。jobvl = N
の場合、左固有ベクトルは計算されません。jobvr = N
の場合、右固有ベクトルは計算されません。jobvl = V
または jobvr = V
の場合、対応する固有ベクトルが計算されます。この関数は LAPACK 3.6.0 を必要とします。
LinearAlgebra.LAPACK.gtsv!
— Functiongtsv!(dl, d, du, B)
方程式 A * X = B
を解きます。ここで A
は下対角成分が dl
、対角成分が d
、上対角成分が du
の三重対角行列です。
B
を解 X
で上書きし、それを返します。
LinearAlgebra.LAPACK.gttrf!
— Functiongttrf!(dl, d, du) -> (dl, d, du, du2, ipiv)
三重対角行列の LU
因子分解を見つけます。dl
は下対角、d
は対角、du
は上対角にあります。
dl
、d
、および du
をインプレースで変更し、それらと第二の上対角 du2
およびピボットベクトル ipiv
を返します。
LinearAlgebra.LAPACK.gttrs!
— Functiongttrs!(trans, dl, d, du, du2, ipiv, B)
方程式 A * X = B
(trans = N
)、transpose(A) * X = B
(trans = T
)、または adjoint(A) * X = B
(trans = C
) を gttrf!
によって計算された LU
因子分解を使用して解きます。B
は解 X
で上書きされます。
LinearAlgebra.LAPACK.orglq!
— Functionorglq!(A, tau, k = length(tau))
gelqf!
をA
に呼び出した後、LQ
因子分解の行列Q
を明示的に求めます。gelqf!
の出力を使用します。A
はQ
で上書きされます。
LinearAlgebra.LAPACK.orgqr!
— Functionorgqr!(A, tau, k = length(tau))
geqrf!
をA
に呼び出した後に、QR
分解の行列Q
を明示的に求めます。geqrf!
の出力を使用します。A
はQ
で上書きされます。
LinearAlgebra.LAPACK.orgql!
— Functionorgql!(A, tau, k = length(tau))
geqlf!
をA
に呼び出した後、QL
因子分解の行列Q
を明示的に求めます。geqlf!
の出力を使用します。A
はQ
で上書きされます。
LinearAlgebra.LAPACK.orgrq!
— Functionorgrq!(A, tau, k = length(tau))
gerqf!
をA
に対して呼び出した後に、RQ
因子分解の行列Q
を明示的に求めます。gerqf!
の出力を使用します。A
はQ
で上書きされます。
LinearAlgebra.LAPACK.ormlq!
— Functionormlq!(side, trans, A, tau, C)
Q * C
を計算します(trans = N
)、transpose(Q) * C
(trans = T
)、adjoint(Q) * C
(trans = C
)で side = L
の場合、または side = R
の場合は gelqf!
を使用して計算された A
の LQ
分解からの Q
を使用して同等の右側の乗算を行います。C
は上書きされます。
LinearAlgebra.LAPACK.ormqr!
— Functionormqr!(side, trans, A, tau, C)
Q * C
を計算します(trans = N
)、transpose(Q) * C
(trans = T
)、adjoint(Q) * C
(trans = C
)は side = L
の場合、または side = R
の場合は同等の右側の乗算を行います。A
の QR
因数分解から得られた Q
を使用し、geqrf!
を用いて計算されます。C
は上書きされます。
LinearAlgebra.LAPACK.ormql!
— Functionormql!(side, trans, A, tau, C)
Q * C
を計算します(trans = N
)、transpose(Q) * C
(trans = T
)、adjoint(Q) * C
(trans = C
)で side = L
または side = R
の場合は A
の geqlf!
を使用して計算された QL
因子分解からの Q
を使用します。C
は上書きされます。
LinearAlgebra.LAPACK.ormrq!
— Functionormrq!(side, trans, A, tau, C)
Q * C
を計算します(trans = N
)、transpose(Q) * C
(trans = T
)、adjoint(Q) * C
(trans = C
)は side = L
の場合、または side = R
の場合は gerqf!
を使用して計算された A
の RQ
因数分解からの Q
を使用して同等の右側の乗算を行います。C
は上書きされます。
LinearAlgebra.LAPACK.gemqrt!
— Functiongemqrt!(side, trans, V, T, C)
Q * C
を計算します(trans = N
)、transpose(Q) * C
(trans = T
)、adjoint(Q) * C
(trans = C
)を side = L
の場合、または geqrt!
を使用して計算された A
の QR
分解からの Q
を使用して side = R
の場合の同等の右側の乗算を行います。C
は上書きされます。
LinearAlgebra.LAPACK.posv!
— Functionposv!(uplo, A, B) -> (A, B)
A * X = B
の解を見つけます。ここで A
は対称またはエルミートの正定値行列です。uplo = U
の場合、A
の上三角コレスキー分解が計算されます。uplo = L
の場合、A
の下三角コレスキー分解が計算されます。A
はそのコレスキー分解で上書きされます。B
は解 X
で上書きされます。
LinearAlgebra.LAPACK.potrf!
— Functionpotrf!(uplo, A)
正定行列 A
のコレスキー分解(uplo = U
の場合は上三角、uplo = L
の場合は下三角)を計算します。A
は上書きされ、情報コードと共に返されます。
LinearAlgebra.LAPACK.potri!
— Functionpotri!(uplo, A)
正定行列 A
の逆行列を計算します。これは、(uplo = U の場合は上三角、uplo = L の場合は下三角の) コレスキー分解を見つけるために potrf!
を呼び出した後に行われます。
A
はその逆行列で上書きされ、返されます。
LinearAlgebra.LAPACK.potrs!
— Functionpotrs!(uplo, A, B)
A * X = B
の解を求めます。ここで、A
は potrf!
によって計算されたコレスキー分解を持つ対称またはエルミートの正定値行列です。uplo = U
の場合、A
の上三角コレスキー分解が計算されました。uplo = L
の場合、A
の下三角コレスキー分解が計算されました。B
は解 X
で上書きされます。
LinearAlgebra.LAPACK.pstrf!
— Functionpstrf!(uplo, A, tol) -> (A, piv, rank, info)
正定行列 A
の(uplo = U
の場合は上三角、uplo = L
の場合は下三角)ピボット付きコレスキー分解を、ユーザーが設定した許容誤差 tol
で計算します。A
はそのコレスキー分解で上書きされます。
A
、ピボット piv
、A
のランク、および info
コードを返します。info = 0
の場合、因子分解は成功しました。info = i > 0
の場合、A
は不定またはランク不足です。
LinearAlgebra.LAPACK.ptsv!
— Functionptsv!(D, E, B)
正定三重対角行列 A
に対して A * X = B
を解きます。D
は A
の対角成分で、E
は副対角成分です。B
は解 X
で上書きされ、返されます。
LinearAlgebra.LAPACK.pttrf!
— Functionpttrf!(D, E)
正定三対角行列のLDLt因子分解を計算します。D
は対角成分、E
は非対角成分です。D
とE
は上書きされ、返されます。
LinearAlgebra.LAPACK.pttrs!
— Functionpttrs!(D, E, B)
正定三対角行列 A
に対して A * X = B
を解きます。ここで、対角成分は D
、非対角成分は E
です。A
の LDLt 因子分解を pttrf!
を使用して計算した後、B
は解 X
で上書きされます。
LinearAlgebra.LAPACK.trtri!
— Functiontrtri!(uplo, diag, A)
上三角行列 A
の逆行列を求めます(uplo = U
の場合は上、uplo = L
の場合は下)。diag = N
の場合、A
は単位でない対角要素を持ちます。diag = U
の場合、A
のすべての対角要素は1です。A
はその逆行列で上書きされます。
LinearAlgebra.LAPACK.trtrs!
— Functiontrtrs!(uplo, trans, diag, A, B)
A * X = B
を解きます(trans = N
)、transpose(A) * X = B
(trans = T
)、または adjoint(A) * X = B
(trans = C)
、(上三角行列の場合は uplo = U
、下三角行列の場合は uplo = L
) の行列 A
に対して。diag = N
の場合、A
は非単位対角要素を持ちます。diag = U
の場合、A
のすべての対角要素は1です。B
は解 X
で上書きされます。
LinearAlgebra.LAPACK.trcon!
— Functiontrcon!(norm, uplo, diag, A)
三角行列 A
の逆条件数を求めます(uplo = U
の場合は上三角、uplo = L
の場合は下三角)。diag = N
の場合、A
は単位でない対角要素を持ちます。diag = U
の場合、A
のすべての対角要素は1です。norm = I
の場合、条件数は無限大ノルムで求められます。norm = O
または 1
の場合、条件数は1ノルムで求められます。
LinearAlgebra.LAPACK.trevc!
— Functiontrevc!(side, howmny, select, T, VL = similar(T), VR = similar(T))
上三角行列 T
の固有系を求めます。side = R
の場合、右固有ベクトルが計算されます。side = L
の場合、左固有ベクトルが計算されます。side = B
の場合、両方のセットが計算されます。howmny = A
の場合、すべての固有ベクトルが見つかります。howmny = B
の場合、すべての固有ベクトルが見つかり、VL
と VR
を使用して逆変換されます。howmny = S
の場合、select
に対応する値の固有ベクトルのみが計算されます。
LinearAlgebra.LAPACK.trrfs!
— Functiontrrfs!(uplo, trans, diag, A, B, X, Ferr, Berr) -> (Ferr, Berr)
A * X = B
の解の誤差を推定します(trans = N
)、transpose(A) * X = B
(trans = T
)、adjoint(A) * X = B
(trans = C
)で side = L
の場合、または trtrs!
を使用して X
を計算した後の右側の side = R
X * A
の同等の方程式。uplo = U
の場合、A
は上三角行列です。uplo = L
の場合、A
は下三角行列です。diag = N
の場合、A
は単位でない対角要素を持ちます。diag = U
の場合、A
のすべての対角要素は1です。Ferr
と Berr
はオプションの入力です。Ferr
は前方誤差で、Berr
は後方誤差であり、それぞれ成分ごとです。
LinearAlgebra.LAPACK.stev!
— Functionstev!(job, dv, ev) -> (dv, Zmat)
対称トリディアゴナル行列の固有系を計算します。dv
は対角成分、ev
は非対角成分です。job = N
の場合、固有値のみが見つかり、dv
に返されます。job = V
の場合、固有ベクトルも見つかり、Zmat
に返されます。
LinearAlgebra.LAPACK.stebz!
— Functionstebz!(range, order, vl, vu, il, iu, abstol, dv, ev) -> (dv, iblock, isplit)
対称トリディアゴナル行列の固有値を計算します。dv
は対角成分、ev
は非対角成分です。range = A
の場合、すべての固有値が見つかります。range = V
の場合、半開区間 (vl, vu]
内の固有値が見つかります。range = I
の場合、インデックスが il
と iu
の間にある固有値が見つかります。order = B
の場合、固有値はブロック内で順序付けられます。order = E
の場合、すべてのブロック間で順序付けられます。abstol
は収束のための許容誤差として設定できます。
LinearAlgebra.LAPACK.stegr!
— Functionstegr!(jobz, range, dv, ev, vl, vu, il, iu) -> (w, Z)
対称三重対角行列の固有値(jobz = N
)または固有値と固有ベクトル(jobz = V
)を計算します。dv
が対角成分、ev
が非対角成分です。range = A
の場合、すべての固有値が見つかります。range = V
の場合、半開区間(vl, vu]
内の固有値が見つかります。range = I
の場合、インデックスがil
とiu
の間の固有値が見つかります。固有値はw
に、固有ベクトルはZ
に返されます。
LinearAlgebra.LAPACK.stein!
— Functionstein!(dv, ev_in, w_in, iblock_in, isplit_in)
対称トリディアゴナル行列の固有ベクトルを計算します。dv
は対角成分、ev_in
は非対角成分です。w_in
は対応する固有ベクトルを見つけるための入力固有値を指定します。iblock_in
はw_in
の固有値に対応するサブ行列を指定します。isplit_in
はサブ行列ブロック間の分割点を指定します。
LinearAlgebra.LAPACK.syconv!
— Functionsyconv!(uplo, A, ipiv) -> (A, work)
対称行列 A
(三角行列に因数分解されたもの)を二つの行列 L
と D
に変換します。uplo = U
の場合、A
は上三角行列です。uplo = L
の場合、下三角行列です。ipiv
は三角因数分解からのピボットベクトルです。A
は L
と D
で上書きされます。
LinearAlgebra.LAPACK.sysv!
— Functionsysv!(uplo, A, B) -> (B, A, ipiv)
対称行列 A
に対する A * X = B
の解を見つけます。uplo = U
の場合、A
の上半分が格納されます。uplo = L
の場合、下半分が格納されます。B
は解 X
で上書きされます。A
はそのバンチ-カウフマン因子分解で上書きされます。ipiv
には因子分解に関するピボット情報が含まれています。
LinearAlgebra.LAPACK.sytrf!
— Functionsytrf!(uplo, A) -> (A, ipiv, info)
対称行列 A
のバンチ-カウフマン因子分解を計算します。uplo = U
の場合、A
の上半分が格納されます。uplo = L
の場合、下半分が格納されます。
因子分解によって上書きされた A
、ピボットベクトル ipiv
、およびエラーコード info
(非負整数)を返します。info
が正の場合、行列は特異であり、因子分解の対角部分は位置 info
で正確にゼロになります。
sytrf!(uplo, A, ipiv) -> (A, ipiv, info)
対称行列 A
のバンチ-カウフマン因子分解を計算します。uplo = U
の場合、A
の上半分が格納されます。uplo = L
の場合、下半分が格納されます。
因子分解によって上書きされた A
、ピボットベクトル ipiv
、およびエラーコード info
を返します。info
が非負の整数である場合、info
が正の場合、行列は特異であり、因子分解の対角部分は位置 info
で正確にゼロです。
LinearAlgebra.LAPACK.sytri!
— Functionsytri!(uplo, A, ipiv)
対称行列 A
の逆行列を sytrf!
の結果を使用して計算します。uplo = U
の場合、A
の上半分が格納されます。uplo = L
の場合、下半分が格納されます。A
はその逆行列で上書きされます。
LinearAlgebra.LAPACK.sytrs!
— Functionsytrs!(uplo, A, ipiv, B)
対称行列 A
に対して A * X = B
の方程式を sytrf!
の結果を使用して解きます。uplo = U
の場合、A
の上半分が格納されます。uplo = L
の場合、下半分が格納されます。B
は解 X
で上書きされます。
LinearAlgebra.LAPACK.hesv!
— Functionhesv!(uplo, A, B) -> (B, A, ipiv)
エルミート行列 A
に対する A * X = B
の解を見つけます。uplo = U
の場合、A
の上半分が保存されます。uplo = L
の場合、下半分が保存されます。B
は解 X
で上書きされます。A
はそのバンチ-カウフマン因子分解で上書きされます。ipiv
には因子分解に関するピボッティング情報が含まれています。
LinearAlgebra.LAPACK.hetrf!
— Functionhetrf!(uplo, A) -> (A, ipiv, info)
エルミート行列 A
のバンチ-カウフマン因子分解を計算します。uplo = U
の場合、A
の上半分が格納されます。uplo = L
の場合、下半分が格納されます。
因子分解によって上書きされた A
、ピボットベクトル ipiv
、およびエラーコード info
を返します。info
が非負の整数で、正の値の場合、行列は特異であり、因子分解の対角部分は位置 info
で正確にゼロになります。
hetrf!(uplo, A, ipiv) -> (A, ipiv, info)
エルミート行列 A
のバンチ-カウフマン因子分解を計算します。uplo = U
の場合、A
の上半分が格納されます。uplo = L
の場合、下半分が格納されます。
因子分解によって上書きされた A
、ピボットベクトル ipiv
、および非負整数のエラーコード info
を返します。info
が正の場合、行列は特異であり、因子分解の対角部分は位置 info
で正確にゼロになります。
LinearAlgebra.LAPACK.hetri!
— Functionhetri!(uplo, A, ipiv)
エルミート行列 A
の逆行列を sytrf!
の結果を使用して計算します。uplo = U
の場合、A
の上半分が格納されます。uplo = L
の場合、下半分が格納されます。A
はその逆行列で上書きされます。
LinearAlgebra.LAPACK.hetrs!
— Functionhetrs!(uplo, A, ipiv, B)
エルミート行列 A
に対して A * X = B
の方程式を sytrf!
の結果を使用して解きます。uplo = U
の場合、A
の上半分が格納されます。uplo = L
の場合、下半分が格納されます。B
は解 X
で上書きされます。
LinearAlgebra.LAPACK.syev!
— Functionsyev!(jobz, uplo, A)
対称行列 A
の固有値(jobz = N
)または固有値と固有ベクトル(jobz = V
)を求めます。uplo = U
の場合、A
の上三角が使用されます。uplo = L
の場合、A
の下三角が使用されます。
LinearAlgebra.LAPACK.syevr!
— Functionsyevr!(jobz, range, uplo, A, vl, vu, il, iu, abstol) -> (W, Z)
対称行列 A
の固有値(jobz = N
)または固有値と固有ベクトル(jobz = V
)を求めます。uplo = U
の場合、A
の上三角部分が使用されます。uplo = L
の場合、A
の下三角部分が使用されます。range = A
の場合、すべての固有値が求められます。range = V
の場合、半開区間 (vl, vu]
内の固有値が求められます。range = I
の場合、インデックスが il
と iu
の間にある固有値が求められます。abstol
は収束のための許容誤差として設定できます。
固有値は W
に、固有ベクトルは Z
に返されます。
LinearAlgebra.LAPACK.syevd!
— Functionsyevd!(jobz, uplo, A)
対称行列 A
の固有値(jobz = N
)または固有値と固有ベクトル(jobz = V
)を求めます。uplo = U
の場合、A
の上三角が使用されます。uplo = L
の場合、A
の下三角が使用されます。
syev!
によって使用される QR 反復法や、syevr!
によって使用される複数の比較的堅牢な表現の代わりに、分割統治法を使用します。異なる手法の精度と性能の比較については、James W. Demmel らによる SIAM J. Sci. Comput. 30, 3, 1508 (2008) を参照してください。
LinearAlgebra.LAPACK.sygvd!
— Functionsygvd!(itype, jobz, uplo, A, B) -> (w, A, B)
対称行列 A
と対称正定値行列 B
の一般化固有値(jobz = N
)または固有値と固有ベクトル(jobz = V
)を求めます。uplo = U
の場合、A
と B
の上三角が使用されます。uplo = L
の場合、A
と B
の下三角が使用されます。itype = 1
の場合、解くべき問題は A * x = lambda * B * x
です。itype = 2
の場合、解くべき問題は A * B * x = lambda * x
です。itype = 3
の場合、解くべき問題は B * A * x = lambda * x
です。
LinearAlgebra.LAPACK.bdsqr!
— Functionbdsqr!(uplo, d, e_, Vt, U, C) -> (d, Vt, U, C)
バイディアゴナル行列の特異値分解を計算します。対角に d
、副対角に e_
が配置されています。uplo = U
の場合、e_
は上対角線です。uplo = L
の場合、e_
は下対角線です。オプションで、Q' * C
の積も計算できます。
特異値は d
に返され、行列 C
は Q' * C
で上書きされます。
LinearAlgebra.LAPACK.bdsdc!
— Functionbdsdc!(uplo, compq, d, e_) -> (d, e, u, vt, q, iq)
バイディアゴナル行列の特異値分解を計算します。対角に d
、オフ対角に e_
を持ち、分割統治法を使用します。uplo = U
の場合、e_
は上対角線です。uplo = L
の場合、e_
は下対角線です。compq = N
の場合、特異値のみが求められます。compq = I
の場合、特異値とベクトルが求められます。compq = P
の場合、特異値とベクトルがコンパクトな形で求められます。実数型のみに対応しています。
特異値は d
に返され、compq = P
の場合、コンパクトな特異ベクトルは iq
に返されます。
LinearAlgebra.LAPACK.gecon!
— Functiongecon!(normtype, A, anorm)
行列 A
の逆条件数を求めます。normtype = I
の場合、条件数は無限大ノルムで求められます。normtype = O
または 1
の場合、条件数は1ノルムで求められます。A
は getrf!
の結果でなければならず、anorm
は関連するノルムにおける A
のノルムです。
LinearAlgebra.LAPACK.gehrd!
— Functiongehrd!(ilo, ihi, A) -> (A, tau)
行列 A
をヘッセンベルグ形式に変換します。もし A
が gebal!
でバランスされている場合、ilo
と ihi
は gebal!
の出力です。そうでない場合、ilo = 1
および ihi = size(A,2)
であるべきです。tau
には因子分解の基本反射体が含まれています。
LinearAlgebra.LAPACK.orghr!
— Functionorghr!(ilo, ihi, A, tau)
明示的に gehrd!
からの直交/ユニタリ行列 Q
を求めます。ilo
、ihi
、A
、および tau
は gehrd!
への入力/出力に対応している必要があります。
LinearAlgebra.LAPACK.gees!
— Functiongees!(jobvs, A) -> (A, vs, w)
行列 A
の固有値(jobvs = N
)または固有値とシュルベクトル(jobvs = V
)を計算します。A
はそのシュル形式で上書きされます。
A
、シュルベクトルを含む vs
、および固有値を含む w
を返します。
LinearAlgebra.LAPACK.gges!
— Functiongges!(jobvsl, jobvsr, A, B) -> (A, B, alpha, beta, vsl, vsr)
一般化固有値、一般化シュア形式、左シュアベクトル(jobsvl = V
)、または右シュアベクトル(jobvsr = V
)を A
と B
のために計算します。
一般化固有値は alpha
と beta
に返されます。左シュアベクトルは vsl
に、右シュアベクトルは vsr
に返されます。
LinearAlgebra.LAPACK.gges3!
— Functiongges3!(jobvsl, jobvsr, A, B) -> (A, B, alpha, beta, vsl, vsr)
一般化固有値、一般化シュール形式、左シュールベクトル(jobsvl = V
)、または右シュールベクトル(jobvsr = V
)をブロックアルゴリズムを使用して A
と B
のために計算します。この関数は LAPACK 3.6.0 を必要とします。
一般化固有値は alpha
と beta
に返されます。左シュールベクトルは vsl
に、右シュールベクトルは vsr
に返されます。
LinearAlgebra.LAPACK.trexc!
— Functiontrexc!(compq, ifst, ilst, T, Q) -> (T, Q)
trexc!(ifst, ilst, T, Q) -> (T, Q)
行列のシュア分解 T
を再配置し、行インデックス ifst
の T
の対角ブロックを行インデックス ilst
に移動します。compq = V
の場合、シュアベクトル Q
が再配置されます。compq = N
の場合は変更されません。4引数のメソッドは、compq = V
で5引数のメソッドを呼び出します。
LinearAlgebra.LAPACK.trsen!
— Function行列のシュア分解を再順序付けし、オプションで逆条件数を求めます。`job = N` の場合、条件数は求められません。`job = E` の場合、この固有値のクラスターの条件数のみが求められます。`job = V` の場合、不変部分空間の条件数のみが求められます。`job = B` の場合、クラスターと部分空間の条件数が求められます。`compq = V` の場合、シュアベクトル `Q` が更新されます。`compq = N` の場合、シュアベクトルは変更されません。`select` は、どの固有値がクラスターに含まれるかを決定します。3引数メソッドは、`job = N` および `compq = V` で5引数メソッドを呼び出します。
`T`、`Q`、再順序付けされた固有値 `w`、固有値のクラスターの条件数 `s`、および不変部分空間の条件数 `sep` を返します。
LinearAlgebra.LAPACK.tgsen!
— Functiontgsen!(select, S, T, Q, Z) -> (S, T, alpha, beta, Q, Z)
一般化シュア分解のベクトルを再配置します。select
は各クラスター内の固有値を指定します。
LinearAlgebra.LAPACK.trsyl!
— Functiontrsyl!(transa, transb, A, B, C, isgn=1) -> (C, scale)
シルベスター行列方程式 A * X +/- X * B = scale*C
を解きます。ここで A
と B
はどちらも準上三角行列です。transa = N
の場合、A
は変更されません。transa = T
の場合、A
は転置されます。transa = C
の場合、A
は共役転置されます。同様に transb
と B
にも適用されます。isgn = 1
の場合、方程式 A * X + X * B = scale * C
が解かれます。isgn = -1
の場合、方程式 A * X - X * B = scale * C
が解かれます。
X
(C
を上書き)と scale
を返します。
LinearAlgebra.LAPACK.hseqr!
— Functionhseqr!(job, compz, ilo, ihi, H, Z) -> (H, Z, w)
行列をヘッセンベルグ形式に減少させたときのすべての固有値と(オプションで)シュール因子分解を計算します。H
がgebal!
でバランスされている場合、ilo
とihi
はgebal!
の出力です。そうでない場合、ilo = 1
およびihi = size(H,2)
とする必要があります。tau
には因子分解の基本反射体が含まれています。
- ACM832Davis, Timothy A. (2004b). Algorithm 832: UMFPACK V4.3–-an Unsymmetric-Pattern Multifrontal Method. ACM Trans. Math. Softw., 30(2), 196–199. doi:10.1145/992200.992206
- ACM887Chen, Y., Davis, T. A., Hager, W. W., & Rajamanickam, S. (2008). Algorithm 887: CHOLMOD, Supernodal Sparse Cholesky Factorization and Update/Downdate. ACM Trans. Math. Softw., 35(3). doi:10.1145/1391989.1391995
- DavisHager2009Davis, Timothy A., & Hager, W. W. (2009). Dynamic Supernodes in Sparse Cholesky Update/Downdate and Triangular Solves. ACM Trans. Math. Softw., 35(4). doi:10.1145/1462173.1462176
- Bischof1987C Bischof and C Van Loan, "The WY representation for products of Householder matrices", SIAM J Sci Stat Comput 8 (1987), s2-s13. doi:10.1137/0908009
- Schreiber1989R Schreiber and C Van Loan, "A storage-efficient WY representation for products of Householder transformations", SIAM J Sci Stat Comput 10 (1989), 53-57. doi:10.1137/0910005
- ACM933Foster, L. V., & Davis, T. A. (2013). Algorithm 933: Reliable Calculation of Numerical Rank, Null Space Bases, Pseudoinverse Solutions, and Basic Solutions Using SuitesparseQR. ACM Trans. Math. Softw., 40(1). doi:10.1145/2513109.2513116
- Bunch1977J R Bunch と L Kaufman, 一部の安定した方法による慣性の計算と対称線形システムの解法, Mathematics of Computation 31:137 (1977), 163-179. url.
- issue8859Issue 8859, "Fix least squares", https://github.com/JuliaLang/julia/pull/8859
- B96Åke Björck, "Numerical Methods for Least Squares Problems", SIAM Press, Philadelphia, 1996, "Other Titles in Applied Mathematics", Vol. 51. doi:10.1137/1.9781611971484
- S84G. W. Stewart, "Rank Degeneracy", SIAM Journal on Scientific and Statistical Computing, 5(2), 1984, 403-413. doi:10.1137/0905030
- KY88Konstantinos Konstantinides and Kung Yao, "Statistical analysis of effective singular values in matrix rank determination", IEEE Transactions on Acoustics, Speech and Signal Processing, 36(5), 1988, 757-763. doi:10.1109/29.1585
- H05Nicholas J. Higham, "The squaring and scaling method for the matrix exponential revisited", SIAM Journal on Matrix Analysis and Applications, 26(4), 2005, 1179-1193. doi:10.1137/090768539
- BH83Åke Björck and Sven Hammarling, "A Schur method for the square root of a matrix", Linear Algebra and its Applications, 52-53, 1983, 127-140. doi:10.1016/0024-3795(83)80010-X
- H87Nicholas J. Higham, "Computing real square roots of a real matrix", Linear Algebra and its Applications, 88-89, 1987, 405-430. doi:10.1016/0024-3795(87)90118-2
- S03Matthew I. Smith, "A Schur Algorithm for Computing Matrix pth Roots", SIAM Journal on Matrix Analysis and Applications, vol. 24, 2003, pp. 971–989. doi:10.1137/S0895479801392697
- AH16_1Mary Aprahamian と Nicholas J. Higham, "Matrix Inverse Trigonometric and Inverse Hyperbolic Functions: Theory and Algorithms", MIMS EPrint: 2016.4. https://doi.org/10.1137/16M1057577
- AH16_2Mary Aprahamian と Nicholas J. Higham, "Matrix Inverse Trigonometric and Inverse Hyperbolic Functions: Theory and Algorithms", MIMS EPrint: 2016.4. https://doi.org/10.1137/16M1057577
- AH16_3Mary Aprahamian と Nicholas J. Higham, "Matrix Inverse Trigonometric and Inverse Hyperbolic Functions: Theory and Algorithms", MIMS EPrint: 2016.4. https://doi.org/10.1137/16M1057577
- AH16_4Mary Aprahamian と Nicholas J. Higham, "行列の逆三角関数と逆双曲線関数: 理論とアルゴリズム", MIMS EPrint: 2016.4. https://doi.org/10.1137/16M1057577
- AH16_5Mary Aprahamian and Nicholas J. Higham, "Matrix Inverse Trigonometric and Inverse Hyperbolic Functions: Theory and Algorithms", MIMS EPrint: 2016.4. https://doi.org/10.1137/16M1057577
- AH16_6Mary Aprahamian と Nicholas J. Higham, "行列の逆三角関数と逆双曲線関数: 理論とアルゴリズム", MIMS EPrint: 2016.4. https://doi.org/10.1137/16M1057577