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.24947A はエルミート行列、対称行列、三角行列、三重対角行列、二重対角行列のいずれでもないため、最善の方法は 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.0sB は(実数)対称行列としてタグ付けされています。そのため、固有分解や行列とベクトルの積など、後続の演算では行列の半分だけを参照して効率化できます。たとえば、次のとおりです。
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 の各種最適化メソッドへの接続が利用可能かどうかをまとめています。
Elementary operations
| 行列型 | + | - | * | \ | 最適化メソッドが用意されているその他の関数 |
|---|---|---|---|---|---|
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 | / |
凡例:
| キー | 説明 |
|---|---|
| M(行列) | 行列と行列の演算に最適化されたメソッドを利用できます |
| V(ベクトル) | 行列とベクトルの演算に最適化されたメソッドを利用できます |
| S(スカラー) | 行列とスカラーの演算に最適化されたメソッドを利用できます |
Matrix factorizations
| 行列型 | 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 |
凡例:
| キー | 説明 | 例 |
|---|---|---|
| A(すべて) | 特性値および/または特性ベクトルをすべて求める最適化メソッドを利用できます | 例:eigvals(M) |
| R(範囲) | il 番目から ih 番目までの特性値を求める最適化メソッドを利用できます | eigvals(M, il, ih) |
| I(区間) | 区間 [vl, vh] 内の特性値を求める最適化メソッドを利用できます | eigvals(M, vl, vh) |
| V(ベクトル) | 特性値 x=[x1, x2,...] に対応する特性ベクトルを求める最適化メソッドを利用できます | 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 に実装されている行列分解の型をまとめます。各型に関連するメソッドの詳細は、Linear Algebra ドキュメントの Standard functions セクションを参照してください。
| 型 | 説明 |
|---|---|
BunchKaufman | Bunch-Kaufman 分解 |
Cholesky | Cholesky factorization |
CholeskyPivoted | Pivoted Cholesky 分解 |
LDLt | LDL(T) factorization |
LU | LU factorization |
QR | QR factorization |
QRCompactWY | QR 分解のコンパクト WY 形式 |
QRPivoted | ピボット付き QR factorization |
LQ | transpose(A) の QR factorization |
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 関連の分解(QR、QRCompactWY、QRPivoted)、hessenberg の呼び出しで得られるヘッセンベルグ分解、lq の呼び出しで得られる LQ 分解が含まれます。これらの直交/ユニタリ因子は行列として表現できますが、性能とメモリ使用量の理由から、内部表現は通常の行列とは異なります。そのため、行列を背後に持つ関数ベースの線形演算子として捉えるのが適切です。特に、たとえば行列表現の列を読み取るには、「行列」とベクトルの積を計算するコードを実行する必要があります。メモリからデータをそのまま読み出す(場合によってはベクトルの一部を構造的なゼロで埋める)わけではありません。また、三角行列以外の行列型との明確な違いとして、基盤となる乗算コードでは、乗算中にインプレースで変更できます。さらに、AbstractQ の特定のサブタイプ(qr、hessenberg、lq で作成されるものなど)は、状況に応じて正方行列または長方形行列として振る舞います。
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-multiplicationeltype の昇格が不要であれば、convert メソッドは必要ありません。デフォルトでは convert(::Type{AbstractQ{T}}, Q::AbstractQ{T}) が Q 自体を返すためです。AbstractQ 型のオブジェクトの随伴行列は、AdjointQ ラッパー型で遅延ラップされます。この型には独自の LinearAlgebra.lmul! メソッドと LinearAlgebra.rmul! メソッドが必要です。これらのメソッドを実装すれば、任意の Q::MyQ を行列のように使用できます。特に乗算の文脈での使用が適しています。* によるスカラー、ベクトル、行列との左右からの乗算、Q の行列表現の取得(Matrix(Q) または Q*I による)、行列表現へのインデックスアクセスが可能です。一方、加算や減算、さらに一般に行列表現の要素に対するブロードキャストは、非常に非効率になるため失敗します。こうした用途では、あらかじめ行列表現を計算し、後で再利用できるようキャッシュすることを検討してください。
Pivoting Strategies
Julia の matrix factorizations の多くは pivoting をサポートしており、数値安定性の向上に利用できます。実際、LU 分解などの行列分解は、ピボット選択なしでは失敗することがあります。
ピボット選択では、まずピボット戦略に基づき、数値的に良好な性質を持つ pivot element を選びます。次に、後続の計算で選んだ要素を所定の位置に置くため、元の行列の行と列を並べ替えます。この処理を分解の各段階で繰り返します。
そのため、ピボット選択を伴う分解では、通常の行列因子に加えて置換行列も出力されます。
以下では、Julia に実装されているピボット戦略について簡単に説明します。すべての行列分解がこれらの戦略をサポートしているとは限りません。サポートされるピボット戦略の詳細は、各 matrix factorization のドキュメントを参照してください。
LinearAlgebra.ZeroPivotException も参照してください。
LinearAlgebra.NoPivot — Type
NoPivotピボット選択は行いません。これは、cholesky および qr の分解で使われるデフォルトの戦略です。ただし、LU 分解などの他の行列分解では、ピボット選択を行わないと失敗することがあります。また、浮動小数点行列では丸め誤差の影響により、数値的に不安定になる場合もあります。このような場合、このピボット戦略は主に教育目的で役立ちます。
LinearAlgebra.RowNonZero — Type
RowNonZero残りの行で最初に見つかった非ゼロ要素をピボット要素として選びます。
浮動小数点行列では、この方法による LU アルゴリズムは数値的に不安定になるため注意してください。この方法は主に、手計算(通常はこの方法を使います)との比較や、丸め誤差の影響を受けない他の代数的型(有理数など)での使用に適しています。それ以外の場合、ガウス消去法では通常、デフォルトの RowMaximum ピボット戦略を使うことを推奨します。
行列の element type は、iszero メソッドを持つ必要があります。
LinearAlgebra.RowMaximum — Type
RowMaximumピボットには、最大値に基づいて行(場合によっては列も)が選ばれます。これは、LU 分解とピボット付きコレスキー分解のデフォルトの戦略です(ただし、NoPivot は cholesky のデフォルトです)。
LU 分解では、現在の列のうち、残りの行にある要素から絶対値が最大のものをピボット要素として選びます。これは「部分ピボット選択」アルゴリズムと呼ばれることがあります。この場合、行列の element type は abs メソッドをサポートしている必要があり、その戻り値の型も < メソッドをサポートしている必要があります。
コレスキー分解では、残りの対角要素のうち最大のものをピボット要素として選びます。これは「対角ピボット選択」アルゴリズムと呼ばれることがあり、完全ピボット選択(つまり、同じ置換によって行と列の両方を入れ替える方法)につながります。この場合、行列の element type(の実部)は < メソッドをサポートしている必要があります。
LinearAlgebra.ColumnNorm — Type
ColumnNormノルムが最大の列を、以降の計算に使用します。これはピボット付きQR分解で使用されます。
行列のelement typeは、normメソッドとabsメソッドをサポートしている必要があります。また、それぞれの戻り値の型は<メソッドをサポートしている必要があります。
Standard functions
Julia の線形代数関数の多くは、LAPACK の関数を呼び出して実装されています。疎行列の分解では、SuiteSparse の関数が呼び出されます。そのほかの疎行列ソルバーは Julia のパッケージとして利用できます。
Base.:* — Method
*(A, B::AbstractMatrix, C)
A * B * C * D3個または4個の行列を連鎖的に乗算する場合、配列のサイズに基づいて最も効率的な順序で計算します。つまり、(A * B) * C(密行列3個)の場合に必要なスカラー乗算の回数と、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 が正方行列の場合、A*X == B となります。使用されるソルバーは、A の構造によって異なります。A が上三角行列、下三角行列、または対角行列の場合、A の因子分解は不要で、前進代入または後退代入によって連立方程式を解きます。三角行列でない正方行列には、LU分解を使用します。
長方形行列 A の場合、結果は、A のピボット付きQR分解と、R因子に基づく A のランク推定によって計算される、最小ノルム最小二乗解です。
A が疎行列の場合も、同様の多項式アルゴリズムを使用します。不定値行列では、LDLt 分解の数値分解時にピボット選択を行わないため、行列が可逆であっても処理に失敗することがあります。
Examples
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
trueBase.:/ — Method
A / B行列の右除算:A / B は、(B' \ A')' と等価です。ここで、\ は左除算演算子です。正方行列の場合、結果 X は A == X*B を満たします。
関連項目:rdiv!。
Examples
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))
trueLinearAlgebra.SingularException — Type
SingularException入力行列にゼロの固有値が1つ以上あり、逆行列を持たない場合にスローされる例外です。このような行列を含む連立一次方程式は解けません。infoフィールドは、特異値の位置(いずれか1つ)を示します。
LinearAlgebra.PosDefException — Type
PosDefException入力行列がpositive definiteでない場合にスローされます。線形代数関数や行列分解の中には、正定値行列にのみ適用できるものがあります。infoフィールドは、0以下の固有値の位置を示します。
LinearAlgebra.ZeroPivotException — Type
ZeroPivotException <: Exception行列の因子分解または求解でピボット(対角)位置にゼロが見つかり、処理を続行できない場合にスローされる例外です。これは、行列が特異であることを必ずしも意味しません。ピボット付き LU 分解など、変数の順序を入れ替えて見かけ上のゼロピボットを解消できる別の因子分解に切り替えるとよい場合があります。info フィールドは、ゼロピボットの位置(複数ある場合はそのうちの 1 つ)を示します。
LinearAlgebra.RankDeficientException — Type
RankDeficientException入力行列がrank deficientの場合にスローされる例外です。コレスキー分解など、一部の線形代数関数は、ランク落ちしていない行列にのみ適用できます。infoフィールドは、行列の計算されたランクを示します。
LinearAlgebra.LAPACKException — Type
LAPACKExceptionLAPACK functions の直接呼び出し時、または LAPACK 関数を内部で使用しているものの、専用のエラー処理を備えていない他の関数の呼び出し時にスローされる、汎用的な LAPACK 例外です。info フィールドには、元のエラーに関する追加情報が格納されます。その内容は、呼び出された LAPACK 関数によって異なります。
LinearAlgebra.dot — Function
dot(x, y)
x ⋅ y2つのベクトルの内積を計算します。複素ベクトルの場合は、最初のベクトルを共役します。
dot は、要素に対して dot が定義されていれば、任意の次元の配列を含む、任意の反復可能オブジェクトにも使用できます。
dot は意味的には sum(dot(vx,vy) for (vx,vy) in zip(x, y)) と同等ですが、引数の長さが等しくなければならないという制約が追加されています。
x ⋅ y(REPL で \cdot をタブ補完すると ⋅ と入力できます)は、dot(x, y) の同義語です。
Examples
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.0LinearAlgebra.dot — Method
dot(x, A, y)2つのベクトル x と y の一般化内積 dot(x, A*y) を計算します。中間結果 A*y は保存されません。2引数の dot(_,_) と同様に、これは再帰的に動作します。また、複素ベクトルの場合は、第1ベクトルの複素共役を取ります。
Examples
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)
trueLinearAlgebra.cross — Function
cross(x, y)
×(x,y)2つの3次元ベクトルの外積を計算します。
Examples
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
0LinearAlgebra.axpy! — Function
axpy!(α, x::AbstractArray, y::AbstractArray)yをx * α + yで上書きし、yを返します。xとyの軸が同じであれば、y .+= x .* aと等価です。
Examples
julia> x = [1; 2; 3];
julia> y = [4; 5; 6];
julia> axpy!(2, x, y)
3-element Vector{Int64}:
6
9
12LinearAlgebra.axpby! — Function
axpby!(α, x::AbstractArray, β, y::AbstractArray)yをx * α + y * βで上書きし、yを返します。xとyの軸が同じであれば、y .= x .* a .+ y .* βと等価です。
Examples
julia> x = [1; 2; 3];
julia> y = [4; 5; 6];
julia> axpby!(2, x, 2, y)
3-element Vector{Int64}:
10
14
18LinearAlgebra.rotate! — Function
rotate!(x, y, c, s)xをs*y + c*xで上書きし、yをc*y - conj(s)*xで上書きします。xとyを返します。
LinearAlgebra.reflect! — Function
reflect!(x, y, c, s)xをc*x + s*yで上書きし、yをconj(s)*x - c*yで上書きします。xとyを返します。
LinearAlgebra.factorize — Function
factorize(A)入力行列の型に基づいて、Aの便利な分解を計算します。Aが汎用行列として渡された場合、factorizeは対称行列、三角行列などに該当するかを調べます。そのために、factorizeは、各性質を確認または否定するため、Aのすべての要素を調べることがあります。対称性や三角構造がないと判定できた時点で、検査を打ち切ります。戻り値は、複数の連立方程式を効率よく解くために再利用できます。たとえば、A=factorize(A); x=A\b; y=A\Cのようにします。
Aの性質 | 分解の型 |
|---|---|
| 密な対称/エルミート行列 | Bunch-Kaufman(bunchkaufmanを参照) |
| 疎な対称/エルミート行列 | LDLt(ldltを参照) |
| 三角行列 | 三角分解 |
| 対角行列 | 対角分解 |
| 二重対角行列 | 二重対角分解 |
| 三重対角行列 | LU(luを参照) |
| 実対称三重対角行列 | LDLt(ldltを参照) |
| 一般の正方行列 | LU(luを参照) |
| 一般の非正方行列 | QR(qrを参照) |
Examples
julia> A = Array(Bidiagonal(fill(1.0, (5, 5)), :U))
5×5 Matrix{Float64}:
1.0 1.0 0.0 0.0 0.0
0.0 1.0 1.0 0.0 0.0
0.0 0.0 1.0 1.0 0.0
0.0 0.0 0.0 1.0 1.0
0.0 0.0 0.0 0.0 1.0
julia> factorize(A) # factorize will check to see that A is already factorized
5×5 Bidiagonal{Float64, Vector{Float64}}:
1.0 1.0 ⋅ ⋅ ⋅
⋅ 1.0 1.0 ⋅ ⋅
⋅ ⋅ 1.0 1.0 ⋅
⋅ ⋅ ⋅ 1.0 1.0
⋅ ⋅ ⋅ ⋅ 1.0これは5×5 Bidiagonal{Float64}を返します。この値を他の線形代数関数(固有値ソルバーなど)に渡すと、Bidiagonal型に特化した手法が使われます。
LinearAlgebra.Diagonal — Type
Diagonal(V::AbstractVector)V を対角成分とする遅延行列を構築します。
遅延単位行列 I については UniformScaling を、密行列を作成するには diagm を、対角要素を取り出すには diag も参照してください。
Examples
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 ⋅
⋅ 1julia> 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.0Diagonal(A::AbstractMatrix)A の主対角成分から行列を構成します。入力行列 A は長方形でもかまいませんが、出力は正方行列になります。
Examples
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 ⋅
⋅ 5Diagonal{T}(undef, n)長さが n の、未初期化の Diagonal{T} を構築します。undef を参照してください。
LinearAlgebra.Bidiagonal — Type
Bidiagonal(dv::V, ev::V, uplo::Symbol) where V <: AbstractVector指定された対角ベクトル(dv)と非対角ベクトル(ev)を使って、上(uplo=:U)または下(uplo=:L)二重対角行列を構築します。結果はBidiagonal型で、専用の効率的な線形ソルバーを利用できます。また、convert(Array, _)(または簡潔なArray(_))を使って通常の行列に変換することもできます。evの長さは、dvの長さより1短くなければなりません。
Examples
julia> dv = [1, 2, 3, 4]
4-element Vector{Int64}:
1
2
3
4
julia> ev = [7, 8, 9]
3-element Vector{Int64}:
7
8
9
julia> Bu = Bidiagonal(dv, ev, :U) # ev is on the first superdiagonal
4×4 Bidiagonal{Int64, Vector{Int64}}:
1 7 ⋅ ⋅
⋅ 2 8 ⋅
⋅ ⋅ 3 9
⋅ ⋅ ⋅ 4
julia> Bl = Bidiagonal(dv, ev, :L) # ev is on the first subdiagonal
4×4 Bidiagonal{Int64, Vector{Int64}}:
1 ⋅ ⋅ ⋅
7 2 ⋅ ⋅
⋅ 8 3 ⋅
⋅ ⋅ 9 4Bidiagonal(A, uplo::Symbol)A の主対角線と、その第1上対角線(uplo=:U の場合)または第1下対角線(uplo=:L の場合)から、Bidiagonal 行列を構成します。
Examples
julia> A = [1 1 1 1; 2 2 2 2; 3 3 3 3; 4 4 4 4]
4×4 Matrix{Int64}:
1 1 1 1
2 2 2 2
3 3 3 3
4 4 4 4
julia> Bidiagonal(A, :U) # contains the main diagonal and first superdiagonal of A
4×4 Bidiagonal{Int64, Vector{Int64}}:
1 1 ⋅ ⋅
⋅ 2 2 ⋅
⋅ ⋅ 3 3
⋅ ⋅ ⋅ 4
julia> Bidiagonal(A, :L) # contains the main diagonal and first subdiagonal of A
4×4 Bidiagonal{Int64, Vector{Int64}}:
1 ⋅ ⋅ ⋅
2 2 ⋅ ⋅
⋅ 3 3 ⋅
⋅ ⋅ 4 4LinearAlgebra.SymTridiagonal — Type
SymTridiagonal(dv::V, ev::V) where V <: AbstractVector対角成分(dv)と第1副対角成分(ev)から、それぞれ対称三重対角行列を構築します。結果はSymTridiagonal型で、専用の効率的な固有値ソルバーを利用できます。また、convert(Array, _)(簡潔にはArray(_))を使って通常の行列に変換することもできます。
SymTridiagonalのブロック行列では、dvの要素は対称化されます。引数evは上対角ブロックとして解釈されます。下対角ブロックは、対応する上対角ブロックを(実体化した)転置です。
Examples
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 4SymTridiagonal(A::AbstractMatrix)対称行列 A の対角成分と第1上対角成分から、対称三重対角行列を構成します。
Examples
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 — Type
Tridiagonal(dl::V, d::V, du::V) where V <: AbstractVector第1下対角、第対角、第1上対角から、三重対角行列を構築します。結果はTridiagonal型で、効率的な専用線形ソルバーを利用できます。また、convert(Array, _)(短縮形はArray(_))を使って通常の行列に変換することもできます。dlとduの長さは、dの長さより1短くなければなりません。
Examples
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 0Tridiagonal(A)行列 A の第1副対角、第対角、第1超対角から三重対角行列を構成します。
Examples
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 4LinearAlgebra.Symmetric — Type
Symmetric(A::AbstractMatrix, uplo::Symbol=:U)行列 A の上三角部分(uplo = :U の場合)または下三角部分(uplo = :L の場合)のビュー Symmetric を構築します。
Symmetric ビューは、主に実対称行列で役立ちます。実対称行列では、Symmetric 型に対して、固有値問題などの専用アルゴリズムが利用できます。より一般には、エルミート行列 A == A' については Hermitian(A) も参照してください。これは実行列では Symmetric と実質的に同等ですが、複素行列にも有用です。(一方、複素 Symmetric 行列もサポートされていますが、専用アルゴリズムはほとんど、あるいはまったくありません。)
実行列の対称部分、またはより一般に実行列・複素行列 A のエルミート部分 (A + A') / 2 を計算するには、hermitianpart を使用します。
対称ビューと共有される A の三角部分に対応する uplo シンボルは、関数 LinearAlgebra.uplo を使って取得できます。対称ビューから元の行列 A を取得するには、parent を使用します。
Examples
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.0Supper は、A 自体が対称でない限り(たとえば A == transpose(A) の場合)、Slower と等しくならないことに注意してください。
LinearAlgebra.Hermitian — Type
Hermitian(A::AbstractMatrix, uplo::Symbol=:U)行列 A の上三角部分(uplo = :U の場合)または下三角部分(uplo = :L の場合)のビューを Hermitian として構築します。
A のエルミート部分を計算するには、hermitianpart を使用します。
エルミートビューと共有される A の三角部分に対応する uplo シンボルは、関数 LinearAlgebra.uplo を使って取得できます。元の行列 A は、parent を使ってエルミートビューから取得できます。
Examples
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.0imA 自体がエルミート行列でない限り(たとえば A == adjoint(A) の場合)、Hupper と Hlower は等しくないことに注意してください。
対角成分の虚部はすべて無視されます。
Hermitian(fill(complex(1,1), 1, 1)) == fill(1, 1, 1)LinearAlgebra.LowerTriangular — Type
LowerTriangular(A::AbstractMatrix)行列 A の LowerTriangular ビューを構築します。
Examples
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.0LinearAlgebra.UpperTriangular — Type
UpperTriangular(A::AbstractMatrix)行列 A の UpperTriangular ビューを構築します。
Examples
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.0LinearAlgebra.UnitLowerTriangular — Type
UnitLowerTriangular(A::AbstractMatrix)行列 A の UnitLowerTriangular ビューを構築します。このビューでは、対角成分に A の eltype の oneunit が並びます。
Examples
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.0LinearAlgebra.UnitUpperTriangular — Type
UnitUpperTriangular(A::AbstractMatrix)行列 A の UnitUpperTriangular ビューを構築します。このビューでは、対角成分に A の eltype の oneunit が並びます。
Examples
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.0LinearAlgebra.UpperHessenberg — Type
UpperHessenberg(A::AbstractMatrix)行列 A の UpperHessenberg ビューを構築します。最初の副対角線より下にある A の要素は無視されます。
H \ b、det(H) などには、効率的なアルゴリズムが実装されています。
任意の行列を同様の上ヘッセンベルグ行列に分解する関数 hessenberg も参照してください。
F::Hessenberg が分解オブジェクトの場合、ユニタリ行列は F.Q で、ヘッセンベルグ行列は F.H で取得できます。Q を取り出すと、結果の型は HessenbergQ オブジェクトになります。これは convert(Array, _)(または簡潔な Array(_))で通常の行列に変換できます。
分解を反復すると、因子 F.Q と F.H が生成されます。
Examples
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 16LinearAlgebra.UniformScaling — Type
UniformScaling{T<:Number}スカラーと単位作用素の積として定義される、サイズが汎用的な一様スケーリング作用素 λ*I。明示的な size はありませんが、多くの場合、行列と同様に動作し、一部のインデックス指定をサポートします。I も参照してください。
Examples
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.0LinearAlgebra.I — Constant
I任意のサイズの単位行列を表す、型 UniformScaling のオブジェクト。
Examples
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+0imLinearAlgebra.UniformScaling — Method
(I::UniformScaling)(n::Integer)UniformScalingからDiagonal行列を構築します。
Examples
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.7LinearAlgebra.Factorization — Type
LinearAlgebra.Factorizationmatrix factorizations(別名:行列分解)の抽象型です。利用可能な行列分解の一覧については、online documentationを参照してください。
LinearAlgebra.LU — Type
LU <: 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 が生成されます。
Examples
julia> A = [4 3; 6 3]
2×2 Matrix{Int64}:
4 3
6 3
julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
1.0 0.0
0.666667 1.0
U factor:
2×2 Matrix{Float64}:
6.0 3.0
0.0 1.0
julia> F.L * F.U == A[F.p, :]
true
julia> l, u, p = lu(A); # destructuring via iteration
julia> l == F.L && u == F.U && p == F.p
trueLinearAlgebra.lu — Function
lu(A::AbstractSparseMatrixCSC; check = true, q = nothing, control = get_umfpack_control()) -> F::UmfpackLU疎行列 A の LU 分解を計算します。
実数または複素数の要素型を持つ疎行列 A に対して、F の戻り値の型は UmfpackLU{Tv, Ti} です。ここで、Tv はそれぞれ Float64 または ComplexF64 であり、Ti は整数型(Int32 または Int64)です。
check = true の場合、分解に失敗するとエラーがスローされます。check = false の場合、分解が有効かどうか(issuccess を使って)確認する責任はユーザーにあります。
置換 q には、置換ベクトルまたは nothing を指定できます。置換ベクトルが指定されていない場合、または q が nothing の場合は、UMFPACK のデフォルトが使われます。置換が 0 始まりでない場合は、0 始まりのコピーが作成されます。
control ベクトルのデフォルト値は、Julia の SparseArrays パッケージにおける UMFPACK のデフォルト設定です(注:反復改良を無効にするため、UMFPACK のデフォルトから変更されています)。長さ UMFPACK_CONTROL のベクトルを渡すことで変更できます。設定可能な値については UMFPACK のマニュアルを参照してください。たとえば、反復改良を再び有効にするには、次のようにします。
umfpack_control = SparseArrays.UMFPACK.get_umfpack_control(Float64, Int64) # read Julia default configuration for a Float64 sparse matrix
SparseArrays.UMFPACK.show_umf_ctrl(umfpack_control) # optional - display values
umfpack_control[SparseArrays.UMFPACK.JL_UMFPACK_IRSTEP] = 2.0 # reenable iterative refinement (2 is UMFPACK default max iterative refinement steps)
Alu = lu(A; control = umfpack_control)
x = Alu \ b # solve Ax = b, including UMFPACK iterative refinement分解 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::LUA の 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():ピボットには、これから分解する残りの行にある最初の非ゼロ要素を選びます。(手計算で一般的に使われる選び方であり、iszeroはサポートするものの、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 | ✓ | ✓ |
Examples
julia> A = [4 3; 6 3]
2×2 Matrix{Int64}:
4 3
6 3
julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
1.0 0.0
0.666667 1.0
U factor:
2×2 Matrix{Float64}:
6.0 3.0
0.0 1.0
julia> F.L * F.U == A[F.p, :]
true
julia> l, u, p = lu(A); # destructuring via iteration
julia> l == F.L && u == F.U && p == F.p
true
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.0LinearAlgebra.lu! — Function
lu!(F::UmfpackLU, A::AbstractSparseMatrixCSC; check=true, reuse_symbolic=true, q=nothing) -> F::UmfpackLU疎行列 A の LU 分解を計算します。このとき、既存の LU 分解 F に保存されているシンボリック分解を再利用します。reuse_symbolic が false に設定されていない限り、疎行列 A は、LU 分解 F の作成に使用した行列と同じ非ゼロパターンを持つ必要があります。そうでない場合はエラーが発生します。A と F のサイズが異なる場合、すべてのベクトルはそれに応じてサイズ変更されます。
check = true の場合、分解に失敗するとエラーが発生します。check = false の場合、分解が有効かどうか(issuccess を使用)の確認はユーザーの責任です。
置換 q には、置換ベクトルまたは nothing を指定できます。置換ベクトルが指定されていない場合、または q が nothing の場合は、UMFPACK のデフォルトが使用されます。置換が 0 始まりでない場合は、0 始まりのコピーが作成されます。
関連項目: lu
lu!(F::UmfpackLU, A::AbstractSparseMatrixCSC) は、SuiteSparse に含まれる UMFPACK ライブラリを使用します。このライブラリがサポートする疎行列の要素型は Float64 または ComplexF64 のみであるため、lu! は、LU 分解または SparseMatrixCSC{ComplexF64} で指定された型に自動的に変換されます。
Examples
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.0lu!(F::LU, pivot = RowMaximum(); check = true, allowsingular = false) -> LUlu!はluと同じですが、コピーを作成せず、入力のFを上書きすることで、メモリを節約します。
Examples
julia> A = [4. 3.; 6. 3.]
2×2 Matrix{Float64}:
4.0 3.0
6.0 3.0
julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
1.0 0.0
0.666667 1.0
U factor:
2×2 Matrix{Float64}:
6.0 3.0
0.0 1.0
julia> B = [8 3; 12 3]
2×2 Matrix{Int64}:
8 3
12 3
julia> F2 = lu!(F,B)
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}:
12.0 3.0
0.0 1.0lu!(A, pivot = RowMaximum(); check = true, allowsingular = false) -> LUlu!はluと同じですが、コピーを作成せず、入力のAを上書きするため、メモリを節約できます。因数分解の結果がAの要素型で表現できない数になる場合(整数型など)、InexactError例外がスローされます。
Examples
julia> A = [4. 3.; 6. 3.]
2×2 Matrix{Float64}:
4.0 3.0
6.0 3.0
julia> F = lu!(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
1.0 0.0
0.666667 1.0
U factor:
2×2 Matrix{Float64}:
6.0 3.0
0.0 1.0
julia> iA = [4 3; 6 3]
2×2 Matrix{Int64}:
4 3
6 3
julia> lu!(iA)
ERROR: InexactError: Int64(0.6666666666666666)
Stacktrace:
[...]LinearAlgebra.Cholesky — Type
Cholesky <: Factorization密な対称正定値行列またはエルミート正定値行列 A のコレスキー分解を表す行列分解型です。対応する行列分解関数 cholesky の戻り値の型です。
三角コレスキー因子は、分解 F::Cholesky から F.L と F.U を使って取得できます。このとき、A ≈ F.U' * F.U ≈ F.L * F.L' です。
Cholesky オブジェクトでは、次の関数を利用できます: size、\、inv、det、logdet、isposdef。
この分解を反復すると、成分 L と U が生成されます。
Examples
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, Adjoint{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
trueLinearAlgebra.CholeskyPivoted — Type
CholeskyPivoted密な対称/エルミート半正定値行列 A のピボット付きコレスキー分解を表す行列分解型です。対応する行列分解関数 cholesky(_, ::RowMaximum) の戻り値の型です。
三角コレスキー因子は、分解 F::CholeskyPivoted から F.L と F.U を使って取得できます。また、置換は F.p を使って取得できます。このとき、A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' と Ur = F.U[1:F.rank, :] および Lr = F.L[:, 1:F.rank] を使う方法と、A ≈ Up' * Up ≈ Lp * Lp' と Up = F.U[1:F.rank, invperm(F.p)] および Lp = F.L[invperm(F.p), 1:F.rank] を使う方法があります。
CholeskyPivoted オブジェクトでは、次の関数を利用できます: size、\、inv、det、rank。
この分解を反復すると、成分 L と U が生成されます。
Examples
julia> X = [1.0, 2.0, 3.0, 4.0];
julia> A = X * X';
julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U factor with rank 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
4.0 2.0 3.0 1.0
⋅ 0.0 6.0 2.0
⋅ ⋅ 9.0 3.0
⋅ ⋅ ⋅ 1.0
permutation:
4-element Vector{Int64}:
4
2
3
1
julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
true
julia> l, u = C; # destructuring via iteration
julia> l == C.L && u == C.U
trueLinearAlgebra.cholesky — Function
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 を用いた連立方程式の求解に最もよく使われますが、F に対しては、diag、det、logdet の各メソッドも定義されています。F から、F.L を使って個々の因子を取り出すこともできます。ただし、既定ではピボット選択が有効なため、分解結果は内部的に置換行列 P を伴う A == P'*L*L'*P として表現されます。P を考慮せずに L だけを使うと、誤った結果になります。置換の影響を反映するには、通常、PtL = F.PtL(P'*L に相当)や LtP = F.UP(L'*P に相当)のような「結合」因子を取り出すのが適切です。サポートされている因子の一覧は :L, :PtL, :UP, :U です。置換ベクトルは F.p で取得でき、次のように定義されています。L*L' == A[p, p]、
L 成分は、sparse(F.L) を使って疎行列として実体化できます。その他の成分は直接実体化できませんが、必要に応じて sparse(F.L) と F.p から再構成できます。
check = true の場合、分解に失敗するとエラーがスローされます。check = false の場合、issuccess による分解の妥当性確認はユーザーの責任となります。
省略可能なキーワード引数 shift を設定すると、A ではなく A+shift*I の分解を計算します。perm 引数を指定する場合は、使用する順序を表す 1:size(A,1) の置換である必要があります(CHOLMOD の既定の AMD 順序付けの代わりに使用されます)。
正定値性を必要としない類似の分解については ldlt も参照してください。ただし、cholesky より大幅に遅くなる場合があります。
Examples
次の例では、フィルインを減らすために [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 モジュールからはエクスポートされていません。
cholesky(A, NoPivot(); check = true) -> Cholesky密な対称正定値行列 A のコレスキー分解を計算し、Cholesky 分解を返します。行列 A には、Symmetric、Hermitian AbstractMatrix、または 完全に 対称な、あるいはエルミートな AbstractMatrix を指定できます。
三角コレスキー因子は、分解 F から F.L と F.U を使って取得できます。ここで、A ≈ F.U' * F.U ≈ F.L * F.L' です。
Cholesky オブジェクトでは、次の関数を使用できます。size、\、inv、det、logdet、isposdef。
行列 A の構築時に生じた丸め誤差により、行列がわずかに非エルミートになっている場合は、cholesky に渡す前に Hermitian(A) でラップすると、完全にエルミートな行列として扱えます。
check = true の場合、分解に失敗するとエラーがスローされます。check = false の場合、分解の妥当性を issuccess で確認する責任はユーザーにあります。
Examples
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, Adjoint{Float64, Matrix{Float64}}}:
2.0 ⋅ ⋅
6.0 1.0 ⋅
-8.0 5.0 3.0
julia> C.L * C.U == A
truecholesky(A, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted密な対称半正定値行列 A のピボット付きコレスキー分解を計算し、CholeskyPivoted 分解を返します。行列 A には、Symmetric、Hermitian AbstractMatrix、または 完全に 対称あるいはエルミートな AbstractMatrix を指定できます。
三角コレスキー因子は、分解 F から F.L と F.U を使って取得できます。また、置換は F.p から取得できます。ここで、A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' は Ur = F.U[1:F.rank, :] および Lr = F.L[:, 1:F.rank] を伴う場合と、A ≈ Up' * Up ≈ Lp * Lp' が Up = F.U[1:F.rank, invperm(F.p)] および Lp = F.L[invperm(F.p), 1:F.rank] を伴う場合があります。
CholeskyPivoted オブジェクトでは、次の関数を利用できます: size、\、inv、det、rank。
引数 tol は、ランク判定の許容誤差を指定します。負の値の場合、許容誤差は eps()*size(A,1)*maximum(diag(A)) と等しくなります。
構成時の丸め誤差によりわずかに非エルミートとなっている行列 A を、完全にエルミートな行列として扱うには、cholesky に渡す前に Hermitian(A) でラップしてください。
check = true の場合、分解に失敗するとエラーがスローされます。check = false の場合、分解が有効かどうかの確認(issuccess を使用)はユーザーの責任です。
Examples
julia> X = [1.0, 2.0, 3.0, 4.0];
julia> A = X * X';
julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U factor with rank 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
4.0 2.0 3.0 1.0
⋅ 0.0 6.0 2.0
⋅ ⋅ 9.0 3.0
⋅ ⋅ ⋅ 1.0
permutation:
4-element Vector{Int64}:
4
2
3
1
julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
true
julia> l, u = C; # destructuring via iteration
julia> l == C.L && u == C.U
trueLinearAlgebra.cholesky! — Function
cholesky!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.FactorA のコレスキー分解($LL'$)を、シンボリック分解 F を再利用して計算します。A は、SparseMatrixCSC の SparseMatrixCSC または Symmetric/Hermitian ビューでなければなりません。A に型タグがない場合は、それ自体が対称行列またはエルミート行列でなければならないことに注意してください。
関連項目: cholesky。
cholesky!(A::AbstractMatrix, NoPivot(); check = true) -> Choleskycholeskyと同じですが、コピーを作成せずに入力のAを上書きするため、メモリを節約できます。因数分解の結果がAの要素型で表現できない数になる場合(整数型の場合など)、InexactError例外がスローされます。
Examples
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) -> CholeskyPivotedcholeskyと同じですが、コピーを作成せず、入力のAを上書きするため、メモリを節約できます。因数分解の結果がAの要素型で表現できない数値になる場合(整数型の場合など)、InexactError例外がスローされます。
LinearAlgebra.lowrankupdate — Function
lowrankupdate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.FactorLDLt または LLt の A の因数分解 F が与えられたとき、A + C*C' の LDLt 因数分解を取得します。
返される因数は、常に LDLt 因数分解です。
lowrankupdate(C::Cholesky, v::AbstractVector) -> CC::Choleskyベクトル v を使って、コレスキー分解 C を更新します。A = C.U'C.U の場合、CC = cholesky(C.U'C.U + v*v') ですが、CC の計算には O(n^2) 演算しか使いません。
LinearAlgebra.lowrankdowndate — Function
lowrankdowndate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.FactorA + C*C' の A を、LDLt または LLt の因子分解 F から LDLt 因子分解として取得します。
返される因子は、常に LDLt 因子分解です。
lowrankdowndate(C::Cholesky, v::AbstractVector) -> CC::Choleskyベクトル v を用いて、コレスキー分解 C をダウンドデートします。A = C.U'C.U の場合、CC = cholesky(C.U'C.U - v*v') ですが、CC の計算では O(n^2) 演算のみを使用します。
LinearAlgebra.lowrankupdate! — Function
lowrankupdate!(F::CHOLMOD.Factor, C::AbstractArray)A の LDLt または LLt 因子分解 F を、A + C*C' の因子分解に更新します。
LLt の因子分解は LDLt に変換されます。
lowrankupdate!(C::Cholesky, v::AbstractVector) -> CC::Choleskyベクトル v を使って、コレスキー分解 C を更新します。A = C.U'C.U の場合、CC = cholesky(C.U'C.U + v*v') ですが、CC の計算では O(n^2) 演算のみを使用します。入力の分解 C はインプレースで更新され、終了時には C == CC となります。計算中にベクトル v は破棄されます。
LinearAlgebra.lowrankdowndate! — Function
lowrankdowndate!(F::CHOLMOD.Factor, C::AbstractArray)LDLt または LLt の因子分解 F を、A の A - C*C' への因子分解に更新します。
LLt の因子分解は LDLt に変換されます。
lowrankdowndate!(C::Cholesky, v::AbstractVector) -> CC::Choleskyベクトル v を用いて、コレスキー分解 C をダウンドデートします。A = C.U'C.U の場合、CC = cholesky(C.U'C.U - v*v') ですが、CC の計算で使用する演算は O(n^2) のみです。入力の分解 C はその場で更新され、終了時には C == CC となります。計算中にベクトル v は破棄されます。
LinearAlgebra.LDLt — Type
LDLt <: Factorization実数の SymTridiagonal 行列 S の LDLt 分解を表す行列因子分解型です。S = L*Diagonal(d)*L' が成り立ちます。ここで、L は UnitLowerTriangular 行列、d はベクトルです。LDLt 分解 F = ldlt(S) の主な用途は、F\b を用いて連立一次方程式 Sx = b を解くことです。これは、対応する行列因子分解関数 ldlt の戻り値の型です。
因子分解 F::LDLt の各成分には、getproperty を使ってアクセスできます。
| 成分 | 説明 |
|---|---|
F.L | LDLt の L(単位下三角)部分 |
F.D | LDLt の D(対角)部分 |
F.Lt | LDLt の Lt(単位上三角)部分 |
F.d | D の対角成分を Vector として表したもの |
Examples
julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
3.0 1.0 ⋅
1.0 4.0 2.0
⋅ 2.0 5.0
julia> F = ldlt(S)
LDLt{Float64, SymTridiagonal{Float64, Vector{Float64}}}
L factor:
3×3 UnitLowerTriangular{Float64, SymTridiagonal{Float64, Vector{Float64}}}:
1.0 ⋅ ⋅
0.333333 1.0 ⋅
0.0 0.545455 1.0
D factor:
3×3 Diagonal{Float64, Vector{Float64}}:
3.0 ⋅ ⋅
⋅ 3.66667 ⋅
⋅ ⋅ 3.90909LinearAlgebra.ldlt — Function
ldlt(A::SparseMatrixCSC; shift = 0.0, check = true, perm=nothing) -> CHOLMOD.Factor疎行列 A の $LDL'$ 分解を計算します。A は、SparseMatrixCSC の SparseMatrixCSC または Symmetric/Hermitian ビューでなければなりません。A に型タグがない場合、それ自体が対称行列またはエルミート行列でなければならない点に注意してください。フィルインを抑える置換が使用されます。F = ldlt(A) は、F\b を用いて連立方程式 A*x = b を解くために最もよく使われます。返される分解オブジェクト F は、diag、det、logdet、inv の各メソッドにも対応しています。F.L を使うと、F から個々の因子を取り出せます。ただし、既定ではピボット選択が有効なため、分解は内部的に置換行列 P を伴う A == P'*L*D*L'*P として表現されます。P を考慮せずに L だけを使うと、誤った結果になります。置換の影響を反映するには、通常、P'*L に相当する PtL = F.PtL や、L'*P に相当する LtP = F.UP など、「結合された」因子を取り出すのが適切です。対応している因子の一覧は :L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP です。置換ベクトルは F.p で取得できます。これは L*D*L' == A[p, p] となるように定義されています。
LD 成分は、sparse(F.LD) を使って疎行列として実体化できます。他の成分は直接実体化できませんが、必要に応じて sparse(F.LD) と F.p から再構成できます。
関連するコレスキー分解とは異なり、$LDL'$ 分解では A が正定値である必要はありません。ただし、すべての首座小行列式が良条件である必要があり、これを満たさない場合は失敗します。
check = true の場合、分解に失敗するとエラーがスローされます。check = false の場合、issuccess を使って分解の有効性を確認する責任はユーザーにあります。
省略可能なキーワード引数 shift を設定すると、A ではなく A+shift*I の分解が計算されます。perm 引数を指定する場合は、CHOLMOD の既定の AMD 順序付けの代わりに使用する順序を表す、1:size(A,1) の置換でなければなりません。
ldlt より大幅に高速な場合がある分解については cholesky も参照してください。ただし、こちらは A が正定値である必要があります。
このメソッドは、SuiteSparse の CHOLMOD[ACM887][DavisHager2009] ライブラリを使用します。CHOLMOD が対応しているのは、単精度または倍精度の実数型と複素数型のみです。それ以外の要素型を持つ入力行列は、必要に応じてこれらの型に変換されます。
CHOLMOD の他の多くの関数もラップされていますが、Base.SparseArrays.CHOLMOD モジュールからはエクスポートされていません。
ldlt(S::SymTridiagonal) -> LDLt実対称三重対角行列 S の LDLt(すなわち $LDL^T$)分解を計算します。分解は S = L*Diagonal(d)*L' を満たし、L は単位下三角行列、d はベクトルです。LDLt 分解 F = ldlt(S) の主な用途は、F\b を用いて連立一次方程式 Sx = b を解くことです。
任意の対称行列またはエルミート行列をピボット付きで分解する類似の方法については、bunchkaufman を参照してください。
Examples
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.3488372093023255LinearAlgebra.ldlt! — Function
ldlt!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.FactorF のシンボリック分解を再利用して、A の $LDL'$ 分解を計算します。A は、SparseMatrixCSC の SparseMatrixCSC または Symmetric/Hermitian ビューでなければなりません。A に型タグがない場合、それ自体が対称行列またはエルミート行列でなければならない点に注意してください。
関連項目: ldlt。
このメソッドは SuiteSparse の CHOLMOD ライブラリを使用します。このライブラリがサポートするのは、単精度または倍精度の実数型と複素数型のみです。これら以外の要素型を持つ入力行列は、適宜これらの型に変換されます。
ldlt!(S::SymTridiagonal) -> LDLtldltと同じですが、コピーを作成せずに入力Sを上書きするため、メモリを節約できます。
Examples
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.90909LinearAlgebra.QR — Type
QR <: Factorization通常はqrから得られる、パック形式で格納されたQR行列分解です。$A$がm×n行列の場合、
\[A = Q R\]
ここで、$Q$は直交行列/ユニタリ行列、$R$は上三角行列です。行列$Q$は、ハウスホルダー反射$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$の要素が格納されます。つまり、
QRオブジェクトFではR = triu(F.factors)です。 - 対角下部分には、パック形式で格納された反射$v_i$が格納されます。ここで、$v_i$は行列
V = I + tril(F.factors, -1)の$i$列です。
- 上三角部分には$R$の要素が格納されます。つまり、
τは、係数$\tau_i$を含む、長さmin(m,n)のベクトルです。
LinearAlgebra.QRCompactWY — Type
QRCompactWY <: Factorizationコンパクトなブロック形式で格納された QR 行列分解で、通常は qr から得られます。$A$ が m×n 行列の場合、
\[A = Q R\]
ここで、$Q$ は直交行列/ユニタリ行列、$R$ は上三角行列です。これは QR 形式に似ていますが、直交行列/ユニタリ行列 $Q$ を Compact WY 形式で格納する点が異なります [Schreiber1989]。ブロックサイズが $n_b$ の場合、m×n の下台形行列 $V$ と、サイズ $n_b$×$n_b$ の上三角行列 $T_j$($j = 1, ..., b-1$)を $b = \lceil \min(m,n) / n_b \rceil$ 個並べた行列 $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$ の要素が格納されます。つまり、
QRオブジェクトFではR = triu(F.factors)です。 - 対角より下の部分には、
V = I + tril(F.factors, -1)となるよう、反射子 $v_i$ がパック形式で格納されます。
- 上三角部分には $R$ の要素が格納されます。つまり、
Tは、上記のとおり $n_b$-by-$\min(m,n)$ 行列です。各三角行列 $T_j$ の対角より下の要素は無視されます。
この形式は、古い WY 表現 [Bischof1987] と混同しないでください。
LinearAlgebra.QRPivoted — Type
QRPivoted <: Factorization列ピボット選択付きQR行列分解をパック形式で格納したものです。通常、qrから得られます。$A$がm×n行列の場合、
\[A P = Q R\]
ここで、$P$は置換行列、$Q$は直交行列/ユニタリ行列、$R$は上三角行列です。行列$Q$は、ハウスホルダー反射の列として格納されます。
\[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T).\]
分解を反復すると、成分Q、R、pが得られます。
このオブジェクトは3つのフィールドを持ちます。
factorsは、m×n行列です。- 上三角部分には$R$の要素が格納されます。つまり、
QRオブジェクトFの場合はR = triu(F.factors)です。 - 対角線より下の部分には、パック形式で格納された反射$v_i$が含まれます。このとき、$v_i$は行列
V = I + tril(F.factors, -1)の$i$列です。
- 上三角部分には$R$の要素が格納されます。つまり、
τは、係数$au_i$を格納する長さmin(m,n)のベクトルです。jpvtは、置換$P$に対応する長さnの整数ベクトルです。
LinearAlgebra.qr — Function
qr(A::SparseMatrixCSC; tol=_default_tol(A), ordering=ORDERING_DEFAULT) -> QRSparse疎行列 A の QR 分解を計算します。フィルインを抑えるため、行と列の置換を行い、F.R = F.Q'*A[F.prow,F.pcol] とします。この分解は主に、\ を用いて最小二乗問題や劣決定問題を解くために使われます。この関数は C ライブラリ SPQR[ACM933] を呼び出します。
返される QRSparse オブジェクトは、ldiv!() 呼び出し用の内部ワークスペースを使用します。このワークスペースはスレッドセーフを確保するため、ロックで保護されています。マルチスレッドで使用する場合は、各タスク用に copy(F) でこのオブジェクトのコピーを個別に作成してください。
qr(A::SparseMatrixCSC) は、SuiteSparse に含まれる SPQR ライブラリを使用します。このライブラリがサポートする疎行列の要素型は Float64 または ComplexF64 のみです。そのため、Julia v1.4 以降では、qr は A を、適切な型である SparseMatrixCSC{Float64} または SparseMatrixCSC{ComplexF64} のコピーに変換します。
Examples
julia> A = sparse([1,2,3,4], [1,1,2,2], [1.0,1.0,1.0,1.0])
4×2 SparseMatrixCSC{Float64, Int64} with 4 stored entries:
1.0 ⋅
1.0 ⋅
⋅ 1.0
⋅ 1.0
julia> qr(A)
SparseArrays.SPQR.QRSparse{Float64, Int64}
Q factor:
4×4 SparseArrays.SPQR.QRSparseQ{Float64, Int64}
R factor:
2×2 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
-1.41421 ⋅
⋅ -1.41421
Row permutation:
4-element Vector{Int64}:
1
3
4
2
Column permutation:
2-element Vector{Int64}:
1
2qr(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 因子、つまり m×m の直交行列を取得するには、F.Q*I または collect(F.Q) を使用します。m<=n の場合、Matrix(F.Q) は m×m の直交行列を返します。
pivot == NoPivot() かつ A isa StridedMatrix{<:BlasFloat} の場合、QR 分解のブロックサイズをキーワード引数 blocksize :: Integer で指定できます。blocksize > minimum(size(A)) の場合、この引数は無視されます。QRCompactWY を参照してください。
Examples
julia> A = [3.0 -6.0; 4.0 -8.0; 0.0 1.0]
3×2 Matrix{Float64}:
3.0 -6.0
4.0 -8.0
0.0 1.0
julia> F = qr(A)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}, Matrix{Float64}}
Q factor: 3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R factor:
2×2 Matrix{Float64}:
-5.0 10.0
0.0 -1.0
julia> F.Q * F.R == A
trueLinearAlgebra.qr! — Function
qr!(A, pivot = NoPivot(); blocksize)qr!は、AがAbstractMatrixのサブタイプである場合、qrと同じですが、コピーを作成せず、入力のAを上書きすることでメモリを節約します。因数分解の結果がAの要素型で表現できない数になる場合(整数型など)、InexactError例外がスローされます。
Examples
julia> a = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
1.0 2.0
3.0 4.0
julia> qr!(a)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}, Matrix{Float64}}
Q factor: 2×2 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R factor:
2×2 Matrix{Float64}:
-3.16228 -4.42719
0.0 -0.632456
julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> qr!(a)
ERROR: InexactError: Int64(3.1622776601683795)
Stacktrace:
[...]LinearAlgebra.LQ — Type
LQ <: Factorization行列 A の LQ 分解の行列因子分解型です。LQ 分解は、transpose(A) の QR 分解です。これは、対応する行列因子分解関数 lq の戻り値の型です。
S::LQ が分解オブジェクトの場合、下三角成分は S.L で、直交/ユニタリ成分は S.Q で取得できます。このとき、A ≈ S.L*S.Q となります。
分解を反復処理すると、成分 S.L と S.Q が得られます。
Examples
julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> S = lq(A)
LQ{Float64, Matrix{Float64}, Vector{Float64}}
L factor:
2×2 Matrix{Float64}:
-8.60233 0.0
4.41741 -0.697486
Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}
julia> S.L * S.Q
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> l, q = S; # destructuring via iteration
julia> l == S.L && q == S.Q
trueLinearAlgebra.lq — Function
lq(A) -> S::LQA の LQ 分解を計算します。分解の下三角成分は、LQ オブジェクト S から S.L を使って取得でき、直交/ユニタリ成分は S.Q を使って取得できます。このとき、A ≈ S.L*S.Q となります。
分解を反復すると、成分 S.L と S.Q が得られます。
LQ 分解は transpose(A) の QR 分解であり、劣決定系の方程式(A は行数より列数が多いものの、行フルランクである)の最小ノルム解 lq(A) \ b を求めるのに役立ちます。
Examples
julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> S = lq(A)
LQ{Float64, Matrix{Float64}, Vector{Float64}}
L factor:
2×2 Matrix{Float64}:
-8.60233 0.0
4.41741 -0.697486
Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}
julia> S.L * S.Q
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> l, q = S; # destructuring via iteration
julia> l == S.L && q == S.Q
trueLinearAlgebra.lq! — Function
LinearAlgebra.BunchKaufman — Type
BunchKaufman <: Factorization対称行列またはエルミート行列 A に対する Bunch-Kaufman 分解の行列分解型です。A に上三角部分(デフォルト)と下三角部分のどちらが格納されているかに応じて、P'UDU'P または P'LDL'P となります。ここで、U と L はそれぞれ上三角行列と下三角行列、P は置換行列、D は 1×1 および 2×2 のブロックからなるブロック対角行列です。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 が生成されます。
Examples
julia> A = Float64.([1 2; 2 3])
2×2 Matrix{Float64}:
1.0 2.0
2.0 3.0
julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
-0.333333 0.0
0.0 3.0
U factor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
1.0 0.666667
⋅ 1.0
permutation:
2-element Vector{Int64}:
1
2
julia> d, u, p = S; # destructuring via iteration
julia> d == S.D && u == S.U && p == S.p
true
julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
3.0 0.0
0.0 -0.333333
L factor:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
1.0 ⋅
0.666667 1.0
permutation:
2-element Vector{Int64}:
2
1LinearAlgebra.bunchkaufman — Function
bunchkaufman(A, rook::Bool=false; check = true) -> S::BunchKaufman対称行列またはエルミート行列 A の Bunch-Kaufman 分解[Bunch1977]を計算します。A に格納されている三角部分に応じて、P'*U*D*U'*P または P'*L*D*L'*P として分解し、BunchKaufman オブジェクトを返します。ここで、U と L はそれぞれ上三角行列と下三角行列、P は置換行列、D は 1×1 および 2×2 ブロックからなるブロック対角行列です。A が複素対称行列の場合、U' と L' は共役を取らない転置を表すことに注意してください。すなわち、transpose(U) と transpose(L) です。
分解を反復すると、S.uplo に応じて、S.D、S.U または S.L、および S.p の各成分が得られます。
rook が true の場合、rook ピボット法が使用されます。rook が false の場合、rook ピボット法は使用されません。
check = true の場合、分解に失敗するとエラーがスローされます。check = false の場合、分解が有効かどうか(issuccess を使用)の確認はユーザーの責任です。
BunchKaufman オブジェクトでは、次の関数を使用できます: size、\、inv、issymmetric、ishermitian、getindex。
Examples
julia> A = Float64.([1 2; 2 3])
2×2 Matrix{Float64}:
1.0 2.0
2.0 3.0
julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
-0.333333 0.0
0.0 3.0
U factor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
1.0 0.666667
⋅ 1.0
permutation:
2-element Vector{Int64}:
1
2
julia> d, u, p = S; # destructuring via iteration
julia> d == S.D && u == S.U && p == S.p
true
julia> S.U * S.D * S.U' ≈ S.P * A * S.P'
true
julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
3.0 0.0
0.0 -0.333333
L factor:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
1.0 ⋅
0.666667 1.0
permutation:
2-element Vector{Int64}:
2
1
julia> S.L * S.D * S.L' ≈ A[S.p, S.p]
trueLinearAlgebra.bunchkaufman! — Function
bunchkaufman!(A, rook::Bool=false; check = true) -> BunchKaufmanbunchkaufman! は bunchkaufman と同じですが、コピーを作成せずに入力 A を上書きするため、メモリを節約できます。
LinearAlgebra.Eigen — Type
Eigen <: Factorization正方行列 A の固有値分解(スペクトル分解)を表す行列分解型です。対応する行列分解関数 eigen の戻り値の型です。
F::Eigen が分解オブジェクトの場合、固有値は F.values で取得でき、固有ベクトルは行列 F.vectors の列として得られます。(k 番目の固有ベクトルは、スライス F.vectors[:, k] から取得できます。)
この分解を反復すると、成分 F.values と F.vectors が得られます。
Examples
julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
1.0
3.0
18.0
vectors:
3×3 Matrix{Float64}:
1.0 0.0 0.0
0.0 1.0 0.0
0.0 0.0 1.0
julia> F.values
3-element Vector{Float64}:
1.0
3.0
18.0
julia> F.vectors
3×3 Matrix{Float64}:
1.0 0.0 0.0
0.0 1.0 0.0
0.0 0.0 1.0
julia> vals, vecs = F; # destructuring via iteration
julia> vals == F.values && vecs == F.vectors
trueLinearAlgebra.GeneralizedEigen — Type
GeneralizedEigen <: FactorizationAとBの一般化固有値分解/スペクトル分解を表す行列因子分解型です。2つの行列引数を指定して呼び出した場合に、対応する行列因子分解関数であるeigenが返す型です。
F::GeneralizedEigenが因子分解オブジェクトの場合、固有値はF.valuesで取得でき、固有ベクトルは行列F.vectorsの列として得られます。(k番目の固有ベクトルは、スライスF.vectors[:, k]から取得できます。)
この分解を反復処理すると、成分F.valuesとF.vectorsが生成されます。
Examples
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
trueLinearAlgebra.eigvals — Function
eigvals(A; permute::Bool=true, scale::Bool=true, sortby) -> valuesA の固有値を返します。
一般の非対称行列では、固有値を計算する前に行列をどのようにバランス調整するかを指定できます。キーワード permute、scale、sortby は、eigen と同じです。
Examples
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はスカラーを返します。
Examples
julia> eigvals(-2)
-2eigvals(A, B) -> valuesA と B の一般化固有値を計算します。
Examples
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.0imeigvals(A::Union{Hermitian, Symmetric}; alg::Algorithm = default_eigen_alg(A))) -> valuesA の固有値を返します。
alg は、固有値分解に使用するアルゴリズムと LAPACK の手法を指定します。
alg = DivideAndConquer():LAPACK.syevd!を呼び出します。alg = QRIteration():LAPACK.syev!を呼び出します。alg = RobustRepresentations()(デフォルト): 複数の相対的にロバストな表現を用いる手法です。LAPACK.syevr!を呼び出します。
各手法の精度と性能の比較については、James W. Demmel ほか、SIAM J. Sci. Comput. 30, 3, 1508 (2008) を参照してください。
使用されるデフォルトの alg は、将来変更される可能性があります。
eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> valuesA の固有値を返します。ソートされた固有値のインデックス範囲を指定する UnitRange irange を指定すると、固有値の一部だけを計算できます。たとえば、2番目から8番目までの固有値を指定できます。
Examples
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.140054944640259eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> valuesAの固有値を返します。固有値の下限と上限を指定するvlとvuのペアを指定すると、固有値の一部だけを計算できます。
Examples
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.140054944640259LinearAlgebra.eigvals! — Function
eigvals!(A; permute::Bool=true, scale::Bool=true, sortby) -> valueseigvalsと同じですが、コピーを作成せず、入力のAを上書きすることで、メモリを節約します。permute、scale、sortbyの各キーワードは、eigenの場合と同じです。
Examples
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.37228eigvals!(A, B; sortby) -> valueseigvalsと同じですが、コピーを作成する代わりに入力のA(およびB)を上書きすることで、メモリを節約します。
Examples
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.0eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> valueseigvalsと同じですが、コピーを作成せずに入力のAを上書きするため、メモリを節約できます。irangeは、検索対象となる固有値のインデックスの範囲です。たとえば、2番目から8番目までの固有値を指定します。
eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> valueseigvalsと同じですが、コピーを作成せずに入力Aを上書きするため、メモリを節約できます。vlは固有値を探索する区間の下限、vuは上限です。
LinearAlgebra.eigmax — Function
eigmax(A; permute::Bool=true, scale::Bool=true)Aの最大固有値を返します。オプションpermute=trueを指定すると、行列を並べ替えて上三角行列に近づけます。また、scale=trueを指定すると、行列を対角要素でスケーリングし、各行と各列のノルムをより均等にします。Aの固有値が複素数の場合、複素数はソートできないため、この方法は失敗することに注意してください。
Examples
julia> A = [0 im; -im 0]
2×2 Matrix{Complex{Int64}}:
0+0im 0+1im
0-1im 0+0im
julia> eigmax(A)
1.0
julia> A = [0 im; -1 0]
2×2 Matrix{Complex{Int64}}:
0+0im 0+1im
-1+0im 0+0im
julia> eigmax(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` cannot have complex eigenvalues.
Stacktrace:
[...]LinearAlgebra.eigmin — Function
eigmin(A; permute::Bool=true, scale::Bool=true)A の最小固有値を返します。オプション permute=true は、行列がより上三角行列に近づくように並べ替えます。また、scale=true は、対角要素を使って行列をスケーリングし、各行と列のノルムがより均等になるようにします。A の固有値が複素数の場合、この方法は失敗します。複素数はソートできないためです。
Examples
julia> A = [0 im; -im 0]
2×2 Matrix{Complex{Int64}}:
0+0im 0+1im
0-1im 0+0im
julia> eigmin(A)
-1.0
julia> A = [0 im; -1 0]
2×2 Matrix{Complex{Int64}}:
0+0im 0+1im
-1+0im 0+0im
julia> eigmin(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` cannot have complex eigenvalues.
Stacktrace:
[...]LinearAlgebra.eigvecs — Function
eigvecs(A::Union{Symmetric, Hermitian, SymTridiagonal}[, eigvals])::Matrix列がAの固有ベクトルとなる行列Mを返します。(k番目の固有ベクトルは、スライスM[:, k]から取得できます。)
固有値のオプションベクトルeigvalsを指定すると、eigvecsは対応する固有ベクトルを返します。
Examples
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.5547001962252291eigvecs(A; permute::Bool=true, scale::Bool=true, `sortby`) -> Matrix列がAの固有ベクトルとなる行列Mを返します。(k番目の固有ベクトルは、スライスM[:, k]から取得できます。)キーワードpermute、scale、sortbyは、eigenの場合と同じです。
Examples
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.0eigvecs(A, B) -> Matrix列が A と B の一般化固有ベクトルとなる行列 M を返します。(k 番目の固有ベクトルは、スライス M[:, k] から取得できます。)
Examples
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.0imLinearAlgebra.eigen — Function
eigen(A; permute::Bool=true, scale::Bool=true, sortby) -> EigenA の固有値分解を計算し、固有値を F.values に、正規化された固有ベクトルを行列 F.vectors の列に格納した、Eigen 分解オブジェクト F を返します。これは、A が行列、x が固有ベクトル、λ が固有値である固有値問題 Ax = λ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 キーワードを受け付けない場合があります。
Examples
julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
1.0
3.0
18.0
vectors:
3×3 Matrix{Float64}:
1.0 0.0 0.0
0.0 1.0 0.0
0.0 0.0 1.0
julia> F.values
3-element Vector{Float64}:
1.0
3.0
18.0
julia> F.vectors
3×3 Matrix{Float64}:
1.0 0.0 0.0
0.0 1.0 0.0
0.0 0.0 1.0
julia> vals, vecs = F; # destructuring via iteration
julia> vals == F.values && vecs == F.vectors
trueeigen(A, B; sortby) -> GeneralizedEigenA と B の一般化固有値分解を計算し、一般化固有値を F.values に、一般化固有ベクトルを行列 F.vectors の列に格納した GeneralizedEigen 分解オブジェクト F を返します。これは、A, B が行列、x が固有ベクトル、λ が固有値である、次の形式の一般化固有値問題を解くことに相当します: Ax = λBx。(k 番目の一般化固有ベクトルは、スライス F.vectors[:, k] から取得できます。)
この分解を反復すると、成分 F.values と F.vectors が得られます。
デフォルトでは、固有値と固有ベクトルは (real(λ),imag(λ)) の辞書順でソートされます。別の比較関数 by(λ) を sortby に渡すことも、sortby=nothing を渡して固有値を任意の順序のままにすることもできます。
Examples
julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
1 0
0 -1
julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
0 1
1 0
julia> F = eigen(A, B);
julia> F.values
2-element Vector{ComplexF64}:
0.0 - 1.0im
0.0 + 1.0im
julia> F.vectors
2×2 Matrix{ComplexF64}:
0.0+1.0im 0.0-1.0im
-1.0+0.0im -1.0-0.0im
julia> vals, vecs = F; # destructuring via iteration
julia> vals == F.values && vecs == F.vectors
trueeigen(A::Union{Hermitian, Symmetric}; alg::LinearAlgebra.Algorithm = LinearAlgebra.default_eigen_alg(A)) -> EigenAの固有値分解を計算し、固有値をF.valuesに、正規直交固有ベクトルを行列F.vectorsの列に格納した、Eigenの分解オブジェクトFを返します。(k番目の固有ベクトルは、スライスF.vectors[:, k]から取得できます。)
この分解を反復すると、成分F.valuesとF.vectorsが得られます。
algでは、固有値分解に使用するアルゴリズムとLAPACKの手法を指定します。
alg = DivideAndConquer():LAPACK.syevd!を呼び出します。alg = QRIteration():LAPACK.syev!を呼び出します。alg = RobustRepresentations()(デフォルト):多重相対ロバスト表現法。LAPACK.syevr!を呼び出します。
各アルゴリズムの精度と性能の比較については、James W. Demmel et al, SIAM J. Sci. Comput. 30, 3, 1508 (2008)を参照してください。
今後、使用されるデフォルトのalgが変更される可能性があります。
eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> EigenA の固有値分解を計算し、固有値を 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) -> EigenA の固有値分解を計算し、固有値を F.values に、正規直交固有ベクトルを行列 F.vectors の列に格納した、Eigen の分解オブジェクト F を返します。(k 番目の固有ベクトルは、スライス F.vectors[:, k] から取得できます。)
この分解を反復すると、成分 F.values と F.vectors が得られます。
Eigen オブジェクトでは、次の関数を使用できます:inv、det、isposdef。
vl は検索対象とする固有値の範囲の下限、vu は上限です。
LinearAlgebra.eigen! — Function
eigen!(A; permute, scale, sortby)
eigen!(A, B; sortby)eigenと同じですが、コピーを作成せずに入力A(およびB)を上書きするため、メモリを節約できます。
LinearAlgebra.Hessenberg — Type
Hessenberg <: FactorizationHessenbergオブジェクトは、正方行列のヘッセンベルグ分解QHQ'、またはそのシフトQ(H+μI)Q'を表します。これはhessenberg関数によって生成されます。
LinearAlgebra.hessenberg — Function
hessenberg(A) -> HessenbergA のヘッセンベルグ分解を計算し、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.μ が得られます。
Examples
julia> A = [4. 9. 7.; 4. 4. 1.; 4. 3. 2.]
3×3 Matrix{Float64}:
4.0 9.0 7.0
4.0 4.0 1.0
4.0 3.0 2.0
julia> F = hessenberg(A)
Hessenberg{Float64, UpperHessenberg{Float64, Matrix{Float64}}, Matrix{Float64}, Vector{Float64}, Bool}
Q factor: 3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}
H factor:
3×3 UpperHessenberg{Float64, Matrix{Float64}}:
4.0 -11.3137 -1.41421
-5.65685 5.0 2.0
⋅ -8.88178e-16 1.0
julia> F.Q * F.H * F.Q'
3×3 Matrix{Float64}:
4.0 9.0 7.0
4.0 4.0 1.0
4.0 3.0 2.0
julia> q, h = F; # destructuring via iteration
julia> q == F.Q && h == F.H
trueLinearAlgebra.hessenberg! — Function
hessenberg!(A) -> Hessenberghessenberg!はhessenbergと同じですが、コピーを作成せずに入力Aを上書きするため、容量を節約できます。
LinearAlgebra.Schur — Type
Schur <: Factorization行列 A のシュール分解における行列因子分解の型です。対応する行列因子分解関数 schur(_) の戻り値の型です。
因子分解オブジェクトが F::Schur の場合、(準)三角シュール因子は F.Schur または F.T で取得でき、直交/ユニタリなシュールベクトルは F.vectors または F.Z で取得できます。このとき A = F.vectors * F.Schur * F.vectors' が成り立ちます。A の固有値は F.values で取得できます。
分解を反復処理すると、成分 F.T、F.Z、F.values が得られます。
Examples
julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
3.0 9.0
0.0 -2.0
Z factor:
2×2 Matrix{Float64}:
0.961524 0.274721
-0.274721 0.961524
eigenvalues:
2-element Vector{Float64}:
3.0
-2.0
julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> t, z, vals = F; # destructuring via iteration
julia> t == F.T && z == F.Z && vals == F.values
trueLinearAlgebra.GeneralizedSchur — Type
GeneralizedSchur <: Factorization2つの行列 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 — Function
schur(A) -> F::Schur行列 A のシュール分解を計算します。(準)三角シュール因子は、Schur オブジェクト F から F.Schur または F.T を使って取得できます。また、直交/ユニタリなシュールベクトルは F.vectors または F.Z を使って取得でき、A = F.vectors * F.Schur * F.vectors' が成り立ちます。A の固有値は F.values を使って取得できます。
実数の A では、シュール因子は「準三角」です。これは、複素固有値の共役ペアに対して対角ブロックが 2×2 となる点を除き、上三角行列であることを意味します。このため、複素固有値がある場合でも分解を完全に実数のまま表せます。実数の準三角分解から(複素数の)純粋な上三角シュール分解を得るには、Schur{Complex}(schur(A)) を使います。
この分解を反復すると、成分 F.T、F.Z、F.values が得られます。
Examples
julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
3.0 9.0
0.0 -2.0
Z factor:
2×2 Matrix{Float64}:
0.961524 0.274721
-0.274721 0.961524
eigenvalues:
2-element Vector{Float64}:
3.0
-2.0
julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> t, z, vals = F; # destructuring via iteration
julia> t == F.T && z == F.Z && vals == F.values
trueschur(A, B) -> F::GeneralizedSchur行列 A と B の一般化シュール分解(QZ 分解)を計算します。(準)三角シュール因子は、Schur オブジェクト F から F.S と F.T を使って取得できます。左側のユニタリ/直交シュールベクトルは F.left または F.Q で、右側のユニタリ/直交シュールベクトルは F.right または F.Z で取得でき、A=F.left*F.S*F.right' および B=F.left*F.T*F.right' が成り立ちます。行列 A と B の一般化固有値は、F.α./F.β で取得できます。
分解を反復すると、成分 F.S、F.T、F.Q、F.Z、F.α、および F.β が得られます。
LinearAlgebra.schur! — Function
schur!(A) -> F::Schurschurと同じですが、入力引数Aをワークスペースとして使用します。
Examples
julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
5.0 7.0
-2.0 -4.0
julia> F = schur!(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
3.0 9.0
0.0 -2.0
Z factor:
2×2 Matrix{Float64}:
0.961524 0.274721
-0.274721 0.961524
eigenvalues:
2-element Vector{Float64}:
3.0
-2.0
julia> A
2×2 Matrix{Float64}:
3.0 9.0
0.0 -2.0schur!(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchurschurと同じですが、入力行列AおよびBをワークスペースとして使用します。
LinearAlgebra.ordschur — Function
ordschur(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur行列 A = Z*T*Z' のシュール分解 F を、論理配列 select に従って並べ替え、並べ替え後の分解オブジェクト F を返します。選択された固有値は F.Schur の先頭の対角成分に現れ、それに対応する F.vectors の先頭列は、対応する右不変部分空間の直交基底/ユニタリ基底を成します。実数の場合、複素共役な固有値のペアは、select によって必ず両方とも選択するか、両方とも選択しないようにしてください。
ordschur(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur行列ペア (A, B) = (Q*S*Z', Q*T*Z') の一般化 Schur 分解 F を論理配列 select に従って並べ替え、GeneralizedSchur オブジェクト F を返します。選択された固有値は F.S と F.T の両方の対角成分の先頭に配置されます。また、左および右の直交/ユニタリ Schur ベクトルも並べ替えられるため、(A, B) = F.Q*(F.S, F.T)*F.Z' が引き続き成り立ち、A と B の一般化固有値を引き続き F.α./F.β で求められます。
LinearAlgebra.ordschur! — Function
ordschur!(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schurordschurと同じですが、因子分解Fを上書きします。
ordschur!(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchurordschurと同じですが、因子分解Fを上書きします。
LinearAlgebra.SVD — Type
SVD <: Factorization行列 A の特異値分解(SVD)を表す行列因子分解型です。対応する行列因子分解関数 svd(_) の戻り値の型です。
F::SVD が因子分解オブジェクトの場合、U、S、V、Vt は、それぞれ F.U、F.S、F.V、F.Vt で取得できます。このとき、A = U * Diagonal(S) * Vt が成り立ちます。S の特異値は降順に並んでいます。
分解を反復すると、成分 U、S、V が得られます。
Examples
julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
4×5 Matrix{Float64}:
1.0 0.0 0.0 0.0 2.0
0.0 0.0 3.0 0.0 0.0
0.0 0.0 0.0 0.0 0.0
0.0 2.0 0.0 0.0 0.0
julia> F = svd(A)
SVD{Float64, Float64, Matrix{Float64}, Vector{Float64}}
U factor:
4×4 Matrix{Float64}:
0.0 1.0 0.0 0.0
1.0 0.0 0.0 0.0
0.0 0.0 0.0 1.0
0.0 0.0 -1.0 0.0
singular values:
4-element Vector{Float64}:
3.0
2.23606797749979
2.0
0.0
Vt factor:
4×5 Matrix{Float64}:
-0.0 0.0 1.0 -0.0 0.0
0.447214 0.0 0.0 0.0 0.894427
0.0 -1.0 0.0 0.0 0.0
0.0 0.0 0.0 1.0 0.0
julia> F.U * Diagonal(F.S) * F.Vt
4×5 Matrix{Float64}:
1.0 0.0 0.0 0.0 2.0
0.0 0.0 3.0 0.0 0.0
0.0 0.0 0.0 0.0 0.0
0.0 2.0 0.0 0.0 0.0
julia> u, s, v = F; # destructuring via iteration
julia> u == F.U && s == F.S && v == F.V
trueLinearAlgebra.GeneralizedSVD — Type
GeneralizedSVD <: Factorization2つの行列 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は M×(K+L) の対角行列で、最初の K 個の要素は 1 です。D2は P×(K+L) の行列で、右上の L×L ブロックは対角行列です。R0は (K+L)×N の行列で、右端の (K+L)×(K+L) ブロックは正則な上三角ブロック行列です。
K+L は、行列 [A; B] の実効数値ランクです。
分解を反復すると、成分 U、V、Q、D1、D2、R0 が得られます。
F.D1 と F.D2 の要素の関係については、内部で呼び出される generalized SVD および xGGSVD3 ルーチンの LAPACK ドキュメント(LAPACK 3.6.0 以降)を参照してください。
Examples
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.0LinearAlgebra.svd — Function
svd(A; full::Bool = false, alg::Algorithm = default_svd_alg(A), atol::Real=0, rtol::Real=0) -> SVDA の特異値分解(SVD)を計算し、SVD オブジェクトを返します。
U、S、V、Vt は、F.U、F.S、F.V、F.Vt を用いた因数分解 F から得られます。このとき、A = U * Diagonal(S) * Vt が成り立ちます。このアルゴリズムは Vt を生成するため、Vt は V より効率よく取り出せます。S 内の特異値は降順に並んでいます。
分解を反復すると、成分 U、S、V が得られます。
full = false(デフォルト)の場合、「thin」SVD が返されます。$M \times N$ 行列 A について、完全分解では U は $M \times M$、V は $N \times N$ です。一方、thin 分解では U は $M \times K$、V は $N \times K$ です。ここで、$K = \min(M,N)$ は特異値の個数です。
alg は、SVD に使用するアルゴリズムと LAPACK の手法を指定します。
alg = LinearAlgebra.DivideAndConquer()(デフォルト):LAPACK.gesdd!を呼び出します。alg = LinearAlgebra.QRIteration():LAPACK.gesvd!を呼び出します(通常は低速ですが、より高精度です)。
atol と rtol は、SVD を打ち切るための省略可能な許容誤差を指定します。max(atol, rtol*σ₁) 未満の特異値は削除され(ゼロに設定され)ます。ここで、σ₁ は A の最大特異値です。
Examples
julia> A = rand(4,3);
julia> F = svd(A); # Store the Factorization Object
julia> A ≈ F.U * Diagonal(F.S) * F.Vt
true
julia> U, S, V = F; # destructuring via iteration
julia> A ≈ U * Diagonal(S) * V'
true
julia> Uonly, = svd(A); # Store U only
julia> Uonly == U
truesvd(A, B) -> GeneralizedSVDA と B の一般化特異値分解を計算し、次の条件を満たす GeneralizedSVD 分解オブジェクト F を返します。[A;B] = [F.U * F.D1; F.V * F.D2] * F.R0 * F.Q'
Uは M×M の直交行列です。Vは P×P の直交行列です。Qは N×N の直交行列です。D1は M×(K+L) の対角行列で、最初の K 個の対角成分は 1 です。D2は P×(K+L) の行列で、右上の L×L ブロックは対角行列です。R0は (K+L)×N の行列で、右端の (K+L)×(K+L) ブロックは正則な上三角ブロック行列です。
K+L は、行列 [A; B] の実効数値ランクです。
この分解を反復して得られる成分は、U、V、Q、D1、D2、R0 です。
一般化特異値分解は、ヒトと酵母のゲノム、信号とノイズ、あるいはクラスター間とクラスター内のように、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 は、その測定方向を示します。
Examples
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
trueLinearAlgebra.svd! — Function
svd!(A; full::Bool = false, alg::Algorithm = default_svd_alg(A), atol::Real=0, rtol::Real=0) -> SVDsvd!はsvdと同じですが、コピーを作成せずに入力のAを上書きするため、メモリを節約できます。詳細については、svdのドキュメントを参照してください。
LinearAlgebra.svdvals — Function
svdvals(A)Aの特異値を降順で返します。
Examples
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.0svdvals(A, B)A と B の一般化特異値分解から、一般化特異値を返します。svd も参照してください。
Examples
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.0LinearAlgebra.Givens — Type
LinearAlgebra.Givens(i1,i2,c,s) -> Gギブンス回転を表す線形作用素です。フィールド c と s は、それぞれ回転角の余弦と正弦を表します。型 Givens は、左からの乗算 G*A と、共役転置による右からの乗算 A*G' をサポートします。この型には size がないため、G*A に対しては i2<=size(A,2)、A*G' に対しては i2<=size(A,1) が成り立つ限り、任意のサイズの行列と乗算できます。
関連項目: givens。
LinearAlgebra.givens — Function
givens(f::T, g::T, i1::Integer, i2::Integer) where {T} -> (G::Givens, r::T)任意のベクトル x に対して、次の条件が成り立つようなギブンス回転 G とスカラー r を計算します。
x[i1] = f
x[i2] = g積
y = G*xの結果が次の性質を持つようにします。
y[i1] = r
y[i2] = 0LinearAlgebra.Givens も参照してください。
givens(A::AbstractArray, i1::Integer, i2::Integer, j::Integer) -> (G::Givens, r)ギブンス回転 G とスカラー r を計算します。これらは、次の積の結果が
B = G*A次の性質を満たすように選ばれます。
B[i1,j] = r
B[i2,j] = 0LinearAlgebra.Givens も参照してください。
givens(x::AbstractVector, i1::Integer, i2::Integer) -> (G::Givens, r)積の結果が次の性質を満たすような、ギブンス回転 G とスカラー r を計算します。
B = G*xつまり、
B[i1] = r
B[i2] = 0関連項目: LinearAlgebra.Givens。
LinearAlgebra.triu — Function
triu(M, k::Integer = 0)Mのk番目の超対角線から始まる上三角部分を返します。
Examples
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.0LinearAlgebra.triu! — Function
triu!(M)行列の上三角部分を取り出し、その過程でMを上書きします。triuも参照してください。
triu!(M, k::Integer)k番目の上副対角線から始まるMの上三角部分を返し、その過程でMを上書きします。
Examples
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 0LinearAlgebra.tril — Function
tril(M, k::Integer = 0)k 番目の上対角線から始まる、M の下三角部分を返します。
Examples
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.0LinearAlgebra.tril! — Function
tril!(M)行列の下三角部分。処理中にMを上書きします。trilも参照してください。
tril!(M, k::Integer)Mのk番目の上副対角線から始まる下三角部分を返します。その際、Mを上書きします。
Examples
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 5LinearAlgebra.diagind — Function
diagind(M::AbstractMatrix, k::Integer = 0, indstyle::IndexStyle = IndexLinear())
diagind(M::AbstractMatrix, indstyle::IndexStyle = IndexLinear())
diagind(::IndexStyle, m::Integer, n::Integer, k::Integer = 0)
diagind(m::Integer, n::Integer, k::Integer = 0)行列の k 番目の対角線のインデックスを返す AbstractRange です。行列 M 自体、またはその次元 m と n を指定します。必要に応じて、返される範囲の型を決めるインデックススタイルも指定できます。indstyle isa IndexLinear(デフォルト)の場合、AbstractRange{Integer} を返します。一方、indstyle isa IndexCartesian の場合は、AbstractRange{CartesianIndex{2}} を返します。
k を指定しない場合は、0(主対角線に対応)とみなされます。
Examples
行列自体を diagind に渡すことができます。
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)または、次元 m と n を渡すと、m×n 行列の対角線を取得できます。
julia> m, n = 5, 7
(5, 7)
julia> diagind(m, n, 2)
11:6:35
julia> diagind(IndexCartesian(), m, n)
StepRangeLen(CartesianIndex(1, 1), CartesianIndex(1, 1), 5)LinearAlgebra.diagm — Function
diagm(kv::Pair{<:Integer,<:AbstractVector}...)
diagm(m::Integer, n::Integer, kv::Pair{<:Integer,<:AbstractVector}...)対角線とベクトルのPairから行列を構築します。ベクトルkv.secondは、kv.first対角線上に配置されます。デフォルトでは行列は正方行列で、そのサイズはkvから推定されます。ただし、最初の引数としてm,nを渡すと、必要に応じてゼロで埋められる、m×nの非正方サイズを指定できます。対角線のインデックスkv.firstが重複する場合、対応するベクトルkv.secondの値は加算されます。
diagmは密行列を構築します。メモリ効率に優れ、高速な演算が可能な形式については、Diagonal、Bidiagonal Tridiagonal、SymTridiagonalを参照してください。
Examples
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 0diagm(v::AbstractVector)
diagm(m::Integer, n::Integer, v::AbstractVector)ベクトルの要素を対角成分とする行列を構築します。デフォルトでは正方行列となり、そのサイズはlength(v)で指定されます。ただし、最初の引数としてm,nを渡すと、m×nの非正方行列を指定できます。必要に応じて、対角成分にはゼロが補われます。
Examples
julia> diagm([1,2,3])
3×3 Matrix{Int64}:
1 0 0
0 2 0
0 0 3
julia> diagm(4, 5, [1,2,3])
4×5 Matrix{Int64}:
1 0 0 0 0
0 2 0 0 0
0 0 3 0 0
0 0 0 0 0LinearAlgebra.rank — Function
rank(::QRSparse{Tv,Ti}) -> TiQR 分解のランクを返します。
rank(S::SparseMatrixCSC{Tv,Ti}; [tol::Real]) -> TiQR 分解を計算して、S のランクを求めます。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で非推奨になります。
Examples
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)
1rank(S::SVD{<:Any, T}; atol::Real=0, rtol::Real=min(n,m)*ϵ) where {T}SVD オブジェクト S の数値ランクを、特異値のうち max(atol, rtol*σ₁) より大きいものの個数として計算します。ここで、σ₁ は計算された特異値の最大値です。これはデフォルトの rank(::AbstractMatrix) メソッドと同等ですが、既存の SVD 分解を再利用します。atol と rtol は、それぞれ絶対許容誤差と相対許容誤差です。デフォルトの相対許容誤差は n*ϵ です。ここで、n は UΣV' の最小次元のサイズ、ϵ は S の要素型の eps です。
rank(A::QRPivoted{<:Any, T}; atol::Real=0, rtol::Real=min(n,m)*ϵ) where {T}QR 分解 A の数値ランクは、A.factors の対角成分のうち、max(atol, rtol*Δ₁) を上回るものの個数として計算します。ここで、Δ₁ は、計算された対角成分のうち最大の値です。行列分解から(数値的に)ゼロでない係数の個数を数える点では、rank(::AbstractMatrix) メソッドと似ています。ただし、デフォルトのメソッドでは QR 分解ではなく SVD を使用します。また、rank(::SVD) と同様に、このメソッドも既存の行列分解を再利用します。
QR 分解を使ってランクを計算した場合、通常は SVD を使った場合と同じ結果になります。ただし、行列の条件が悪い病的なケースでは、ランクを過大評価しやすくなる可能性があります。また、一般に QR 分解は SVD より高速に計算できるため、性能が重要な場合にはこのメソッドが適していることがあります。
atol と rtol は、それぞれ絶対許容誤差と相対許容誤差です。相対許容誤差のデフォルト値は n*ϵ です。ここで、n は A の最小次元のサイズ、ϵ は A の要素型の eps です。
LinearAlgebra.norm — Function
norm(A, p::Real=2)数値(または norm が定義されている任意の要素型)からなる反復可能なコンテナ A(任意の次元の配列を含む)について、A を対応する長さのベクトルとみなした場合の p ノルムを計算します(既定値は p=2)。
p ノルムは、次のように定義されます。
\[\|A\|_p = \left( \sum_{i=1}^n | a_i | ^p \right)^{1/p}\]
ここで、$a_i$ は $A$ の要素、$| a_i |$ は $a_i$ の norm、$n$ は $A$ の長さです。p ノルムは A の要素の norm を使って計算されるため、p != 2 の場合、ベクトルのベクトルの p ノルムは、一般にそれをブロックベクトルとみなす解釈とは一致しません。
p には任意の数値を指定できます(ただし、すべての値が数学的に妥当なベクトルノルムを与えるわけではありません)。特に、norm(A, Inf) は abs.(A) の最大値を返し、norm(A, -Inf) は最小値を返します。A が行列で、p=2 の場合、これはフロベニウスノルムと等価です。
第 2 引数 p は、必ずしも norm のインターフェースの一部とは限りません。つまり、カスタム型では第 2 引数なしの norm(A) だけを実装している場合があります。
行列の作用素ノルムを計算するには、opnorm を使用してください。
Examples
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)
truenorm(x::Number, p::Real=2)数値の場合は、$\left( |x|^p \right)^{1/p}$を返してください。
Examples
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.0LinearAlgebra.opnorm — Function
opnorm(A::AbstractMatrix, p::Real=2)ベクトルのpノルムによって誘導される作用素ノルム(または行列ノルム)を計算します。pに指定できる値は、1、2、Infです。(疎行列では、現在p=2は実装されていません。)フロベニウスノルムの計算にはnormを使用してください。
p=1の場合、作用素ノルムはAの列ごとの絶対値の和の最大値です。
\[\|A\|_1 = \max_{1 ≤ j ≤ n} \sum_{i=1}^m | a_{ij} |\]
ここで、$a_{ij}$は$A$の要素、$m$と$n$はその次元です。
p=2の場合、作用素ノルムはスペクトルノルムであり、Aの最大特異値に等しくなります。
p=Infの場合、作用素ノルムはAの行ごとの絶対値の和の最大値です。
\[\|A\|_\infty = \max_{1 ≤ i ≤ m} \sum _{j=1}^n | a_{ij} |\]
Examples
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.0opnorm(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ノルムとも整合します。
Examples
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.0LinearAlgebra.normalize! — Function
normalize!(a::AbstractArray, p::Real=2)配列 a をインプレースで正規化し、その p ノルムを 1 にします。つまり、norm(a, p) == 1 です。normalize と norm も参照してください。
LinearAlgebra.normalize — Function
normalize(a, p::Real=2)a を正規化し、その p-norm が 1、すなわち norm(a, p) == 1 になるようにします。スカラーの場合、これは sign(a) に似ていますが、normalize(0) は NaN になります。normalize!、norm、sign も参照してください。
Examples
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)
NaNLinearAlgebra.cond — Function
cond(M, p::Real=2)行列 M の条件数。演算子 p ノルムを使って計算します。p に指定できる値は、1、2(デフォルト)、または Inf です。
LinearAlgebra.condskeel — Function
condskeel(M, [x, p::Real=Inf])\[\kappa_S(M, p) = \left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \right\Vert_p \\ \kappa_S(M, x, p) = \frac{\left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \left\vert x \right\vert \right\Vert_p}{\left \Vert x \right \Vert_p}\]
行列 M の Skeel 条件数 $\kappa_S$。必要に応じてベクトル x に関する条件数も、作用素 p ノルムを用いて計算します。$\left\vert M \right\vert$ は、$M$ の各成分の絶対値からなる行列を表します。$\left\vert M \right\vert_{ij} = \left\vert M_{ij} \right\vert$。p に指定できる値は、1、2、Inf(デフォルト)です。
この量は、文献では Bauer 条件数、相対条件数、または成分ごとの相対条件数とも呼ばれます。
LinearAlgebra.tr — Function
tr(M)行列のトレース。Mの対角要素の和を求めます。
Examples
julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> tr(A)
5LinearAlgebra.det — Function
det(M)行列式。
Examples
julia> M = [1 0; 2 2]
2×2 Matrix{Int64}:
1 0
2 2
julia> det(M)
2.0一般に、整数行列に対しても、det は行列式の浮動小数点近似値を計算することに注意してください。通常はガウス消去法を用います。Julia には整数行列式を厳密に計算するアルゴリズム(Bareiss アルゴリズム)が含まれていますが、既定では BigInt 行列に対してのみ使用されます(行列式は固定精度の整数型ではすぐにオーバーフローするためです)。
julia> det(BigInt[1 0; 2 2]) # exact integer determinant
2LinearAlgebra.logdet — Function
logdet(M)行列式の対数。log(det(M))と等価ですが、精度が向上し、オーバーフローやアンダーフローを回避できる場合があります。
Examples
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.0LinearAlgebra.logabsdet — Function
logabsdet(M)行列式の絶対値の対数。(log(abs(det(M))), sign(det(M)))と同等ですが、精度や速度が向上する場合があります。
Examples
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 — Method
inv(M)行列の逆行列。N を計算します。M * N = I が成り立ち、I は単位行列です。左除算 N = M \ I を解くことで計算されます。
数値的な逆行列計算に M が失敗すると、SingularException がスローされます。
Examples
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)
trueLinearAlgebra.pinv — Function
pinv(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
pinv(M, rtol::Real) = pinv(M; rtol=rtol) # to be deprecated in Julia 2.0ムーア・ペンローズ擬似逆行列を計算します。
浮動小数点要素を持つ行列 M では、σ₁ を M の最大特異値として、max(atol, rtol*σ₁) より大きい特異値だけを逆数にすることで、擬似逆行列を計算できます。
絶対許容誤差(atol)と相対許容誤差(rtol)の最適な値は、M の値と擬似逆行列の用途の両方によって異なります。相対許容誤差の既定値は n*ϵ です。ここで、n は M の最小次元のサイズ、ϵ は M の要素型の eps です。
密で悪条件な方程式を最小二乗の意味で解く場合、擬似逆行列を明示的に作成するのは避けるのが望ましいです。許容誤差が小さいと数値的に不安定になる可能性があるためです。既定の M \ b アルゴリズムでは、代わりにピボット付き QR 分解(qr)を使用します。SVD ベースのアルゴリズムを使う場合は、svd(M; rtol, atol) \ b または ldiv!(svd(M), b; rtol, atol) を介して SVD を直接利用するのが望ましいです。
既存の SVD 分解を再利用するには、pinv の引数として M = svd(A) を渡すこともできます。この場合、pinv は明示的な行列ではなく、正確に適用できる擬似逆行列の SVD を返します。
詳細については、[pr1387]、[B96]、[S84]、[KY88]を参照してください。
Examples
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.0LinearAlgebra.nullspace — Function
nullspace(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
nullspace(M, rtol::Real) = nullspace(M; rtol=rtol) # to be deprecated in Julia 2.0M の零空間の基底を計算します。M の特異値の絶対値が max(atol, rtol*σ₁) より小さい特異ベクトルを含めます。ここで、σ₁ は M の最大特異値です。
デフォルトでは、相対許容誤差 rtol は n*ϵ です。ここで、n は M の最小次元のサイズ、ϵ は M の要素型の eps です。
Examples
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.0Base.kron — Function
kron(A, B)2つのベクトル、行列、または数値のクロネッカー積を計算します。
実ベクトル v と w では、クロネッカー積は外積と kron(v,w) == vec(w * transpose(v)) または w * transpose(v) == reshape(kron(v,w), (length(w), length(v))) の関係にあります。これらの式の左辺と右辺では、v と w の順序が異なることに注意してください(列優先の格納方式によるものです)。複素ベクトルの場合、外積 w * v' では、v も共役されるため、結果が異なります。
Examples
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 10Base.kron! — Function
kron!(C, A, B)A と B のクロネッカー積を計算し、その結果を C に格納します。既存の C の内容は上書きされます。これは kron のインプレース版です。
Base.exp — Method
exp(A::AbstractMatrix)A の行列指数関数を、次のように定義して計算します。
\[e^A = \sum_{n=0}^{\infty} \frac{A^n}{n!}.\]
対称またはエルミートな A には固有分解(eigen)を使用し、それ以外の場合はスケーリング・二乗法([H05] を参照)を選択します。
Examples
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.71828Base.log — Method
log(A::AbstractMatrix)A が負の実固有値を持たない場合、A の主行列対数を計算します。すなわち、$e^X = A$ を満たし、かつ $X$ のすべての固有値 $\lambda$ に対して $-\pi < Im(\lambda) < \pi$ を満たす一意な行列 $X$ を求めます。A が非正の固有値を持つ場合は、可能であれば主値ではない行列関数を返します。
A が対称行列またはエルミート行列の場合は、固有値分解(eigen)を使用します。A が三角行列の場合は、逆スケーリング・二乗法の改良版を使用します([AH12] および [AHR13] を参照)。A が実行列で、負の固有値を持たない場合は、実 Schur 形を計算します。それ以外の場合は、複素 Schur 形を計算します。その後、上(準)三角因子に対して、[AHR13] の上(準)三角行列用アルゴリズムを適用します。
Examples
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.0Base.sqrt — Method
sqrt(A::AbstractMatrix)A に負の実固有値がない場合は、A の主行列平方根を計算します。これは、固有値の実部が正である唯一の行列 $X$ であり、$X^2 = A$ を満たします。それ以外の場合は、非主平方根が返されます。
A が実対称またはエルミート行列の場合は、その固有分解(eigen)を使って平方根を計算します。このような行列では、丸め誤差によってわずかに負になったように見える固有値は、ゼロとして扱われます。より正確には、すべての固有値が ≥ -rtol*(max |λ|) である行列は半正定値として扱われ(エルミート平方根が得られます)、負の固有値はゼロとみなされます。rtol は sqrt のキーワード引数(エルミート/実対称の場合のみ)で、既定値は size(A,1) でスケーリングした機械精度です。
それ以外の場合、平方根は Björck-Hammarling 法 [BH83] によって求めます。この方法では、複素シュール形式(schur)を計算し、続いて三角因子の複素平方根を求めます。実平方根が存在する場合は、この方法を拡張した手法 [H87] を用います。この手法では、実シュール形式を計算した後、準三角因子の実平方根を求めます。
Examples
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.0Base.Math.cbrt — Method
cbrt(A::AbstractMatrix{<:Real})実数値行列 A の実数値立方根を計算します。T = cbrt(A) の場合、T*T*T ≈ A となります。以下の例を参照してください。
A が実対称またはエルミート行列の場合は、その固有値分解(eigen)を用いて立方根を求めます。それ以外の場合は、p 乗根アルゴリズム [S03] の専用版を使用します。このアルゴリズムは実数値シュール分解(schur)を利用して立方根を計算します。
Examples
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
trueBase.Math.sincos — Method
sincos(A::AbstractMatrix)正方行列 A の行列正弦と行列余弦を計算します。
Examples
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.291927Base.Math.sec — Method
sec(A::AbstractMatrix)正方行列 A の行列正割を計算します。
Base.Math.csc — Method
csc(A::AbstractMatrix)正方行列 A の行列余割を計算します。
Base.Math.cot — Method
cot(A::AbstractMatrix)正方行列 A の行列コタンジェントを計算します。
Base.Math.sech — Method
sech(A::AbstractMatrix)正方行列 A の行列双曲線正割を計算します。
Base.Math.csch — Method
csch(A::AbstractMatrix)正方行列 A の行列双曲線余割を計算します。
Base.Math.coth — Method
coth(A::AbstractMatrix)正方行列 A の行列双曲線余接を計算します。
Base.acos — Method
acos(A::AbstractMatrix)正方行列 A の逆余弦を計算します。
A が実対称行列またはエルミート行列の場合、逆余弦の計算にはその固有値分解(eigen)を使用します。それ以外の場合は、log と sqrt を使用して逆余弦を求めます。この関数の計算に用いる理論と対数公式については、[AH16_1] を参照してください。
Examples
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-16imBase.asin — Method
asin(A::AbstractMatrix)正方行列 A の逆正弦を計算します。
A が実対称行列またはエルミート行列の場合は、その固有値分解(eigen)を使って逆正弦を計算します。それ以外の場合は、log と sqrt を使って逆正弦を求めます。この関数の計算に用いる理論と対数公式については、[AH16_2] を参照してください。
Examples
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-16imBase.Math.asec — Method
asec(A::AbstractMatrix)A の逆行列の正割を計算します。
Base.Math.acsc — Method
acsc(A::AbstractMatrix)A の逆行列コセカントを計算します。
Base.Math.acot — Method
acot(A::AbstractMatrix)A の逆行列の余接を計算します。
Base.acosh — Method
acosh(A::AbstractMatrix)正方行列 A の逆双曲線行列余弦を計算します。この関数の計算に用いる理論と対数公式については、[AH16_4] を参照してください。
Base.asinh — Method
asinh(A::AbstractMatrix)正方行列 A の逆双曲線正弦を計算します。この関数の計算に用いる理論と対数公式については、[AH16_5] を参照してください。
Base.atanh — Method
atanh(A::AbstractMatrix)正方行列 A の逆双曲線正接を計算します。この関数の計算に用いる理論と対数公式については、[AH16_6] を参照してください。
Base.Math.asech — Method
asech(A::AbstractMatrix)A の逆双曲線正割を計算します。
Base.Math.acsch — Method
acsch(A::AbstractMatrix)A の逆行列双曲線余割を計算します。
Base.Math.acoth — Method
acoth(A::AbstractMatrix)A の逆双曲線余接を計算します。
LinearAlgebra.lyap — Function
lyap(A, C)連続リャプノフ方程式 AX + XA' + C = 0 の解 X を計算します。ただし、A の固有値に実部が 0 のものがなく、負の複素共役となる固有値の組も存在しないものとします。
Examples
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
trueLinearAlgebra.sylvester — Function
sylvester(A, B, C)シルベスター方程式 AX + XB + C = 0 の解 X を計算します。ここで、A、B、C は次元が適合しており、A と -B は実部が等しい固有値を持ちません。
Examples
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
trueLinearAlgebra.issuccess — Function
issuccess(F::Factorization)行列の因子分解が成功したことを確認します。
Examples
julia> F = cholesky([1 0; 0 1]);
julia> issuccess(F)
trueissuccess(F::LU; allowsingular = false)行列の LU 分解が成功したかどうかをテストします。デフォルトでは、有効ではあるものの階数落ちした U 因子を生成する分解は失敗とみなされます。これは allowsingular = true を渡すことで変更できます。
Examples
julia> F = lu([1 2; 1 2], check = false);
julia> issuccess(F)
false
julia> issuccess(F, allowsingular = true)
trueLinearAlgebra.issymmetric — Function
issymmetric(A) -> Bool行列または数値が対称かどうかを判定します。
Examples
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)
falseLinearAlgebra.isposdef — Function
isposdef(A) -> BoolAのコレスキー分解を試みて、行列が正定値(かつエルミート)かどうかを判定します。
Examples
julia> A = [1 2; 2 50]
2×2 Matrix{Int64}:
1 2
2 50
julia> isposdef(A)
trueLinearAlgebra.isposdef! — Function
isposdef!(A) -> BoolA のコレスキー分解を試みることで、行列が正定値(かつエルミート)かどうかを判定します。その際、A は上書きされます。isposdef も参照してください。
Examples
julia> A = [1. 2.; 2. 50.];
julia> isposdef!(A)
true
julia> A
2×2 Matrix{Float64}:
1.0 2.0
2.0 6.78233LinearAlgebra.istril — Function
istril(A::AbstractMatrix, k::Integer = 0) -> BoolAが、k番目の上対角線から下三角行列になっているかを判定します。
Examples
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)
trueLinearAlgebra.istriu — Function
istriu(A::AbstractMatrix, k::Integer = 0) -> BoolAがk次の上対角線から上三角行列になっているかを判定します。
Examples
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)
trueLinearAlgebra.isdiag — Function
isdiag(A) -> Bool行列が対角行列であるかどうかを判定します。iszero(A[i,j]) が真となるのは、i == j の場合を除きます。A は正方行列である必要はありません。正方行列かどうかも確認したい場合は、size(A, 1) == size(A, 2) を確認してください。
Examples
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)
falseLinearAlgebra.ishermitian — Function
ishermitian(A) -> Bool行列がエルミート行列かどうかを判定します。
Examples
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)
trueBase.transpose — Function
transpose(A)遅延転置です。返されたオブジェクトを変更すると、Aも適切に変更されます。多くの場合、Transpose(A)が返されますが、常にそうとは限りません。この場合、Transposeは遅延転置ラッパーです。この操作は再帰的に行われることに注意してください。
この操作は線形代数での使用を想定しています。一般的なデータ操作には、再帰的ではないpermutedimsを使用してください。
Examples
julia> A = [3 2; 0 0]
2×2 Matrix{Int64}:
3 2
0 0
julia> B = transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
3 0
2 0
julia> B isa Transpose
true
julia> transpose(B) === A # the transpose of a transpose unwraps the parent
true
julia> Transpose(B) # however, the constructor always wraps its argument
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
3 2
0 0
julia> B[1,2] = 4; # modifying B will modify A automatically
julia> A
2×2 Matrix{Int64}:
3 2
4 0複素行列の場合、adjoint操作は共役転置と同等です。
julia> A = reshape([Complex(x, x) for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
1+1im 3+3im
2+2im 4+4im
julia> adjoint(A) == conj(transpose(A))
trueAbstractVectorのtransposeは行ベクトルです。
julia> v = [1,2,3]
3-element Vector{Int64}:
1
2
3
julia> transpose(v) # returns a row-vector
1×3 transpose(::Vector{Int64}) with eltype Int64:
1 2 3
julia> transpose(v) * v # compute the dot product
14行列の行列の場合、各ブロックに対して再帰的に操作が行われます。
julia> C = [1 3; 2 4]
2×2 Matrix{Int64}:
1 3
2 4
julia> D = reshape([C, 2C, 3C, 4C], 2, 2) # construct a block matrix
2×2 Matrix{Matrix{Int64}}:
[1 3; 2 4] [3 9; 6 12]
[2 6; 4 8] [4 12; 8 16]
julia> transpose(D) # blocks are recursively transposed
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
[1 2; 3 4] [2 4; 6 8]
[3 6; 9 12] [4 8; 12 16]transpose(F::Factorization)因子分解 F の遅延転置です。デフォルトでは TransposeFactorization を返します。ただし、実数の eltype を持つ Factorization の場合は、AdjointFactorization を返します。
LinearAlgebra.transpose! — Function
transpose!(dest,src)配列 src を転置し、事前に確保した配列 dest に結果を格納します。この配列のサイズは (size(src,2),size(src,1)) に対応している必要があります。インプレース転置はサポートされていません。また、src と dest のメモリ領域が重なっていると、予期しない結果が生じます。
Examples
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+6imtranspose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}行列 A を転置し、行列 X に格納します。size(X) は size(transpose(A)) と等しくなければなりません。必要に応じて X の rowval と nzval のサイズを変更する以外に、追加のメモリは割り当てられません。
halfperm! を参照してください。
LinearAlgebra.Transpose — Type
Transpose元の線形代数オブジェクト(通常は AbstractVector/AbstractMatrix)の転置ビューを表す遅延ラッパー型です。通常、Transpose コンストラクターを直接呼び出すべきではありません。代わりに transpose を使用してください。ビューを実体化するには copy を使用します。
この型は線形代数での使用を想定しています。一般的なデータ操作については permutedims を参照してください。
Examples
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 0LinearAlgebra.TransposeFactorization — Type
TransposeFactorization基になるFactorizationオブジェクトの転置を表す遅延ラッパー型です。通常、TransposeFactorizationコンストラクターを直接呼び出すべきではありません。代わりにtranspose(:: Factorization)を使用してください。
Base.adjoint — Function
A'
adjoint(A)遅延随伴(共役転置)。adjoint は要素に対して再帰的に適用されます。
数値型の場合、adjoint は複素共役を返すため、実数では恒等関数と同じです。
この演算は線形代数での使用を想定しています。一般的なデータ操作については permutedims を参照してください。
Examples
julia> A = [3+2im 9+2im; 0 0]
2×2 Matrix{Complex{Int64}}:
3+2im 9+2im
0+0im 0+0im
julia> B = A' # equivalently adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
3-2im 0+0im
9-2im 0+0im
julia> B isa Adjoint
true
julia> adjoint(B) === A # the adjoint of an adjoint unwraps the parent
true
julia> Adjoint(B) # however, the constructor always wraps its argument
2×2 adjoint(adjoint(::Matrix{Complex{Int64}})) with eltype Complex{Int64}:
3+2im 9+2im
0+0im 0+0im
julia> B[1,2] = 4 + 5im; # modifying B will modify A automatically
julia> A
2×2 Matrix{Complex{Int64}}:
3+2im 9+2im
4-5im 0+0im実行列の場合、adjoint 演算は transpose と同じです。
julia> A = reshape([x for x in 1:4], 2, 2)
2×2 Matrix{Int64}:
1 3
2 4
julia> A'
2×2 adjoint(::Matrix{Int64}) with eltype Int64:
1 2
3 4
julia> adjoint(A) == transpose(A)
trueAbstractVector の随伴は行ベクトルです。
julia> x = [3, 4im]
2-element Vector{Complex{Int64}}:
3 + 0im
0 + 4im
julia> x'
1×2 adjoint(::Vector{Complex{Int64}}) with eltype Complex{Int64}:
3+0im 0-4im
julia> x'x # compute the dot product, equivalently x' * x
25 + 0im行列の行列の場合、各ブロックに対して再帰的に演算が適用されます。
julia> A = reshape([x + im*x for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
1+1im 3+3im
2+2im 4+4im
julia> C = reshape([A, 2A, 3A, 4A], 2, 2)
2×2 Matrix{Matrix{Complex{Int64}}}:
[1+1im 3+3im; 2+2im 4+4im] [3+3im 9+9im; 6+6im 12+12im]
[2+2im 6+6im; 4+4im 8+8im] [4+4im 12+12im; 8+8im 16+16im]
julia> C'
2×2 adjoint(::Matrix{Matrix{Complex{Int64}}}) with eltype Adjoint{Complex{Int64}, Matrix{Complex{Int64}}}:
[1-1im 2-2im; 3-3im 4-4im] [2-2im 4-4im; 6-6im 8-8im]
[3-3im 6-6im; 9-9im 12-12im] [4-4im 8-8im; 12-12im 16-16im]adjoint(F::Factorization)因子分解 F の遅延随伴。デフォルトでは、AdjointFactorization ラッパーを返します。
LinearAlgebra.adjoint! — Function
adjoint!(dest,src)配列 src の共役転置を行い、その結果を事前に確保した配列 dest に格納します。この配列のサイズは (size(src,2),size(src,1)) に対応している必要があります。インプレース転置はサポートされていません。src と dest のメモリ領域が重複している場合、予期しない結果が生じます。
Examples
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+6imadjoint!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}行列 A を転置し、行列 X の要素の随伴を格納します。size(X) は size(transpose(A)) と等しくなければなりません。必要に応じて X の rowval と nzval のサイズを変更する以外に、追加のメモリは割り当てられません。
halfperm! を参照してください。
LinearAlgebra.Adjoint — Type
Adjoint元の線形代数オブジェクト(通常は AbstractVector/AbstractMatrix)の随伴ビューを表す遅延ラッパー型です。通常、Adjoint コンストラクターを直接呼び出すべきではありません。代わりに adjoint を使用してください。ビューを実体化するには copy を使用します。
この型は線形代数での使用を想定しています。一般的なデータ操作については permutedims を参照してください。
Examples
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+0imLinearAlgebra.AdjointFactorization — Type
AdjointFactorization基になるFactorizationオブジェクトの随伴を表す遅延ラッパー型です。通常、AdjointFactorizationコンストラクターを直接呼び出すべきではありません。代わりにadjoint(:: Factorization)を使用してください。
Base.copy — Method
copy(A::Transpose)
copy(A::Adjoint)遅延評価される行列の転置/随伴を即時評価します。転置は要素にも再帰的に適用されることに注意してください。
この操作は線形代数での使用を想定しています。一般的なデータ操作には、再帰的ではないpermutedimsを参照してください。
Examples
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+0imLinearAlgebra.stride1 — Function
stride1(A) -> Int次元 1 における隣接する配列要素間の距離を、要素サイズを単位として返します。
Examples
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)
2LinearAlgebra.checksquare — Function
LinearAlgebra.checksquare(A)行列が正方行列であることを確認し、その共通の次元を返します。引数が複数の場合は、ベクトルを返します。
Examples
julia> A = fill(1, (4,4)); B = fill(1, (5,5));
julia> LinearAlgebra.checksquare(A, B)
2-element Vector{Int64}:
4
5LinearAlgebra.peakflops — Function
LinearAlgebra.peakflops(n::Integer=4096; eltype::DataType=Float64, ntrials::Integer=3, parallel::Bool=false)peakflopsは、倍精度のgemm!を使って、コンピューターのピークFLOPレートを計算します。引数を指定しない場合、デフォルトではサイズがn x nのFloat64行列を2つ乗算します。このとき、n = 4096です。基盤となるBLASが複数のスレッドを使用している場合、より高いFLOPレートが得られます。BLASのスレッド数はBLAS.set_num_threads(n)で設定できます。
キーワード引数eltypeを指定すると、peakflopsはピークFLOPレートの計算に、要素の型がeltypeである行列を生成します。
デフォルトでは、peakflopsは3回の試行のうち最も良い計測時間を使用します。キーワード引数ntrialsを指定すると、peakflopsはその回数だけ試行し、最も良い計測時間を採用します。
キーワード引数parallelをtrueに設定すると、peakflopsはすべてのワーカープロセッサー上で並列に実行されます。並列コンピューター全体のFLOPレートが返されます。並列実行時に使用されるBLASスレッドは1つだけです。引数nは、各プロセッサーで解く問題のサイズを表します。
LinearAlgebra.hermitianpart — Function
hermitianpart(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian正方行列 A のエルミート部分を、(A + A') / 2 として定義し、Hermitian 行列として返します。実行列 A の場合、これは A の対称部分とも呼ばれます。また、「作用素の実部」と呼ばれることもあります。省略可能な引数 uplo は、Hermitian ビューの対応する引数を制御します。実行列の場合、後者は Symmetric ビューと同等です。
対応するインプレース操作については、hermitianpart! も参照してください。
LinearAlgebra.hermitianpart! — Function
hermitianpart!(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian正方行列 A を、そのエルミート部分 (A + A') / 2 でインプレースに上書きし、Hermitian(A, uplo) を返します。実行列 A の場合、これは A の対称部分とも呼ばれます。
対応する非インプレース操作については、hermitianpart を参照してください。
LinearAlgebra.copy_adjoint! — Function
copy_adjoint!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B行列 A の要素を、次のように隣接させて B に効率よくコピーします。
B[ir_dest, jr_dest] = adjoint(A)[jr_src, ir_src]要素 B[ir_dest, jr_dest] は上書きされます。また、インデックス範囲のパラメーターは length(ir_dest) == length(jr_src) および length(jr_dest) == length(ir_src) を満たす必要があります。
LinearAlgebra.copy_transpose! — Function
copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B行列 A の要素を転置しながら B に効率よくコピーするには、次のようにします。
B[ir_dest, jr_dest] = transpose(A)[jr_src, ir_src]B[ir_dest, jr_dest] の要素は上書きされます。また、インデックス範囲のパラメーターは length(ir_dest) == length(jr_src) および length(jr_dest) == length(ir_src) を満たす必要があります。
copy_transpose!(B::AbstractMatrix, ir_dest::AbstractUnitRange, jr_dest::AbstractUnitRange,
tM::AbstractChar,
M::AbstractVecOrMat, ir_src::AbstractUnitRange, jr_src::AbstractUnitRange) -> B文字パラメーター tM に応じて、行列 M の要素を 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! も参照してください。
LinearAlgebra.uplo — Function
LinearAlgebra.uplo(S::Union{Symmetric, Hermitian})::Symbol行列 S の格納された三角部分(:U または :L)に対応する Symbol を返します。つまり、その三角部分について、S と parent(S) の両方に共通する要素です。
Example
julia> S = Symmetric([1 2; 3 4], :U)
2×2 Symmetric{Int64, Matrix{Int64}}:
1 2
2 4
julia> LinearAlgebra.uplo(S)
:U
julia> H = Hermitian([1 2; 3 4], :L)
2×2 Hermitian{Int64, Matrix{Int64}}:
1 3
3 4
julia> LinearAlgebra.uplo(H)
:LLinearAlgebra.uplo(S::Bidiagonal)::Symbol上側(:U)または下側(:L)のどちらの非対角帯が格納されているかに応じて、Symbolを返します。
Low-level matrix operations
多くの場合、行列演算には、事前に確保した出力ベクトルや行列を渡せるインプレース版があります。これは、重要なコードを最適化する際に、繰り返しのメモリ確保によるオーバーヘッドを避けるのに役立ちます。こうしたインプレース演算には、Julia の一般的な規約に従い、以下のように名前の末尾に ! が付きます(例:mul!)。
LinearAlgebra.mul! — Function
mul!(Y, A, B) -> Y行列と行列、または行列とベクトルの積 $A B$ を計算し、その結果を Y に格納します。既存の Y の値は上書きされます。Y は、A または B とエイリアスになっていてはならない点に注意してください。
Examples
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
trueImplementation
独自の行列型やベクトル型では、可能であれば3引数の mul! を直接実装するのではなく、5引数の mul! を実装することを推奨します。
mul!(C, A, B, α, β) -> C行列と行列、または行列とベクトルの積和演算をインプレースで行います $A B α + C β$。結果は C に上書きして格納されます。C は A または B とエイリアスになっていてはならない点に注意してください。
Examples
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]; # A copy of the original value of C
julia> C == A * B * α + C_original * β
truemul!(c::AbstractVector, tA, A::AbstractVecOrMat, b::AbstractVector, α::Number, β::Number)行列とベクトルの積和演算 $A b α + c β$ (tA == 'N')、$A^⊤ b α + c β$ (tA == 'T')、または $A' b α + c β$ (tA == 'C') を計算します。結果は c に上書きして格納されます。c は A または b とエイリアスしてはならないことに注意してください。
これは、ストレージ型に応じたディスパッチに使用される、5引数の mul! より下位の抽象化レイヤーです。独自のストレージ型を提供するパッケージでは、5引数の mul! ではなく、このメソッドシグネチャをオーバーロードすることを推奨します。
mul!(C::AbstractVecOrMat, tA, tB, A::AbstractVecOrMat, B::AbstractVecOrMat, α::Number, β::Number)行列の転置を行う場合は B を tB に対応させ、結合された行列積和演算 $A B α + C β$ (tA == 'N')、$A^⊤ B α + C β$ (tA == 'T')、または $A' B α + C β$ (tA == 'C') を計算します。結果は C に上書き保存されます。C は、A または B とエイリアスになってはならないことに注意してください。
これは、5 引数の mul! より下位の抽象化レイヤーです。独自のストレージ型を提供するパッケージでは、5 引数の mul! ではなく、このメソッドをオーバーロードすることを推奨します。
LinearAlgebra.lmul! — Function
lmul!(a::Number, B::AbstractArray)配列 B をスカラー a でスケーリングし、B をインプレースで上書きします。スカラーを右から乗算するには rmul! を使用します。このスケーリング操作は、a と B の要素との乗算 * のセマンティクスに従います。特に、NaN や ±Inf などの非有限数を含む乗算にも適用されます。
Examples
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}:
NaNlmul!(A, B)行列積 $AB$ を計算し、B に上書きして、結果を返します。ここで、A は、たとえば Diagonal、UpperTriangular、LowerTriangular のような特殊な行列型、または直交型である必要があります。詳しくは QR を参照してください。
Examples
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.0LinearAlgebra.rmul! — Function
rmul!(A::AbstractArray, b::Number)配列 A の各要素にスカラー b を乗算し、A をインプレースで上書きします。スカラーを左から乗算するには lmul! を使用します。このスケーリング操作は、A の要素と b の間の乗算 * のセマンティクスに従います。特に、NaN や ±Inf などの非有限数を含む乗算にも適用されます。
Examples
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}:
NaNrmul!(A, B)行列積 $AB$ を計算し、A に上書きして、結果を返します。ここで、B は、たとえば Diagonal、UpperTriangular、LowerTriangular のような特殊な行列型、または直交型である必要があります。詳しくは QR を参照してください。
Examples
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.0LinearAlgebra.ldiv! — Function
ldiv!(Y, A, B) -> YA \ Bをインプレースで計算し、その結果をYに格納して返します。
引数Aには、行列を指定しないでください。行列ではなく、factorizeやcholeskyなどで生成した因子分解オブジェクトを指定してください。因子分解自体はコストが高く、通常はメモリを割り当てるためです(lu!などを使ってインプレースで行うこともできます)。また、ldiv!が必要となるパフォーマンス重視の状況では、通常、Aの因子分解を細かく制御する必要もあります。
Examples
julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];
julia> B = [1, 2.5, 3];
julia> Y = similar(B); # use similar since there is no need to read from it
julia> ldiv!(Y, qr(A), B); # you may also try qr!(A) to further reduce allocation
julia> Y ≈ A \ B
trueldiv!(A, B)A \ B をインプレースで計算し、B を上書きして結果を格納します。
引数 A は行列ではなく、因子分解オブジェクト(たとえば factorize または cholesky で生成されるもの)である必要があります。因子分解自体はコストが高く、通常はメモリを割り当てるためです(ただし、たとえば lu! を使ってインプレースで行うこともできます)。また、ldiv! が必要となるようなパフォーマンス重視の状況では、通常、A の因子分解を細かく制御する必要もあります。
Examples
julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];
julia> B = [1, 2.5, 3];
julia> B0 = copy(B); # a backup copy to facilitate testing
julia> ldiv!(lu(A), B); # you may also try lu!(A) to further reduce allocation
julia> B ≈ A \ B0
trueldiv!(a::Number, B::AbstractArray)配列 B の各要素をスカラー a で除算し、B をインプレースで上書きします。スカラーを右から除算するには、rdiv! を使用します。
Examples
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.0ldiv!(A::Tridiagonal, B::AbstractVecOrMat) -> BA \ Bを部分ピボット選択付きガウス消去法でインプレースに計算し、結果をBに格納して返します。この処理では、Aの対角成分も上書きされます。
ldiv!(F::SVD, B; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)行列 $m \times n$ の SVD F が与えられたとき、B の先頭 $m$ 行にムーア・ペンローズ擬似逆行列をその場で乗算し、結果を B の先頭 $n$ 行に格納して、B を返します。これは、($m \ge n$ の場合の)最小二乗解、または($m \le n$ の場合の)最小ノルム解に相当します。
pinv 関数と同様に、特異値分解を打ち切り、max(atol, rtol*σ₁) 未満の特異値を除外することで、解を正則化できます。ここで、σ₁ は最大特異値です。デフォルトの相対許容誤差は n*ϵ です。ここで、n は M の最小次元のサイズ、ϵ は M の要素型の eps です。
LinearAlgebra.rdiv! — Function
rdiv!(A, B)A / Bをインプレースで計算し、Aを上書きして結果を格納します。
引数Bには、行列を指定しないでください。行列ではなく、factorizeやcholeskyなどで生成される因子分解オブジェクトを指定します。因子分解自体はコストが高く、通常はメモリを割り当てるためです(lu!などを使ってインプレースで行うこともできます)。また、rdiv!が必要となるパフォーマンス重視の状況では、通常、Bの因子分解を細かく制御する必要もあります。
rdiv!(A::AbstractArray, b::Number)配列 A の各要素をスカラー b で除算し、A をインプレースで上書きします。スカラーを左から除算するには ldiv! を使用します。
Examples
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.0BLAS functions
Julia では(科学技術計算の多くと同様に)、密線形代数演算は 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 | 意味 |
|---|---|
'L' | 行列と行列の演算で、引数を左側に置きます。 |
'R' | 行列と行列の演算で、引数を右側に置きます。 |
Triangle referencing
uplo/ul | 意味 |
|---|---|
'U' | 行列の上三角部分のみを使用します。 |
'L' | 行列の下三角部分のみを使用します。 |
Transposition operation
trans/tX | 意味 |
|---|---|
'N' | 入力行列 X は転置も共役もされません。 |
'T' | 入力行列 X を転置します。 |
'C' | 入力行列 X を共役転置します。 |
Unit diagonal
diag/dX | 意味 |
|---|---|
'N' | 行列 X の対角成分を読み取ります。 |
'U' | 行列 X の対角成分はすべて 1 とみなします。 |
LinearAlgebra.BLAS — Module
BLAS サブルーチンへのインターフェース。
LinearAlgebra.BLAS.set_num_threads — Function
set_num_threads(n::Integer)
set_num_threads(::Nothing)BLASライブラリが使用するスレッド数をn::Integerに設定します。
nothingも指定できます。この場合、juliaはデフォルトのスレッド数を推測しようとします。nothingを渡すことは推奨されません。主に歴史的な理由で残されています。
Apple Accelerateなど、一部のBLASライブラリは、使用するスレッド数を固定するよう設定できません。これらのバックエンドでは、set_num_threads()は何も行いません。get_num_threadsも参照してください。
LinearAlgebra.BLAS.get_num_threads — Function
get_num_threads()BLASライブラリが使用しているスレッド数を取得します。
Apple Accelerateなど、一部のBLASライブラリでは、使用するスレッド数を固定できません。これらのバックエンドでは、get_num_threads()は常に1を返します。set_num_threadsも参照してください。
BLAS 関数は、最初に提案された時期、入力パラメーターの型、演算の複雑さに応じて、3 つのグループ(レベルとも呼ばれます)に分類できます。
Level 1 BLAS functions
レベル 1 BLAS 関数は(Lawson, 1979)で最初に提案され、スカラーとベクトルの間の演算を定義します。
LinearAlgebra.BLAS.rot! — Function
rot!(n, X, incx, Y, incy, c, s)配列 X の先頭 n 個の要素(ストライド incx)と、配列 Y の先頭 n 個の要素(ストライド incy)について、X を c*X + s*Y で、Y を -conj(s)*X + c*Y で上書きします。X と Y を返します。
LinearAlgebra.BLAS.scal! — Function
scal!(n, a, X, incx)
scal!(a, X)配列 X の先頭 n 個の要素を、ストライド incx で X から a*X に上書きします。X を返します。
n と incx が指定されていない場合は、length(X) と stride(X,1) が使用されます。
LinearAlgebra.BLAS.scal — Function
scal(n, a, X, incx)
scal(a, X)配列 X の先頭 n 個の要素を、ストライド incx で a 倍し、X を返します。
n と incx が指定されていない場合は、length(X) と stride(X,1) が使用されます。
LinearAlgebra.BLAS.blascopy! — Function
blascopy!(n, X, incx, Y, incy)配列 X の要素を incx 個おきに n 個コピーし、配列 Y に incy 個おきに格納します。Y を返します。
LinearAlgebra.BLAS.dot — Function
dot(n, X, incx, Y, incy)ストライドがそれぞれincxおよびincyである配列Xのn個の要素と、配列Yのn個の要素からなる2つのベクトルの内積。
Examples
julia> BLAS.dot(10, fill(1.0, 10), 1, fill(1.0, 20), 2)
10.0LinearAlgebra.BLAS.dotu — Function
dotu(n, X, incx, Y, incy)ストライドが incx の配列 X の要素 n 個と、ストライドが incy の配列 Y の要素 n 個からなる、2つの複素ベクトルの内積。
Examples
julia> BLAS.dotu(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
-10.0 + 10.0imLinearAlgebra.BLAS.dotc — Function
dotc(n, X, incx, U, incy)2つの複素ベクトルの内積を計算します。1つ目のベクトルは、配列 X の要素 n 個をストライド incx で取り、2つ目のベクトルは、配列 U の要素 n 個をストライド incy で取ります。1つ目のベクトルは複素共役を取ります。
Examples
julia> BLAS.dotc(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
10.0 - 10.0imLinearAlgebra.BLAS.nrm2 — Function
nrm2(n, X, incx)ストライドが incx の配列 X の要素 n 個からなるベクトルの 2 ノルム。
Examples
julia> BLAS.nrm2(4, fill(1.0, 8), 2)
2.0
julia> BLAS.nrm2(1, fill(1.0, 8), 2)
1.0LinearAlgebra.BLAS.asum — Function
asum(n, X, incx)ストライドが incx の配列 X の先頭 n 要素について、各要素の大きさの合計。
実数配列の場合、大きさは絶対値です。複素数配列の場合、大きさは実部の絶対値と虚部の絶対値の和です。
Examples
julia> BLAS.asum(5, fill(1.0im, 10), 2)
5.0
julia> BLAS.asum(2, fill(1.0im, 10), 5)
2.0LinearAlgebra.BLAS.iamax — Function
iamax(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)で公開され、行列とベクトルの演算を定義します。
ベクトルを返す
LinearAlgebra.BLAS.gemv! — Function
gemv!(tA, alpha, A, x, beta, y)y ベクトルを、tA に従って alpha*A*x + beta*y または alpha*A'x + beta*y に更新します。alpha と beta はスカラーです。更新後の y を返します。
LinearAlgebra.BLAS.gemv — Method
gemv(tA, alpha, A, x)tAに応じて、alpha*A*xまたはalpha*A'xを返します。alphaはスカラーです。
LinearAlgebra.BLAS.gemv — Method
gemv(tA, A, x)tAに従って、A*xまたはA'xを返してください。
LinearAlgebra.BLAS.gbmv! — Function
gbmv!(trans, m, kl, ku, alpha, A, x, beta, y)transに従って、ベクトルyをalpha*A*x + beta*yまたはalpha*A'*x + beta*yとして更新します。行列Aは、kl本の下対角線とku本の上対角線を持つ、m行size(A,2)列の一般帯行列です。alphaとbetaはスカラーです。更新後のyを返します。
LinearAlgebra.BLAS.gbmv — Function
gbmv(trans, m, kl, ku, alpha, A, x)transに応じて、alpha*A*xまたはalpha*A'*xを返します。行列Aは、m行size(A,2)列で、kl本の下対角線とku本の上対角線を持つ一般帯行列であり、alphaはスカラーです。
LinearAlgebra.BLAS.hemv! — Function
hemv!(ul, alpha, A, x, beta, y)ベクトル y を alpha*A*x + beta*y に更新します。A はエルミート行列であると仮定します。A の ul 三角部分のみを使用します。alpha と beta はスカラーです。更新後の y を返します。
LinearAlgebra.BLAS.hemv — Method
hemv(ul, alpha, A, x)alpha*A*xを返します。Aはエルミート行列であると仮定します。Aのul三角部分のみを使用します。alphaはスカラーです。
LinearAlgebra.BLAS.hemv — Method
hemv(ul, A, x)A*xを返します。Aはエルミート行列であると仮定されます。Aのうち、ul側の三角部分のみが使用されます。
LinearAlgebra.BLAS.hpmv! — Function
hpmv!(uplo, α, AP, x, β, y)A がパック形式 AP で与えられたエルミート行列の場合、ベクトル y を α*A*x + β*y として更新します。
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! — Function
symv!(ul, alpha, A, x, beta, y)ベクトル y を alpha*A*x + beta*y として更新します。A は対称であると仮定します。A の ul 三角部分のみを使用します。alpha と beta はスカラーです。更新後の y を返します。
LinearAlgebra.BLAS.symv — Method
symv(ul, alpha, A, x)alpha*A*xを返します。Aは対称であると仮定します。Aのうち、ulの三角部分のみを使用します。alphaはスカラーです。
LinearAlgebra.BLAS.symv — Method
symv(ul, A, x)A*xを返します。Aは対称であると仮定されます。ulの三角部分のみがAで使用されます。
LinearAlgebra.BLAS.sbmv! — Function
sbmv!(uplo, k, alpha, A, x, beta, y)引数 A に格納された、次数 size(A,2)、k 本の上対角線を持つ対称帯行列 A を用いて、ベクトル y を alpha*A*x + beta*y に更新します。A の格納形式については、'h': ASCII/Unicode U+0068 (category Ll: Letter, lowercase)'t': ASCII/Unicode U+0074 (category Ll: Letter, lowercase)'t': ASCII/Unicode U+0074 (category Ll: Letter, lowercase)'p': ASCII/Unicode U+0070 (category Ll: Letter, lowercase)'s': ASCII/Unicode U+0073 (category Ll: Letter, lowercase)':': ASCII/Unicode U+003A (category Po: Punctuation, other)'/': ASCII/Unicode U+002F (category Po: Punctuation, other)'/': ASCII/Unicode U+002F (category Po: Punctuation, other)'w': ASCII/Unicode U+0077 (category Ll: Letter, lowercase)'w': ASCII/Unicode U+0077 (category Ll: Letter, lowercase)'w': ASCII/Unicode U+0077 (category Ll: Letter, lowercase)'.': ASCII/Unicode U+002E (category Po: Punctuation, other)'n': ASCII/Unicode U+006E (category Ll: Letter, lowercase)'e': ASCII/Unicode U+0065 (category Ll: Letter, lowercase)'t': ASCII/Unicode U+0074 (category Ll: Letter, lowercase)'l': ASCII/Unicode U+006C (category Ll: Letter, lowercase)'i': ASCII/Unicode U+0069 (category Ll: Letter, lowercase)'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)'.': ASCII/Unicode U+002E (category Po: Punctuation, other)'o': ASCII/Unicode U+006F (category Ll: Letter, lowercase)'r': ASCII/Unicode U+0072 (category Ll: Letter, lowercase)'g': ASCII/Unicode U+0067 (category Ll: Letter, lowercase)'/': ASCII/Unicode U+002F (category Po: Punctuation, other)'l': ASCII/Unicode U+006C (category Ll: Letter, lowercase)'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)'p': ASCII/Unicode U+0070 (category Ll: Letter, lowercase)'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)'k': ASCII/Unicode U+006B (category Ll: Letter, lowercase)'/': ASCII/Unicode U+002F (category Po: Punctuation, other)'e': ASCII/Unicode U+0065 (category Ll: Letter, lowercase)'x': ASCII/Unicode U+0078 (category Ll: Letter, lowercase)'p': ASCII/Unicode U+0070 (category Ll: Letter, lowercase)'l': ASCII/Unicode U+006C (category Ll: Letter, lowercase)'o': ASCII/Unicode U+006F (category Ll: Letter, lowercase)'r': ASCII/Unicode U+0072 (category Ll: Letter, lowercase)'e': ASCII/Unicode U+0065 (category Ll: Letter, lowercase)'-': ASCII/Unicode U+002D (category Pd: Punctuation, dash)'h': ASCII/Unicode U+0068 (category Ll: Letter, lowercase)'t': ASCII/Unicode U+0074 (category Ll: Letter, lowercase)'m': ASCII/Unicode U+006D (category Ll: Letter, lowercase)'l': ASCII/Unicode U+006C (category Ll: Letter, lowercase)'/': ASCII/Unicode U+002F (category Po: Punctuation, other) のリファレンス BLAS モジュールのレベル 2 BLAS の説明を参照してください。A のうち、uplo 三角部分のみを使用します。
更新後の y を返します。
LinearAlgebra.BLAS.sbmv — Method
sbmv(uplo, k, alpha, A, x)A は、size(A,2) 次の対称帯行列です。k 本の上対角線は、引数 A に格納されています。A の uplo 三角部分のみが使用されます。alpha*A*x
LinearAlgebra.BLAS.sbmv — Method
sbmv(uplo, k, A, x)A が次数 size(A,2) の対称帯行列で、k 本の上側対角線が引数 A に格納されている場合、A*x を返します。A のうち、uplo 三角部分のみが使用されます。
LinearAlgebra.BLAS.spmv! — Function
spmv!(uplo, α, AP, x, β, y)ベクトル y を、パック形式 AP で与えられた対称行列 A を用いて、α*A*x + β*y として更新します。
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! — Function
trmv!(ul, tA, dA, A, b)op(A)*bを返します。opはtAによって決まります。Aのul三角部分のみが使用されます。対角要素の値を読み取るか、すべて1とみなすかはdAによって決まります。乗算はb上でインプレースに行われます。
LinearAlgebra.BLAS.trmv — Function
trmv(ul, tA, dA, A, b)op(A)*bを返します。opはtAによって決まります。ulの三角部分のみがAに使用されます。dAによって、対角要素の値を読み取るか、すべて1とみなすかが決まります。
LinearAlgebra.BLAS.trsv! — Function
trsv!(ul, tA, dA, A, b)b を、A*x = b の解、または tA と ul によって決まる他の2つのバリエーションのいずれかで上書きしてください。対角成分の値を読み込むか、すべて1とみなすかは、dA によって決まります。更新後の b を返してください。
LinearAlgebra.BLAS.trsv — Function
trsv(ul, tA, dA, A, b)A*x = bの解、またはtAとulによって決まる他の2つのバリアントのいずれかを返します。対角成分を読み込むか、すべて1とみなすかはdAによって決まります。
行列を返す
LinearAlgebra.BLAS.ger! — Function
ger!(alpha, x, y, A)行列 A をベクトル x および y で alpha*x*y' + A としてランク1更新します。
LinearAlgebra.BLAS.geru! — Function
geru!(alpha, x, y, A)行列 A をベクトル x および y によって alpha*x*transpose(y) + A としてランク1更新します。
LinearAlgebra.BLAS.her! — Function
her!(uplo, alpha, x, A)複素数配列専用のメソッドです。ベクトル x を用いて、エルミート行列 A を alpha*x*x' + A としてランク1更新します。uplo によって、A のどちらの三角部分を更新するかが決まります。A を返します。
LinearAlgebra.BLAS.syr! — Function
syr!(uplo, alpha, x, A)対称行列 A をベクトル x で alpha*x*transpose(x) + A としてランク1更新します。uplo は、A のどちらの三角部分を更新するかを指定します。A を返します。
LinearAlgebra.BLAS.spr! — Function
spr!(uplo, α, x, AP)A 行列を A+α*x*x' として更新します。ここで、A はパック形式 AP で与えられる対称行列、x はベクトルです。
uplo = 'U' の場合、配列 AP には対称行列の上三角部分を列ごとに順にパックして格納します。つまり、AP[1] には A[1, 1] が格納され、AP[2] と AP[3] にはそれぞれ A[1, 2] と A[2, 2] が格納され、以降も同様です。
uplo = 'L' の場合、配列 AP には対称行列の下三角部分を列ごとに順にパックして格納します。つまり、AP[1] には A[1, 1] が格納され、AP[2] と AP[3] にはそれぞれ A[2, 1] と A[3, 1] が格納され、以降も同様です。
スカラー入力 α は実数でなければなりません。
配列入力 x と AP は、すべて Float32 型または Float64 型でなければなりません。更新後の AP を返します。
Level 3 BLAS functions
レベル 3 BLAS 関数は(Dongarra, 1990)で公開され、行列と行列の演算を定義します。
LinearAlgebra.BLAS.gemmt! — Function
gemmt!(uplo, tA, tB, alpha, A, B, beta, C)uploで指定されたCの下三角部分または上三角部分を、tAおよびtBに従って、alpha*A*B + beta*Cまたはその他のバリアントとして更新します。更新後のCを返します。
LinearAlgebra.BLAS.gemmt — Method
LinearAlgebra.BLAS.gemmt — Method
LinearAlgebra.BLAS.gemm! — Function
gemm!(tA, tB, alpha, A, B, beta, C)tAおよびtBに従って、Cをalpha*A*B + beta*Cまたはその他3つのバリエーションに更新してください。更新後のCを返してください。
LinearAlgebra.BLAS.gemm — Method
gemm(tA, tB, alpha, A, B)tA と tB に応じて、alpha*A*B または残りの3つのバリエーションを返します。
LinearAlgebra.BLAS.gemm — Method
gemm(tA, tB, A, B)A*B、またはtAとtBに応じて、残り3つのバリアントのいずれかを返します。
LinearAlgebra.BLAS.symm! — Function
symm!(side, ul, alpha, A, B, beta, C)sideに従って、Cをalpha*A*B + beta*Cまたはalpha*B*A + beta*Cに更新します。Aは対称であると仮定します。Aのうち、ul三角形のみを使用します。更新後のCを返します。
LinearAlgebra.BLAS.symm — Method
symm(side, ul, alpha, A, B)alpha*A*B または alpha*B*A を、side に応じて返します。A は対称であると仮定します。A のうち、ul 三角形のみを使用します。
LinearAlgebra.BLAS.symm — Method
LinearAlgebra.BLAS.hemm! — Function
hemm!(side, ul, alpha, A, B, beta, C)Cを、sideに従ってalpha*A*B + beta*Cまたはalpha*B*A + beta*Cに更新します。Aはエルミート行列であると仮定されます。Aのうち、ulの三角部分のみが使用されます。更新後のCを返します。
LinearAlgebra.BLAS.hemm — Method
hemm(side, ul, alpha, A, B)sideに応じて、alpha*A*Bまたはalpha*B*Aを返します。Aはエルミート行列であると仮定されます。Aのうち、使用されるのはul三角部分のみです。
LinearAlgebra.BLAS.hemm — Method
LinearAlgebra.BLAS.syrk! — Function
syrk!(uplo, trans, alpha, A, beta, C)transに従って、対称行列Cをalpha*A*transpose(A) + beta*Cまたはalpha*transpose(A)*A + beta*Cとしてランクk更新します。Cでは、uplo側の三角部分のみを使用します。Cを返します。
LinearAlgebra.BLAS.syrk — Function
syrk(uplo, trans, alpha, A)A の上三角部分または下三角部分を返します。どちらを返すかは uplo に従い、対象は alpha*A*transpose(A) または alpha*transpose(A)*A のいずれかです。どちらを対象とするかは trans に従います。
LinearAlgebra.BLAS.herk! — Function
herk!(uplo, trans, alpha, A, beta, C)複素数配列専用のメソッドです。transに従って、エルミート行列Cをalpha*A*A' + beta*Cまたはalpha*A'*A + beta*Cとしてランクk更新します。Cのuplo三角部分のみが更新されます。Cを返します。
LinearAlgebra.BLAS.herk — Function
LinearAlgebra.BLAS.syr2k! — Function
syr2k!(uplo, trans, alpha, A, B, beta, C)transに従って、対称行列Cをalpha*A*transpose(B) + alpha*B*transpose(A) + beta*Cまたはalpha*transpose(A)*B + alpha*transpose(B)*A + beta*Cとしてランク2k更新します。Cのうち、uploの三角部分のみを使用します。Cを返します。
LinearAlgebra.BLAS.syr2k — Function
syr2k(uplo, trans, alpha, A, B)transに応じて、alpha*A*transpose(B) + alpha*B*transpose(A)またはalpha*transpose(A)*B + alpha*transpose(B)*Aのuplo三角行列を返します。
syr2k(uplo, trans, A, B)transに応じて、A*transpose(B) + B*transpose(A)またはtranspose(A)*B + transpose(B)*Aのuplo三角形を返します。
LinearAlgebra.BLAS.her2k! — Function
her2k!(uplo, trans, alpha, A, B, beta, C)C を trans に従って alpha*A*B' + alpha'*B*A' + beta*C または alpha*A'*B + alpha'*B'*A + beta*C として更新する、エルミート行列のランク 2k 更新。スカラー beta は実数でなければなりません。C の uplo 三角部分のみを使用します。C を返します。
LAPACK functions
LinearAlgebra.LAPACK は、線形代数用の LAPACK 関数の一部をラップして提供します。入力配列のいずれかを上書きする関数の名前は、'!' で終わります。
通常、関数には Float64、Float32、ComplexF64、ComplexF32 の各配列に対応する 4 つのメソッドが定義されています。
Julia が提供する LAPACK API は、今後変更される可能性があり、実際に変更されることもあります。この API はユーザー向けではないため、今後のリリースでこの特定の関数群をサポートまたは非推奨化することは保証されません。
LinearAlgebra.LAPACK — Module
LAPACKサブルーチンへのインターフェース。
LinearAlgebra.LAPACK.gbtrf! — Function
gbtrf!(kl, ku, m, AB) -> (AB, ipiv)帯行列 AB の LU 分解を計算します。kl は非ゼロ要素を含む最初の劣対角線、ku は非ゼロ要素を含む最後の上対角線、m は行列 AB の第 1 次元です。LU 分解はインプレースで返され、使用されたピボットを格納するベクトル ipiv も返されます。
LinearAlgebra.LAPACK.gbtrs! — Function
gbtrs!(trans, kl, ku, m, AB, ipiv, B)方程式 AB * X = B を解きます。trans は AB の向きを指定します。N(転置なし)、T(転置)、または C(共役転置)を指定できます。kl は非ゼロの帯を含む最初の下副対角線、ku は非ゼロの帯を含む最後の上副対角線、m は行列 AB の第1次元です。ipiv は gbtrf! が返すピボットのベクトルです。ベクトルまたは行列 X を返し、B をインプレースで上書きします。
LinearAlgebra.LAPACK.gebal! — Function
gebal!(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! — Function
gebak!(job, side, ilo, ihi, scale, V)gebal! を使ってバランス調整した行列の固有ベクトル V を、元の行列のスケーリングおよび並べ替え前の固有ベクトルに変換します。V をインプレースで変更します。side には L(左固有ベクトルを変換)または R(右固有ベクトルを変換)を指定できます。
LinearAlgebra.LAPACK.gebrd! — Function
gebrd!(A) -> (A, d, e, tauq, taup)Aをその場で二重対角形A = QBP'に変換します。戻り値は、二重対角行列Bを格納するA、Bの対角要素を格納するd、Bの非対角要素を格納するe、Qを表す基本反射子を格納するtauq、およびPを表す基本反射子を格納するtaupです。
LinearAlgebra.LAPACK.gelqf! — Function
gelqf!(A, tau)A の A = LQ に対する LQ 分解を計算します。tau には、この分解の基本反射をパラメーター化するスカラーが格納されます。tau の長さは、A の最小次元以上でなければなりません。
A と tau をインプレースで変更して返します。
gelqf!(A) -> (A, tau)LQ 因子分解を A に計算します。A = LQ
変更された A と、因子分解の基本反射子をパラメーター化するスカラーを格納した tau を返します。
LinearAlgebra.LAPACK.geqlf! — Function
geqlf!(A, tau)QL の A, A = QL 分解を計算します。tau には、この分解の基本反射子をパラメーター化するスカラーが格納されています。tau の長さは、A の最小次元以上でなければなりません。
A と tau をインプレースで変更して返します。
geqlf!(A) -> (A, tau)QL の A 因子分解を計算します。A = QL
インプレースで変更された A と、因子分解の基本反射子をパラメーター化するスカラーを格納した tau を返します。
LinearAlgebra.LAPACK.geqrf! — Function
geqrf!(A, tau)A の QR 分解を計算します。A = QR。tau には、分解の基本反射子をパラメーター化するスカラーが格納されます。tau の長さは、A の最小次元以上でなければなりません。
A と tau をインプレースで変更して返します。
geqrf!(A) -> (A, tau)A の A = QR 因子分解を計算します(QR)。
インプレースで変更された A と、因子分解の基本反射子をパラメーター化するスカラーを格納した tau を返します。
LinearAlgebra.LAPACK.geqp3! — Function
geqp3!(A, [jpvt, tau]) -> (A, tau, jpvt)BLAS レベル 3 を使用して、A のピボット選択付き QR 分解 AP = QR を計算します。P はピボット行列で、jpvt によって表されます。tau には基本鏡映変換が格納されます。引数 jpvt と tau は省略可能で、事前に割り当てた配列を渡すことができます。これらを渡す場合、A が (m x n) 行列であれば、jpvt の長さは n 以上でなければなりません。また、tau の長さは A の最小の次元の大きさ以上でなければなりません。呼び出し時に jpvt[j] がゼロでない場合、A の第 j 列は AP の先頭に移動されます。
A、jpvt、tau はその場で変更されます。
LinearAlgebra.LAPACK.gerqf! — Function
gerqf!(A, tau)A の A = RQ に対する RQ 分解を計算します。tau には、この分解の基本反射子をパラメーター化するスカラーが格納されます。tau の長さは、A の最小次元以上でなければなりません。
A と tau をインプレースで変更して返します。
gerqf!(A) -> (A, tau)A、A = RQのRQ分解を計算します。
インプレースで変更されたAと、分解の基本反射子をパラメーター化するスカラーを格納したtauを返します。
LinearAlgebra.LAPACK.geqrt! — Function
geqrt!(A, T)QR のブロック化された A の因子分解を、A = QR を用いて計算します。T には、因子分解の基本反射子をパラメーター化する上三角ブロック反射子が格納されます。T の第1次元はブロックサイズを指定し、1 以上 n 以下でなければなりません。T の第2次元は、A の最小次元と等しくなければなりません。
A と T をインプレースで変更して返します。
geqrt!(A, nb) -> (A, T)A、A = QRのブロック化QR分解を計算します。nbはブロックサイズを指定します。ブロックサイズは1以上、Aの第2次元であるn以下でなければなりません。
インプレースで変更されたAと、分解の基本反射子をパラメーター化する上三角ブロック反射子を格納するTを返します。
LinearAlgebra.LAPACK.geqrt3! — Function
geqrt3!(A, T)A の A = QR に対するブロック化 QR 分解を再帰的に計算します。T には、分解の基本反射をパラメーター化する上三角ブロック反射子が格納されます。T の第 1 次元でブロックサイズを指定します。これは 1 以上 n 以下でなければなりません。T の第 2 次元は、A の最小次元と等しくなければなりません。
A と T をインプレースで変更して返します。
geqrt3!(A) -> (A, T)A のブロック化された QR 分解を、A = QR に対して再帰的に計算します。
インプレースで変更された A と、分解の基本反射子をパラメーター化する上三角ブロック反射子を格納した T を返します。
LinearAlgebra.LAPACK.getrf! — Function
getrf!(A, ipiv) -> (A, ipiv, info)A、A = LUのピボット付き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 内の特異値(この場合、U[i,i] は特異です。info = i)、またはエラーコード(info < 0)を返します。
LinearAlgebra.LAPACK.tzrzf! — Function
tzrzf!(A) -> (A, tau)上三角台形行列 A を、インプレースで上三角行列に変換します。変換に用いる基本反射のスカラー・パラメーターである A と tau を返します。
LinearAlgebra.LAPACK.ormrz! — Function
ormrz!(side, trans, A, tau, C)tzrzf!で指定された変換に基づき、行列 C に Q を乗算します。side または trans に応じて、左側からの乗算(side = L, Q*C)または右側からの乗算(side = R, C*Q)となります。また、Q は変更なし(trans = N)、転置(trans = T)、または共役転置(trans = C)にできます。乗算結果でインプレースに変更された行列 C を返します。
LinearAlgebra.LAPACK.gels! — Function
gels!(trans, A, B) -> (F, B, ssr)QR分解またはLQ分解を用いて、線形方程式 A * X = B、transpose(A) * X = B、または adjoint(A) * X = B を解きます。解を使って行列またはベクトル B をインプレースで変更します。A は、その QR 分解または LQ 分解で上書きされます。trans には、N(変更なし)、T(転置)、または C(共役転置)のいずれかを指定できます。gels! は、最小ノルム解または最小二乗解を求めます。A は、劣決定系でも過決定系でもかまいません。解は B に返されます。
LinearAlgebra.LAPACK.gesv! — Function
gesv!(A, B) -> (B, A, ipiv)A が正方行列である場合、A の LU 分解を用いて、線形方程式 A * X = B を解きます。A は LU 分解で上書きされ、B は解 X で上書きされます。ipiv には、A の LU 分解におけるピボット情報が格納されています。
LinearAlgebra.LAPACK.getrs! — Function
getrs!(trans, A, ipiv, B)正方行列 A に対する線形方程式 A * X = B、transpose(A) * X = B、または adjoint(A) * X = B を解きます。解を用いて、行列またはベクトル B をその場で変更します。A は、getrf! の LU 分解であり、ipiv はピボット情報です。trans には、N(変更なし)、T(転置)、または C(共役転置)を指定できます。
LinearAlgebra.LAPACK.getri! — Function
getri!(A, ipiv)getrf!で求めたAのLU分解を使って、その逆行列を計算します。ipivは出力されたピボット情報であり、Aにはgetrf!のLU分解が格納されています。Aは逆行列で上書きされます。
LinearAlgebra.LAPACK.gesvx! — Function
gesvx!(fact, trans, A, AF, ipiv, equed, R, C, B) -> (X, equed, R, C, B, rcond, ferr, berr, work)A の LU 分解を用いて、線形方程式 A * X = B (trans = N)、transpose(A) * X = B (trans = T)、または adjoint(A) * X = B (trans = C) を解きます。fact は、E の場合、A を平衡化して AF にコピーします。F の場合は、以前の LU 分解で得られた AF と ipiv が入力となります。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 として返されます。また、fact が N でない場合は出力となり、実行された平衡化を示す equed、行の平衡化対角行列 R、列の平衡化対角行列 C、平衡化後の形式 Diagonal(R)*B で上書きされる場合がある B(trans = N かつ equed = R,B の場合)、または Diagonal(C)*B(trans = T,C かつ equed = C,B の場合)、平衡化後の A の逆条件数 rcond、X 内の各解ベクトルの前進誤差限界 ferr、X 内の各解ベクトルの前進誤差限界 berr、および逆ピボット成長因子 work も返されます。
gesvx!(A, B)gesvx! の平衡化も転置も行わない簡略化。
LinearAlgebra.LAPACK.gelsd! — Function
gelsd!(A, B, rcond) -> (B, rnk)A * X = B の最小ノルム解を、A の SVD 分解を求めてから、分割統治法で問題を解くことで計算します。B は解 X で上書きされます。rcond 未満の特異値はゼロとして扱われます。解は B に、A の有効ランクは rnk に返されます。
LinearAlgebra.LAPACK.gelsy! — Function
gelsy!(A, B, rcond) -> (B, rnk)A の完全な QR 分解を求めた後、分割統治法で問題を解くことで、A * X = B の最小ノルム解を計算します。B は解 X で上書きされます。rcond 未満の特異値はゼロとして扱われます。解は B に、A の有効ランクは rnk に返されます。
LinearAlgebra.LAPACK.gglse! — Function
gglse!(A, c, B, d) -> (X,res)A * x = c の方程式を解きます。ここで、x は等式制約 B * x = d を満たします。||c - A*x||^2 = 0 の公式を使って解を求め、X と残差平方和を返します。
LinearAlgebra.LAPACK.geev! — Function
geev!(jobvl, jobvr, A) -> (W, VL, VR)A の固有系を求めます。jobvl = N の場合、A の左固有ベクトルは計算されません。jobvr = N の場合、A の右固有ベクトルは計算されません。jobvl = V または jobvr = V の場合は、対応する固有ベクトルが計算されます。固有値は W に、右固有ベクトルは VR に、左固有ベクトルは VL に返されます。
LinearAlgebra.LAPACK.gesdd! — Function
gesdd!(job, A) -> (U, S, VT)A、A = U * S * V'の特異値分解を、分割統治法を用いて求めます。job = Aの場合、Uのすべての列と、V'のすべての行が計算されます。job = Nの場合、Uの列もV'の行も計算されません。job = Oの場合、Aは、(薄い)Uの列と(薄い)V'の行で上書きされます。job = Sの場合、(薄い)Uの列と(薄い)V'の行が計算され、個別に返されます。
LinearAlgebra.LAPACK.gesvd! — Function
gesvd!(jobu, jobvt, A) -> (U, S, VT)A の特異値分解を求めます。A = U * S * V'。jobu = A の場合、U のすべての列を計算します。jobvt = A の場合、V' のすべての行を計算します。jobu = N の場合、U の列は計算されません。jobvt = N の場合、V' の行は計算されません。jobu = O の場合、A は(薄い)U の列で上書きされます。jobvt = O の場合、A は(薄い)V' の行で上書きされます。jobu = S の場合、(薄い)U の列を計算し、個別に返します。jobvt = S の場合、(薄い)V' の行を計算し、個別に返します。jobu と jobvt を同時に O にすることはできません。
U、S、Vt を返します。ここで、S は A の特異値です。
LinearAlgebra.LAPACK.ggsvd! — Function
ggsvd!(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! — Function
ggsvd3!(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! — Function
geevx!(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! — Function
ggev!(jobvl, jobvr, A, B) -> (alpha, beta, vl, vr)A と B の一般化固有値分解を求めます。jobvl = N の場合、左固有ベクトルは計算されません。jobvr = N の場合、右固有ベクトルは計算されません。jobvl = V または jobvr = V の場合は、対応する固有ベクトルが計算されます。
LinearAlgebra.LAPACK.ggev3! — Function
ggev3!(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! — Function
gtsv!(dl, d, du, B)方程式 A * X = B を解きます。ここで、A は、劣対角成分が dl、対角成分が d、優対角成分が du の三重対角行列です。
B を解 X で上書きし、その値を返します。
LinearAlgebra.LAPACK.gttrf! — Function
gttrf!(dl, d, du) -> (dl, d, du, du2, ipiv)劣対角にdl、対角にd、超対角にduを持つ三重対角行列のLU分解を求めます。
dl、d、duをインプレースで変更し、それらに加えて第2超対角du2とピボットベクトルipivを返します。
LinearAlgebra.LAPACK.gttrs! — Function
gttrs!(trans, dl, d, du, du2, ipiv, B)gttrf!で計算されたLU分解を使って、方程式A * X = B(trans = N)、transpose(A) * X = B(trans = T)、またはadjoint(A) * X = B(trans = C)を解きます。解XでBを上書きします。
LinearAlgebra.LAPACK.orglq! — Function
orglq!(A, tau, k = length(tau))A に対して gelqf! を呼び出した後、LQ 分解の行列 Q を明示的に取得します。gelqf! の出力を使用します。A は Q によって上書きされます。
LinearAlgebra.LAPACK.orgqr! — Function
orgqr!(A, tau, k = length(tau))A に対して geqrf! を呼び出した後、QR 分解の行列 Q を明示的に求めます。geqrf! の出力を使用します。A は Q によって上書きされます。
LinearAlgebra.LAPACK.orgql! — Function
orgql!(A, tau, k = length(tau))A に対して geqlf! を呼び出した後、QL 分解の行列 Q を明示的に求めます。geqlf! の出力を使用します。A は Q によって上書きされます。
LinearAlgebra.LAPACK.orgrq! — Function
orgrq!(A, tau, k = length(tau))A に対して gerqf! を呼び出した後、RQ 分解の行列 Q を明示的に求めます。gerqf! の出力を使用します。A は Q によって上書きされます。
LinearAlgebra.LAPACK.ormlq! — Function
ormlq!(side, trans, A, tau, C)gelqf!を用いて計算したAのLQ分解から、side = Lに対するQ * C(trans = N)、transpose(Q) * C(trans = T)、adjoint(Q) * C(trans = C)、またはside = Rに対する同等の右乗算を、Qを用いて計算します。Cは上書きされます。
LinearAlgebra.LAPACK.ormqr! — Function
ormqr!(side, trans, A, tau, C)geqrf!を使って計算したAのQR分解からQを用いて、side = Lに対するQ * C(trans = N)、transpose(Q) * C(trans = T)、adjoint(Q) * C(trans = C)を計算します。または、side = Rに対する同等の右側乗算を計算します。Cは上書きされます。
LinearAlgebra.LAPACK.ormql! — Function
ormql!(side, trans, A, tau, C)geqlf!を用いて計算したAのQL分解からQを使い、side = Lに対するQ * C(trans = N)、transpose(Q) * C(trans = T)、adjoint(Q) * C(trans = C)を計算します。または、side = Rに対する同等の右側乗算を計算します。Cは上書きされます。
LinearAlgebra.LAPACK.ormrq! — Function
ormrq!(side, trans, A, tau, C)gerqf!を用いて計算したAのRQ分解からQを使って、side = Lに対するQ * C(trans = N)、transpose(Q) * C(trans = T)、adjoint(Q) * C(trans = C)、またはside = Rに対する同等の右側乗算を計算します。Cは上書きされます。
LinearAlgebra.LAPACK.gemqrt! — Function
gemqrt!(side, trans, V, T, C)Aのgeqrt!を用いて計算したQR分解から、side = Lに対するQ * C(trans = N)、transpose(Q) * C(trans = T)、adjoint(Q) * C(trans = C)を計算します。または、side = Rに対して、Qを用いた同等の右側乗算を行います。Cは上書きされます。
LinearAlgebra.LAPACK.posv! — Function
posv!(uplo, A, B) -> (A, B)A が対称正定値行列またはエルミート正定値行列である場合に、A * X = B の解を求めます。uplo = U の場合は、A の上三角コレスキー分解を計算します。uplo = L の場合は、A の下三角コレスキー分解を計算します。A はコレスキー分解で上書きされます。B は解 X で上書きされます。
LinearAlgebra.LAPACK.potrf! — Function
potrf!(uplo, A)正定値行列 A のコレスキー分解を計算します(uplo = U の場合は上三角、uplo = L の場合は下三角)。A は上書きされ、情報コードとともに返されます。
LinearAlgebra.LAPACK.potri! — Function
potri!(uplo, A)potrf!を呼び出して正定値行列Aのコレスキー分解(uplo = Uの場合は上三角、uplo = Lの場合は下三角)を求めた後、その逆行列を計算します。
Aは逆行列で上書きされ、その値が返されます。
LinearAlgebra.LAPACK.potrs! — Function
potrs!(uplo, A, B)A が対称正定値またはエルミート正定値行列であり、そのコレスキー分解が potrf! によって計算されている場合に、A * X = B の解を求めます。uplo = U の場合は、A の上三角コレスキー分解が計算されています。uplo = L の場合は、A の下三角コレスキー分解が計算されています。B は、解 X で上書きされます。
LinearAlgebra.LAPACK.pstrf! — Function
pstrf!(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! — Function
ptsv!(D, E, B)正定値三重対角行列 A に対して、A * X = B を解きます。D は A の対角成分、E は非対角成分です。B は解 X で上書きされ、その値が返されます。
LinearAlgebra.LAPACK.pttrf! — Function
pttrf!(D, E)対角成分がD、非対角成分がEである正定値三重対角行列のLDLt分解を計算します。DとEは上書きされ、返されます。
LinearAlgebra.LAPACK.pttrs! — Function
pttrs!(D, E, B)pttrf!を使用してAのLDLt分解を計算した後、対角成分がD、非対角成分がEである正定値三重対角Aに対して、A * X = Bを解きます。Bは解Xで上書きされます。
LinearAlgebra.LAPACK.trtri! — Function
trtri!(uplo, diag, A)(uplo = U の場合は上三角、uplo = L の場合は下三角)行列 A の逆行列を求めます。diag = N の場合、A の対角要素は単位元ではありません。diag = U の場合、A の対角要素はすべて 1 です。A は逆行列で上書きされます。
LinearAlgebra.LAPACK.trtrs! — Function
trtrs!(uplo, trans, diag, A, B)上三角行列の場合は A * X = B(trans = N)、下三角行列の場合は transpose(A) * X = B(trans = T)、または adjoint(A) * X = B(trans = C)を、三角行列 A に対して解きます(uplo = U が真なら上三角、uplo = L が真なら下三角)。diag = N の場合、A の対角要素は 1 ではありません。diag = U の場合、A の対角要素はすべて 1 です。B は解 X で上書きされます。
LinearAlgebra.LAPACK.trcon! — Function
trcon!(norm, uplo, diag, A)A の逆条件数を求めます(uplo = U の場合は上三角行列、uplo = L の場合は下三角行列)。diag = N の場合、A の対角要素はすべて 1 以外です。diag = U の場合、A の対角要素はすべて 1 です。norm = I の場合、無限大ノルムで条件数を求めます。norm = O または 1 の場合、1 ノルムで条件数を求めます。
LinearAlgebra.LAPACK.trevc! — Function
trevc!(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! — Function
trrfs!(uplo, trans, diag, A, B, X, Ferr, Berr) -> (Ferr, Berr)side = L に対する A * X = B (trans = N)、transpose(A) * X = B (trans = T)、adjoint(A) * X = B (trans = C) の解の誤差を推定します。または、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! — Function
stev!(job, dv, ev) -> (dv, Zmat)対称三重対角行列の固有系を計算します。対角成分は dv、非対角成分は ev です。job = N の場合は、固有値のみを求めて dv に返します。job = V の場合は、固有ベクトルも求めて Zmat に返します。
LinearAlgebra.LAPACK.stebz! — Function
stebz!(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! — Function
stegr!(jobz, range, dv, ev, vl, vu, il, iu) -> (w, Z)対称三重対角行列の対角成分をdv、非対角成分をevとして、固有値(jobz = N)、または固有値と固有ベクトル(jobz = V)を計算します。range = Aの場合は、すべての固有値を求めます。range = Vの場合は、半開区間(vl, vu]内の固有値を求めます。range = Iの場合は、インデックスがilからiuまでの固有値を求めます。固有値はwに、固有ベクトルはZに返されます。
LinearAlgebra.LAPACK.stein! — Function
stein!(dv, ev_in, w_in, iblock_in, isplit_in)対角成分がdv、非対角成分がev_inである対称三重対角行列の固有ベクトルを計算します。w_inには、対応する固有ベクトルを求める固有値を指定します。iblock_inには、w_inの固有値に対応する部分行列を指定します。isplit_inには、部分行列ブロック間の分割点を指定します。
LinearAlgebra.LAPACK.syconv! — Function
syconv!(uplo, A, ipiv) -> (A, work)三角行列に分解された対称行列 A を、2つの行列 L と D に変換します。uplo = U の場合、A は上三角行列になります。uplo = L の場合は、下三角行列になります。ipiv は、三角分解で得られたピボットベクトルです。A は、L と D で上書きされます。
LinearAlgebra.LAPACK.sysv! — Function
sysv!(uplo, A, B) -> (B, A, ipiv)対称行列 A に対する A * X = B の解を求めます。uplo = U の場合、A の上半分が格納されています。uplo = L の場合は、下半分が格納されています。B は解 X で上書きされます。A は、そのバンチ・カウフマン分解で上書きされます。ipiv には、分解に関するピボット情報が格納されています。
LinearAlgebra.LAPACK.sytrf! — Function
sytrf!(uplo, A) -> (A, ipiv, info)対称行列 A の Bunch-Kaufman 分解を計算します。uplo = U の場合、A の上半分が格納されます。uplo = L の場合、下半分が格納されます。
分解によって上書きされる A、ピボットベクトル ipiv、および非負整数のエラーコード info を返します。info が正の場合、行列は特異であり、分解の対角部分は位置 info で厳密にゼロになります。
sytrf!(uplo, A, ipiv) -> (A, ipiv, info)対称行列 A の Bunch-Kaufman 分解を計算します。uplo = U の場合、A の上半分が格納されます。uplo = L の場合、下半分が格納されます。
分解によって上書きされた A、ピボットベクトル ipiv、および非負整数のエラーコード info を返します。info が正の場合、行列は特異であり、分解の対角部分は位置 info で厳密にゼロになります。
LinearAlgebra.LAPACK.sytri! — Function
sytri!(uplo, A, ipiv)sytrf! の計算結果を用いて、対称行列 A の逆行列を計算します。uplo = U の場合、A の上半分が格納されています。uplo = L の場合は、下半分が格納されています。A は逆行列で上書きされます。
LinearAlgebra.LAPACK.sytrs! — Function
sytrs!(uplo, A, ipiv, B)sytrf! の結果を用いて、対称行列 A に対する方程式 A * X = B を解きます。uplo = U の場合、A の上半分が格納されます。uplo = L の場合は、下半分が格納されます。B は、解 X で上書きされます。
LinearAlgebra.LAPACK.hesv! — Function
hesv!(uplo, A, B) -> (B, A, ipiv)エルミート行列 A に対する A * X = B の解を求めます。uplo = U の場合、A の上半分が格納されます。uplo = L の場合は、下半分が格納されます。B は解 X で上書きされます。A は Bunch–Kaufman 分解で上書きされます。ipiv には、分解に関するピボット情報が格納されます。
LinearAlgebra.LAPACK.hetrf! — Function
hetrf!(uplo, A) -> (A, ipiv, info)エルミート行列 A の Bunch-Kaufman 分解を計算します。uplo = U の場合、A の上半分が格納されます。uplo = L の場合、下半分が格納されます。
分解によって上書きされた A、ピボットベクトル ipiv、および非負整数のエラーコード info を返します。info が正の場合、行列は特異であり、分解の対角部分は位置 info で厳密にゼロになります。
hetrf!(uplo, A, ipiv) -> (A, ipiv, info)エルミート行列 A の Bunch-Kaufman 分解を計算します。uplo = U の場合、A の上半分が格納されます。uplo = L の場合、下半分が格納されます。
分解結果で上書きされた A、ピボットベクトル ipiv、および非負整数のエラーコード info を返します。info が正の場合、行列は特異であり、分解の対角部分は位置 info で厳密にゼロになります。
LinearAlgebra.LAPACK.hetri! — Function
hetri!(uplo, A, ipiv)sytrf! の結果を用いて、エルミート行列 A の逆行列を計算します。uplo = U の場合、A の上半分が格納されています。uplo = L の場合は、下半分が格納されています。A は逆行列で上書きされます。
LinearAlgebra.LAPACK.hetrs! — Function
hetrs!(uplo, A, ipiv, B)sytrf! の結果を用いて、エルミート行列 A に対する方程式 A * X = B を解きます。uplo = U の場合、A の上半分が格納されます。uplo = L の場合は、下半分が格納されます。B は、解 X で上書きされます。
LinearAlgebra.LAPACK.syev! — Function
syev!(jobz, uplo, A)対称行列 A の固有値(jobz = N)、または固有値と固有ベクトル(jobz = V)を求めます。uplo = U の場合は A の上三角部分を使用し、uplo = L の場合は A の下三角部分を使用します。
LinearAlgebra.LAPACK.syevr! — Function
syevr!(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! — Function
syevd!(jobz, uplo, A)対称行列 A の固有値(jobz = N)、または固有値と固有ベクトル(jobz = V)を求めます。uplo = U の場合は A の上三角部分を使用し、uplo = L の場合は A の下三角部分を使用します。
LinearAlgebra.LAPACK.sygvd! — Function
sygvd!(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! — Function
bdsqr!(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! — Function
bdsdc!(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! — Function
gecon!(normtype, A, anorm)行列 A の逆条件数を求めます。normtype = I の場合、条件数は無限大ノルムで求められます。normtype = O または 1 の場合は、1ノルムで求められます。A は getrf! の結果でなければならず、anorm は該当するノルムにおける A のノルムです。
LinearAlgebra.LAPACK.gehrd! — Function
gehrd!(ilo, ihi, A) -> (A, tau)行列 A をヘッセンベルグ形式に変換します。A が gebal! とともにバランス調整されている場合、ilo と ihi が gebal! の出力になります。そうでない場合は、ilo = 1 と ihi = size(A,2) が出力になります。tau には、因子分解における基本反射子が格納されています。
LinearAlgebra.LAPACK.orghr! — Function
orghr!(ilo, ihi, A, tau)gehrd!から直交行列/ユニタリ行列Qを明示的に求めます。ilo、ihi、A、tauは、gehrd!への入力/出力に対応している必要があります。
LinearAlgebra.LAPACK.gees! — Function
gees!(jobvs, A) -> (A, vs, w)行列 A の固有値(jobvs = N)、または固有値とシュールベクトル(jobvs = V)を計算します。A はシュール形式で上書きされます。
A を返します。vs にはシュールベクトルが、w には固有値が格納されます。
LinearAlgebra.LAPACK.gges! — Function
gges!(jobvsl, jobvsr, A, B) -> (A, B, alpha, beta, vsl, vsr)A と B の一般化固有値、一般化シュール形式、左シュールベクトル(jobsvl = V)、または右シュールベクトル(jobvsr = V)を計算します。
一般化固有値は alpha と beta に返されます。左シュールベクトルは vsl に、右シュールベクトルは vsr に返されます。
LinearAlgebra.LAPACK.gges3! — Function
gges3!(jobvsl, jobvsr, A, B) -> (A, B, alpha, beta, vsl, vsr)ブロック化アルゴリズムを用いて、A と B の一般化固有値、一般化シュール形式、左シュールベクトル(jobsvl = V)、または右シュールベクトル(jobvsr = V)を計算します。この関数には LAPACK 3.6.0 が必要です。
一般化固有値は alpha と beta に返されます。左シュールベクトルは vsl に、右シュールベクトルは vsr に返されます。
LinearAlgebra.LAPACK.trexc! — Function
trexc!(compq, ifst, ilst, T, Q) -> (T, Q)
trexc!(ifst, ilst, T, Q) -> (T, Q)行列のシュール分解 T を並べ替え、T の行インデックス ifst にある対角ブロックを、行インデックス ilst に移動します。compq = V の場合、シュールベクトル Q も並べ替えられます。compq = N の場合は変更されません。4引数メソッドは、compq = V を指定して5引数メソッドを呼び出します。
LinearAlgebra.LAPACK.trsen! — Function
trsen!(job, compq, select, T, Q) -> (T, Q, w, s, sep)
trsen!(select, T, Q) -> (T, Q, w, s, sep)行列のシュール分解の順序を並べ替え、必要に応じて逆条件数を求めます。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! — Function
tgsen!(select, S, T, Q, Z) -> (S, T, alpha, beta, Q, Z)一般化シュール分解のベクトルの順序を並べ替えます。selectは、各クラスターに含まれる固有値を指定します。
LinearAlgebra.LAPACK.trsyl! — Function
trsyl!(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! — Function
hseqr!(job, compz, ilo, ihi, H, Z) -> (H, Z, w)ヘッセンベルグ形式に変換された行列のすべての固有値を計算し、必要に応じてシュール分解も計算します。H が gebal! でバランス調整されている場合、ilo と ihi は gebal! の出力です。そうでない場合は、ilo = 1 と ihi = size(H,2) である必要があります。tau には、分解に用いる基本反射子が格納されています。
Developer Documentation
LinearAlgebra.matprod_dest — Function
matprod_dest(A, B, T)AbstractArray(要素型がT)のうち、A * Bの結果を格納するために使用できるものを返します。
LinearAlgebra.haszero — Function
haszero(T::Type)型 T に、zero(T) を使って定義された一意のゼロ要素があるかどうかを返します。型 M が zero(M) を特殊化する場合、haszero(M) を true に設定することもできます。デフォルトでは、haszero は false とみなされます。この場合、ゼロ要素は型ではなく値から推定されます。
- 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 and L Kaufman, Some stable methods for calculating inertia and solving symmetric linear systems, Mathematics of Computation 31:137 (1977), 163-179. url.
- pr1387PR 1387, "stable pinv least-squares", LinearAlgebra.jl#1387
- 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
- AH12Awad H. Al-Mohy および Nicholas J. Higham、「行列対数のための改良型逆スケーリング・二乗アルゴリズム」、SIAM Journal on Scientific Computing, 34(4), 2012, C153-C169. doi:10.1137/110852553
- AHR13Awad H. Al-Mohy、Nicholas J. Higham および Samuel D. Relton、「行列対数の Fréchet 微分の計算と条件数の推定」、SIAM Journal on Scientific Computing, 35(4), 2013, C394-C410. doi:10.1137/120885991
- 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 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_2Mary 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_3Mary 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_4Mary 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_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 and Nicholas J. Higham, "Matrix Inverse Trigonometric and Inverse Hyperbolic Functions: Theory and Algorithms", MIMS EPrint: 2016.4. https://doi.org/10.1137/16M1057577