Linear Algebra

多次元配列のサポートに加えて、その一環として、Julia には一般的で便利な線形代数演算の多くがネイティブ実装されており、using LinearAlgebra を読み込むことで利用できます。tr、det、inv などの基本演算がすべてサポートされています。

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

julia> tr(A)
3

julia> det(A)
104.0

julia> inv(A)
3×3 Matrix{Float64}:
 -0.451923   0.211538    0.0865385
  0.365385  -0.192308    0.0576923
  0.240385   0.0576923  -0.0673077

固有値や固有ベクトルの計算など、ほかにも便利な演算が用意されています。

julia> A = [-4. -17.; 2. 2.]
2×2 Matrix{Float64}:
 -4.0  -17.0
  2.0    2.0

julia> eigvals(A)
2-element Vector{ComplexF64}:
 -1.0 - 5.0im
 -1.0 + 5.0im

julia> eigvecs(A)
2×2 Matrix{ComplexF64}:
  0.945905-0.0im        0.945905+0.0im
 -0.166924+0.278207im  -0.166924-0.278207im

さらに Julia には、行列を問題に適した形式にあらかじめ因数分解することで、線形方程式の求解や行列指数関数の計算などを高速化できる factorizations が多数用意されています。因数分解によって、性能やメモリ使用量の面で問題により適した形式にできます。詳しくは factorize のドキュメントを参照してください。例を示します。

julia> A = [1.5 2 -4; 3 -1 -6; -10 2.3 4]
3×3 Matrix{Float64}:
   1.5   2.0  -4.0
   3.0  -1.0  -6.0
 -10.0   2.3   4.0

julia> factorize(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
3×3 Matrix{Float64}:
  1.0    0.0       0.0
 -0.15   1.0       0.0
 -0.3   -0.132196  1.0
U factor:
3×3 Matrix{Float64}:
 -10.0  2.3     4.0
   0.0  2.345  -3.4
   0.0  0.0    -5.24947

A はエルミート行列、対称行列、三角行列、三重対角行列、二重対角行列のいずれでもないため、最善の方法は LU 分解かもしれません。次の例と比較してください。

julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Matrix{Float64}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

julia> factorize(B)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
3×3 Tridiagonal{Float64, Vector{Float64}}:
 -1.64286   0.0   ⋅
  0.0      -2.8  0.0
   ⋅        0.0  5.0
U factor:
3×3 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.142857  -0.8
  ⋅   1.0       -0.6
  ⋅    ⋅         1.0
permutation:
3-element Vector{Int64}:
 1
 2
 3

ここでは Julia が B は実際には対称行列であると判定し、より適切な分解を使用しています。対称行列や三重対角行列など、特定の性質を持つことが分かっている行列については、より効率的なコードを書ける場合がよくあります。Julia には、行列にこうした性質があることを「タグ付け」するための特殊な型が用意されています。たとえば、次のようにします。

julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Matrix{Float64}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

julia> sB = Symmetric(B)
3×3 Symmetric{Float64, Matrix{Float64}}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

sB は(実数)対称行列としてタグ付けされています。そのため、固有分解や行列とベクトルの積など、後続の演算では行列の半分だけを参照して効率化できます。たとえば、次のとおりです。

julia> B = [1.5 2 -4; 2 -1 -3; -4 -3 5]
3×3 Matrix{Float64}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

julia> sB = Symmetric(B)
3×3 Symmetric{Float64, Matrix{Float64}}:
  1.5   2.0  -4.0
  2.0  -1.0  -3.0
 -4.0  -3.0   5.0

julia> x = [1; 2; 3]
3-element Vector{Int64}:
 1
 2
 3

julia> sB\x
3-element Vector{Float64}:
 -1.7391304347826084
 -1.1086956521739126
 -1.4565217391304346

ここでの \ 演算が線形方程式を解きます。左除算演算子は非常に強力で、さまざまな連立一次方程式を解ける柔軟性を備えた、簡潔で読みやすいコードを簡単に書けます。

Special matrices

Matrices with special symmetries and structures は線形代数で頻繁に登場し、さまざまな行列分解と関連付けられることもよくあります。Julia には特殊な行列型が豊富に用意されており、特定の行列型向けに開発された専用ルーチンを使って高速に計算できます。

以下の表では、Julia に実装されている特殊行列型と、それらに対する LAPACK の各種最適化メソッドへの接続が利用可能かどうかをまとめています。

型説明
SymmetricSymmetric matrix
HermitianHermitian matrix
UpperTriangular上三角 triangular matrix
UnitUpperTriangular対角成分が 1 の上三角 triangular matrix
LowerTriangular下三角 triangular matrix
UnitLowerTriangular対角成分が 1 の下三角 triangular matrix
UpperHessenberg上三角 Hessenberg matrix
TridiagonalTridiagonal matrix
SymTridiagonal対称三重対角行列
Bidiagonal上/下 bidiagonal matrix
DiagonalDiagonal matrix
UniformScalingUniform scaling operator

Elementary operations

行列型+-*\最適化メソッドが用意されているその他の関数
SymmetricMVinv, sqrt, cbrt, exp
HermitianMVinv, sqrt, cbrt, exp
UpperTriangularMVMVinv, det, logdet
UnitUpperTriangularMVMVinv, det, logdet
LowerTriangularMVMVinv, det, logdet
UnitLowerTriangularMVMVinv, det, logdet
UpperHessenbergMMinv, det
SymTridiagonalMMMSMVeigmax, eigmin
TridiagonalMMMSMV
BidiagonalMMMSMV
DiagonalMMMVMVinv, det, logdet, /
UniformScalingMMMVSMVS/

凡例:

キー説明
M(行列)行列と行列の演算に最適化されたメソッドを利用できます
V(ベクトル)行列とベクトルの演算に最適化されたメソッドを利用できます
S(スカラー)行列とスカラーの演算に最適化されたメソッドを利用できます

Matrix factorizations

行列型LAPACKeigeneigvalseigvecssvdsvdvals
SymmetricSYARI
HermitianHEARI
UpperTriangularTRAAA
UnitUpperTriangularTRAAA
LowerTriangularTRAAA
UnitLowerTriangularTRAAA
SymTridiagonalSTAARIAV
TridiagonalGT
BidiagonalBDAA
DiagonalDIA

凡例:

キー説明例
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 セクションを参照してください。

型説明
BunchKaufmanBunch-Kaufman 分解
CholeskyCholesky factorization
CholeskyPivotedPivoted Cholesky 分解
LDLtLDL(T) factorization
LULU factorization
QRQR factorization
QRCompactWYQR 分解のコンパクト WY 形式
QRPivotedピボット付き QR factorization
LQtranspose(A) の QR factorization
HessenbergHessenberg decomposition
EigenSpectral decomposition
GeneralizedEigenGeneralized spectral decomposition
SVDSingular value decomposition
GeneralizedSVDGeneralized SVD
SchurSchur decomposition
GeneralizedSchurGeneralized 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-multiplication

eltype の昇格が不要であれば、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 分解などの他の行列分解では、ピボット選択を行わないと失敗することがあります。また、浮動小数点行列では丸め誤差の影響により、数値的に不安定になる場合もあります。このような場合、このピボット戦略は主に教育目的で役立ちます。

source
LinearAlgebra.RowNonZero — Type
RowNonZero

残りの行で最初に見つかった非ゼロ要素をピボット要素として選びます。

浮動小数点行列では、この方法による LU アルゴリズムは数値的に不安定になるため注意してください。この方法は主に、手計算(通常はこの方法を使います)との比較や、丸め誤差の影響を受けない他の代数的型(有理数など)での使用に適しています。それ以外の場合、ガウス消去法では通常、デフォルトの RowMaximum ピボット戦略を使うことを推奨します。

行列の element type は、iszero メソッドを持つ必要があります。

source
LinearAlgebra.RowMaximum — Type
RowMaximum

ピボットには、最大値に基づいて行(場合によっては列も)が選ばれます。これは、LU 分解とピボット付きコレスキー分解のデフォルトの戦略です(ただし、NoPivot は cholesky のデフォルトです)。

LU 分解では、現在の列のうち、残りの行にある要素から絶対値が最大のものをピボット要素として選びます。これは「部分ピボット選択」アルゴリズムと呼ばれることがあります。この場合、行列の element type は abs メソッドをサポートしている必要があり、その戻り値の型も < メソッドをサポートしている必要があります。

コレスキー分解では、残りの対角要素のうち最大のものをピボット要素として選びます。これは「対角ピボット選択」アルゴリズムと呼ばれることがあり、完全ピボット選択(つまり、同じ置換によって行と列の両方を入れ替える方法)につながります。この場合、行列の element type(の実部)は < メソッドをサポートしている必要があります。

source
LinearAlgebra.ColumnNorm — Type
ColumnNorm

ノルムが最大の列を、以降の計算に使用します。これはピボット付きQR分解で使用されます。

行列のelement typeは、normメソッドとabsメソッドをサポートしている必要があります。また、それぞれの戻り値の型は<メソッドをサポートしている必要があります。

source

Standard functions

Julia の線形代数関数の多くは、LAPACK の関数を呼び出して実装されています。疎行列の分解では、SuiteSparse の関数が呼び出されます。そのほかの疎行列ソルバーは Julia のパッケージとして利用できます。

Base.:* — Method
*(A::AbstractMatrix, B::AbstractMatrix)

行列の乗算。

Examples

julia> [1 1; 0 1] * [1 0; 1 1]
2×2 Matrix{Int64}:
 2  1
 1  1
source
Base.:* — Method
*(A, B::AbstractMatrix, C)
A * B * C * D

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

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

最初または最後の因子が数値の場合は、5引数のmul!を使って行列乗算に融合します。

関連項目: muladd、dot。

Julia 1.7

これらの最適化にはJulia 1.7以降が必要です。

source
Base.:\ — Method
\(A, B)

多項式アルゴリズムによる行列除算。入力行列 A と B に対して、結果 X は、A が正方行列の場合、A*X == B となります。使用されるソルバーは、A の構造によって異なります。A が上三角行列、下三角行列、または対角行列の場合、A の因子分解は不要で、前進代入または後退代入によって連立方程式を解きます。三角行列でない正方行列には、LU分解を使用します。

長方形行列 A の場合、結果は、A のピボット付きQR分解と、R因子に基づく A のランク推定によって計算される、最小ノルム最小二乗解です。

A が疎行列の場合も、同様の多項式アルゴリズムを使用します。不定値行列では、LDLt 分解の数値分解時にピボット選択を行わないため、行列が可逆であっても処理に失敗することがあります。

関連項目: factorize、pinv。

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
true
source
Base.:/ — 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))
true
source
LinearAlgebra.SingularException — Type
SingularException

入力行列にゼロの固有値が1つ以上あり、逆行列を持たない場合にスローされる例外です。このような行列を含む連立一次方程式は解けません。infoフィールドは、特異値の位置(いずれか1つ)を示します。

source
LinearAlgebra.PosDefException — Type
PosDefException

入力行列がpositive definiteでない場合にスローされます。線形代数関数や行列分解の中には、正定値行列にのみ適用できるものがあります。infoフィールドは、0以下の固有値の位置を示します。

source
LinearAlgebra.ZeroPivotException — Type
ZeroPivotException <: Exception

行列の因子分解または求解でピボット(対角)位置にゼロが見つかり、処理を続行できない場合にスローされる例外です。これは、行列が特異であることを必ずしも意味しません。ピボット付き LU 分解など、変数の順序を入れ替えて見かけ上のゼロピボットを解消できる別の因子分解に切り替えるとよい場合があります。info フィールドは、ゼロピボットの位置(複数ある場合はそのうちの 1 つ)を示します。

source
LinearAlgebra.RankDeficientException — Type
RankDeficientException

入力行列がrank deficientの場合にスローされる例外です。コレスキー分解など、一部の線形代数関数は、ランク落ちしていない行列にのみ適用できます。infoフィールドは、行列の計算されたランクを示します。

source
LinearAlgebra.LAPACKException — Type
LAPACKException

LAPACK functions の直接呼び出し時、または LAPACK 関数を内部で使用しているものの、専用のエラー処理を備えていない他の関数の呼び出し時にスローされる、汎用的な LAPACK 例外です。info フィールドには、元のエラーに関する追加情報が格納されます。その内容は、呼び出された LAPACK 関数によって異なります。

source
LinearAlgebra.dot — Function
dot(x, y)
x ⋅ y

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

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

dot は意味的には sum(dot(vx,vy) for (vx,vy) in zip(x, y)) と同等ですが、引数の長さが等しくなければならないという制約が追加されています。

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

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.0
source
LinearAlgebra.dot — Method
dot(x, A, y)

2つのベクトル x と y の一般化内積 dot(x, A*y) を計算します。中間結果 A*y は保存されません。2引数の dot(_,_) と同様に、これは再帰的に動作します。また、複素ベクトルの場合は、第1ベクトルの複素共役を取ります。

Julia 1.4

3引数の dot を使用するには、Julia 1.4以降が必要です。

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)
true
source
LinearAlgebra.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
 0
source
LinearAlgebra.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
 12
source
LinearAlgebra.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
 18
source
LinearAlgebra.rotate! — Function
rotate!(x, y, c, s)

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

Julia 1.5

rotate!にはJulia 1.5以降が必要です。

source
LinearAlgebra.reflect! — Function
reflect!(x, y, c, s)

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

Julia 1.5

reflect!にはJulia 1.5以降が必要です。

source
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型に特化した手法が使われます。

source
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  ⋅
 ⋅  1
Note

1 列の行列はベクトルとして扱われず、代わりに 1 要素の diag(A) を取り出すメソッド Diagonal(A::AbstractMatrix) が呼び出されます。

julia> A = transpose([7.0 13.0])
2×1 transpose(::Matrix{Float64}) with eltype Float64:
  7.0
 13.0

julia> Diagonal(A)
1×1 Diagonal{Float64, Vector{Float64}}:
 7.0
source
Diagonal(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  ⋅
 ⋅  5
source
Diagonal{T}(undef, n)

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

source
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  4
source
Bidiagonal(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  4
source
LinearAlgebra.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  4
source
SymTridiagonal(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]
source
LinearAlgebra.Tridiagonal — Type
Tridiagonal(dl::V, d::V, du::V) where V <: AbstractVector

第1下対角、第対角、第1上対角から、三重対角行列を構築します。結果はTridiagonal型で、効率的な専用線形ソルバーを利用できます。また、convert(Array, _)(短縮形はArray(_))を使って通常の行列に変換することもできます。dlとduの長さは、dの長さより1短くなければなりません。

Note

下対角のdlと上対角のduは、互いにエイリアスしていてはなりません。エイリアスが検出された場合、コンストラクターは引数としてduのコピーを使用します。

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  0
source
Tridiagonal(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  4
source
LinearAlgebra.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.0

Supper は、A 自体が対称でない限り(たとえば A == transpose(A) の場合)、Slower と等しくならないことに注意してください。

source
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.0im

A 自体がエルミート行列でない限り(たとえば A == adjoint(A) の場合)、Hupper と Hlower は等しくないことに注意してください。

対角成分の虚部はすべて無視されます。

Hermitian(fill(complex(1,1), 1, 1)) == fill(1, 1, 1)
source
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.0
source
LinearAlgebra.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.0
source
LinearAlgebra.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.0
source
LinearAlgebra.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.0
source
LinearAlgebra.UpperHessenberg — Type
UpperHessenberg(A::AbstractMatrix)

行列 A の UpperHessenberg ビューを構築します。最初の副対角線より下にある A の要素は無視されます。

Julia 1.3

この型は Julia 1.3 で追加されました。

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  16
source
LinearAlgebra.UniformScaling — Type
UniformScaling{T<:Number}

スカラーと単位作用素の積として定義される、サイズが汎用的な一様スケーリング作用素 λ*I。明示的な size はありませんが、多くの場合、行列と同様に動作し、一部のインデックス指定をサポートします。I も参照してください。

Julia 1.6

範囲を使ったインデックス指定は Julia 1.6 以降で利用できます。

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.0
source
LinearAlgebra.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+0im
source
LinearAlgebra.UniformScaling — Method
(I::UniformScaling)(n::Integer)

UniformScalingからDiagonal行列を構築します。

Julia 1.2

このメソッドはJulia 1.2以降で利用できます。

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.7
source
LinearAlgebra.LU — Type
LU <: Factorization

正方行列 A の LU 分解の行列分解型です。対応する行列分解関数 lu の戻り値の型です。

分解 F::LU の各成分には、getproperty を使ってアクセスできます。

成分説明
F.LLU の L(単位下三角)部分
F.ULU の 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
true
source
LinearAlgebra.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 の各成分には、インデックス指定でアクセスできます。

成分説明
LLU の L(三角行列)部分
ULU の 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! も参照してください。

Note

lu(A::AbstractSparseMatrixCSC) は、SuiteSparse の一部である UMFPACK[ACM832] ライブラリを使用します。このライブラリがサポートする疎行列の要素型は Float64 または ComplexF64 のみです。そのため、lu は A を、適切な型である SparseMatrixCSC{Float64} または SparseMatrixCSC{ComplexF64} のコピーに変換します。

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

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

check = true の場合、分解に失敗するとエラーがスローされます。check = false の場合、分解が有効かどうか(issuccess を使って)確認する責任はユーザーにあります。

デフォルトでは、check = true の場合、分解によって有効な因子が得られても、上三角因子 U がランク落ちしているとエラーがスローされます。これは allowsingular = true を渡すことで変更できます。

多くの場合、A が、要素型 T を持つ AbstractMatrix{T} のサブタイプ S であり、その要素型が +、-、*、/ をサポートする場合、戻り値の型は LU{T,S{T}} です。

一般に、LU 分解では行列の行を並べ替えます(これは以下で説明する F.p 出力に対応します)。この操作は「ピボット選択」と呼ばれます(F.U の対角要素である「ピボット」を含む行を選ぶことに由来します)。省略可能な pivot 引数で、次のいずれかのピボット選択方式を指定できます。

  • RowMaximum()(デフォルト):標準的なピボット選択方式です。ピボットには、これから分解する残りの行にある要素のうち、絶対値が最大のものを選びます。この方式では、要素型が abs と < もサポートしている必要があります。(浮動小数点行列では、通常、数値的に安定した唯一の選択肢です。)
  • RowNonZero():ピボットには、これから分解する残りの行にある最初の非ゼロ要素を選びます。(手計算で一般的に使われる選び方であり、iszero はサポートするものの、abs や < はサポートしない、より一般的な代数的数の型にも有用です。)
  • NoPivot():ピボット選択を無効にします。ピボット位置の要素がゼロの場合、allowsingular = true であっても失敗します。

分解 F の各成分には、getproperty からアクセスできます。

成分説明
F.LLU の L(下三角)部分
F.ULU の U(上三角)部分
F.p(右)置換 Vector
F.P(右)置換 Matrix

分解を反復すると、成分 F.L、F.U、F.p が順に得られます。

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

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

F は、さらに次の関数をサポートします。

サポートされる関数LULU{T,Tridiagonal{T}}
/✓
\✓✓
inv✓✓
det✓✓
logdet✓✓
logabsdet✓✓
size✓✓
Julia 1.11

allowsingular キーワード引数は Julia 1.11 で追加されました。

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.0
source
LinearAlgebra.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

Note

lu!(F::UmfpackLU, A::AbstractSparseMatrixCSC) は、SuiteSparse に含まれる UMFPACK ライブラリを使用します。このライブラリがサポートする疎行列の要素型は Float64 または ComplexF64 のみであるため、lu! は、LU 分解または SparseMatrixCSC{ComplexF64} で指定された型に自動的に変換されます。

Julia 1.5

lu! の UmfpackLU には、Julia 1.5 以降が必要です。

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.0
source
lu!(F::LU, pivot = RowMaximum(); check = true, allowsingular = false) -> LU

lu!はluと同じですが、コピーを作成せず、入力のFを上書きすることで、メモリを節約します。

Julia 1.13

lu!で密なLU分解を再利用するには、Julia 1.13以降が必要です。

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.0
source
lu!(A, pivot = RowMaximum(); check = true, allowsingular = false) -> LU

lu!はluと同じですが、コピーを作成せず、入力のAを上書きするため、メモリを節約できます。因数分解の結果がAの要素型で表現できない数になる場合(整数型など)、InexactError例外がスローされます。

Julia 1.11

allowsingularキーワード引数はJulia 1.11で追加されました。

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:
[...]
source
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
true
source
LinearAlgebra.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
true
source
LinearAlgebra.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
Note

このメソッドは、SuiteSparse の CHOLMOD[ACM887][DavisHager2009] ライブラリを使用します。CHOLMOD がサポートするのは、単精度または倍精度の実数型および複素数型のみです。これら以外の要素型を持つ入力行列は、適切な型に変換されます。

CHOLMOD のその他の多くの関数もラップされていますが、Base.SparseArrays.CHOLMOD モジュールからはエクスポートされていません。

source
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
true
source
cholesky(A, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted

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

三角コレスキー因子は、分解 F から F.L と F.U を使って取得できます。また、置換は F.p から取得できます。ここで、A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' は Ur = F.U[1:F.rank, :] および Lr = F.L[:, 1:F.rank] を伴う場合と、A ≈ Up' * Up ≈ Lp * Lp' が Up = F.U[1:F.rank, invperm(F.p)] および Lp = F.L[invperm(F.p), 1:F.rank] を伴う場合があります。

CholeskyPivoted オブジェクトでは、次の関数を利用できます: size、\、inv、det、rank。

引数 tol は、ランク判定の許容誤差を指定します。負の値の場合、許容誤差は eps()*size(A,1)*maximum(diag(A)) と等しくなります。

構成時の丸め誤差によりわずかに非エルミートとなっている行列 A を、完全にエルミートな行列として扱うには、cholesky に渡す前に Hermitian(A) でラップしてください。

check = true の場合、分解に失敗するとエラーがスローされます。check = false の場合、分解が有効かどうかの確認(issuccess を使用)はユーザーの責任です。

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
true
source
LinearAlgebra.cholesky! — Function
cholesky!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

A のコレスキー分解($LL'$)を、シンボリック分解 F を再利用して計算します。A は、SparseMatrixCSC の SparseMatrixCSC または Symmetric/Hermitian ビューでなければなりません。A に型タグがない場合は、それ自体が対称行列またはエルミート行列でなければならないことに注意してください。

関連項目: cholesky。

Note

このメソッドは SuiteSparse の CHOLMOD ライブラリを使用します。このライブラリがサポートするのは、単精度または倍精度の実数型および複素数型のみです。入力行列の要素型がこれら以外の場合は、適切な型に変換されます。

source
cholesky!(A::AbstractMatrix, NoPivot(); check = true) -> Cholesky

choleskyと同じですが、コピーを作成せずに入力の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:
[...]
source
cholesky!(A::AbstractMatrix, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted

choleskyと同じですが、コピーを作成せず、入力のAを上書きするため、メモリを節約できます。因数分解の結果がAの要素型で表現できない数値になる場合(整数型の場合など)、InexactError例外がスローされます。

source
LinearAlgebra.lowrankupdate — Function
lowrankupdate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor

LDLt または LLt の A の因数分解 F が与えられたとき、A + C*C' の LDLt 因数分解を取得します。

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

関連項目: lowrankupdate!、lowrankdowndate、lowrankdowndate!。

source
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) 演算しか使いません。

source
LinearAlgebra.lowrankdowndate — Function
lowrankdowndate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor

A + C*C' の A を、LDLt または LLt の因子分解 F から LDLt 因子分解として取得します。

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

関連項目: lowrankdowndate!、lowrankupdate、lowrankupdate!。

source
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) 演算のみを使用します。

source
LinearAlgebra.lowrankupdate! — Function
lowrankupdate!(F::CHOLMOD.Factor, C::AbstractArray)

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

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

関連項目: lowrankupdate、lowrankdowndate、lowrankdowndate!。

source
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 は破棄されます。

source
LinearAlgebra.lowrankdowndate! — Function
lowrankdowndate!(F::CHOLMOD.Factor, C::AbstractArray)

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

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

関連項目: lowrankdowndate、lowrankupdate、lowrankupdate!。

source
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 は破棄されます。

source
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.LLDLt の L(単位下三角)部分
F.DLDLt の D(対角)部分
F.LtLDLt の Lt(単位上三角)部分
F.dD の対角成分を 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.90909
source
LinearAlgebra.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 が正定値である必要があります。

Note

このメソッドは、SuiteSparse の CHOLMOD[ACM887][DavisHager2009] ライブラリを使用します。CHOLMOD が対応しているのは、単精度または倍精度の実数型と複素数型のみです。それ以外の要素型を持つ入力行列は、必要に応じてこれらの型に変換されます。

CHOLMOD の他の多くの関数もラップされていますが、Base.SparseArrays.CHOLMOD モジュールからはエクスポートされていません。

source
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.3488372093023255
source
LinearAlgebra.ldlt! — Function
ldlt!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

F のシンボリック分解を再利用して、A の $LDL'$ 分解を計算します。A は、SparseMatrixCSC の SparseMatrixCSC または Symmetric/Hermitian ビューでなければなりません。A に型タグがない場合、それ自体が対称行列またはエルミート行列でなければならない点に注意してください。

関連項目: ldlt。

Note

このメソッドは SuiteSparse の CHOLMOD ライブラリを使用します。このライブラリがサポートするのは、単精度または倍精度の実数型と複素数型のみです。これら以外の要素型を持つ入力行列は、適宜これらの型に変換されます。

source
ldlt!(S::SymTridiagonal) -> LDLt

ldltと同じですが、コピーを作成せずに入力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.90909
source
LinearAlgebra.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$列です。
  • τは、係数$\tau_i$を含む、長さmin(m,n)のベクトルです。

source
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$ がパック形式で格納されます。
  • T は、上記のとおり $n_b$-by-$\min(m,n)$ 行列です。各三角行列 $T_j$ の対角より下の要素は無視されます。

Note

この形式は、古い WY 表現 [Bischof1987] と混同しないでください。

source
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$列です。
  • τは、係数$au_i$を格納する長さmin(m,n)のベクトルです。

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

source
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] を呼び出します。

Note

返される QRSparse オブジェクトは、ldiv!() 呼び出し用の内部ワークスペースを使用します。このワークスペースはスレッドセーフを確保するため、ロックで保護されています。マルチスレッドで使用する場合は、各タスク用に copy(F) でこのオブジェクトのコピーを個別に作成してください。

Note

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
 2
source
qr(A, pivot = NoPivot(); blocksize) -> F

行列 A の QR 分解を計算します。すなわち、次式を満たす直交行列(A が複素数値の場合はユニタリ行列)Q と上三角行列 R を求めます。

\[A = Q R\]

返されるオブジェクト F は、分解をコンパクトな形式で格納します。

  • pivot == ColumnNorm() の場合、F は QRPivoted オブジェクトです。
  • それ以外で、A の要素型が BLAS 型(Float32、Float64、ComplexF32 または ComplexF64)の場合、F は QRCompactWY オブジェクトです。
  • それ以外の場合、F は QR オブジェクトです。

分解 F の各成分は、プロパティアクセサーで取得できます。

  • F.Q: 直交行列またはユニタリ行列 Q
  • F.R: 上三角行列 R
  • F.p: ピボット選択に伴う置換ベクトル(QRPivoted のみ)
  • F.P: ピボット選択に伴う置換行列(QRPivoted のみ)
Note

F.R を介して上三角因子を参照するたびに、新しい配列が割り当てられます。そのため、たとえば R = F.R でその配列をキャッシュし、以後は R を使って処理することをお勧めします。

分解を反復処理すると、成分 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 を参照してください。

Julia 1.4

キーワード引数 blocksize には Julia 1.4 以降が必要です。

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
true
Note

qr が複数の型を返すのは、LAPACK が Householder 基本鏡映の積に必要な記憶容量を最小限に抑えるため、複数の表現を使用しているためです。これにより、Q と R の行列を、別々の密行列としてではなく、コンパクトに格納できます。

source
LinearAlgebra.qr! — Function
qr!(A, pivot = NoPivot(); blocksize)

qr!は、AがAbstractMatrixのサブタイプである場合、qrと同じですが、コピーを作成せず、入力のAを上書きすることでメモリを節約します。因数分解の結果がAの要素型で表現できない数になる場合(整数型など)、InexactError例外がスローされます。

Julia 1.4

blocksizeキーワード引数を使用するには、Julia 1.4以降が必要です。

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:
[...]
source
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
true
source
LinearAlgebra.lq — Function
lq(A) -> S::LQ

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

分解を反復すると、成分 S.L と S.Q が得られます。

LQ 分解は transpose(A) の QR 分解であり、劣決定系の方程式(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
true
source
LinearAlgebra.lq! — Function
lq!(A) -> LQ

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

source
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
 1
source
LinearAlgebra.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]
true
source
LinearAlgebra.bunchkaufman! — Function
bunchkaufman!(A, rook::Bool=false; check = true) -> BunchKaufman

bunchkaufman! は bunchkaufman と同じですが、コピーを作成せずに入力 A を上書きするため、メモリを節約できます。

source
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
true
source
LinearAlgebra.GeneralizedEigen — Type
GeneralizedEigen <: Factorization

Aと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
true
source
LinearAlgebra.eigvals — Function
eigvals(A; permute::Bool=true, scale::Bool=true, sortby) -> values

A の固有値を返します。

一般の非対称行列では、固有値を計算する前に行列をどのようにバランス調整するかを指定できます。キーワード 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
source

スカラー入力の場合、eigvalsはスカラーを返します。

Examples

julia> eigvals(-2)
-2
source
eigvals(A, B) -> values

A と 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.0im
source
eigvals(A::Union{Hermitian, Symmetric}; alg::Algorithm = default_eigen_alg(A))) -> values

A の固有値を返します。

alg は、固有値分解に使用するアルゴリズムと LAPACK の手法を指定します。

  • alg = DivideAndConquer(): LAPACK.syevd! を呼び出します。
  • alg = QRIteration(): LAPACK.syev! を呼び出します。
  • alg = RobustRepresentations()(デフォルト): 複数の相対的にロバストな表現を用いる手法です。LAPACK.syevr! を呼び出します。

各手法の精度と性能の比較については、James W. Demmel ほか、SIAM J. Sci. Comput. 30, 3, 1508 (2008) を参照してください。

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

Julia 1.12

alg キーワード引数を使用するには、Julia 1.12 以降が必要です。

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

A の固有値を返します。ソートされた固有値のインデックス範囲を指定する 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.140054944640259
source
eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values

Aの固有値を返します。固有値の下限と上限を指定する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.140054944640259
source
LinearAlgebra.eigvals! — Function
eigvals!(A; permute::Bool=true, scale::Bool=true, sortby) -> values

eigvalsと同じですが、コピーを作成せず、入力のAを上書きすることで、メモリを節約します。permute、scale、sortbyの各キーワードは、eigenの場合と同じです。

Note

eigvals!を呼び出すと、入力行列Aには固有値が残りません。ワークスペースとしてAが使用されます。

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.37228
source
eigvals!(A, B; sortby) -> values

eigvalsと同じですが、コピーを作成する代わりに入力のA(およびB)を上書きすることで、メモリを節約します。

Note

eigvals!の呼び出し後、入力行列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.0
source
eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

eigvalsと同じですが、コピーを作成せずに入力のAを上書きするため、メモリを節約できます。irangeは、検索対象となる固有値のインデックスの範囲です。たとえば、2番目から8番目までの固有値を指定します。

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

eigvalsと同じですが、コピーを作成せずに入力Aを上書きするため、メモリを節約できます。vlは固有値を探索する区間の下限、vuは上限です。

source
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:
[...]
source
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:
[...]
source
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.5547001962252291
source
eigvecs(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.0
source
eigvecs(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.0im
source
LinearAlgebra.eigen — Function
eigen(A; permute::Bool=true, scale::Bool=true, sortby) -> Eigen

A の固有値分解を計算し、固有値を 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
true
source
eigen(A, B; sortby) -> GeneralizedEigen

A と 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
true
source
eigen(A::Union{Hermitian, Symmetric}; alg::LinearAlgebra.Algorithm = LinearAlgebra.default_eigen_alg(A)) -> Eigen

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

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

algでは、固有値分解に使用するアルゴリズムとLAPACKの手法を指定します。

  • alg = DivideAndConquer():LAPACK.syevd!を呼び出します。
  • alg = QRIteration():LAPACK.syev!を呼び出します。
  • alg = RobustRepresentations()(デフォルト):多重相対ロバスト表現法。LAPACK.syevr!を呼び出します。

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

今後、使用されるデフォルトのalgが変更される可能性があります。

Julia 1.12

algキーワード引数を使用するには、Julia 1.12以降が必要です。

Eigenオブジェクトでは、次の関数を使用できます:inv、det、isposdef。

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

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

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

Eigen オブジェクトでは、次の関数を使用できます:inv、det、isposdef。

UnitRange irange は、検索対象とするソート済み固有値のインデックスを指定します。

Note

irange が 1:n と等しくない場合(n は A の次元)、返される分解は 切り詰められた 分解になります。

source
eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> Eigen

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

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

Eigen オブジェクトでは、次の関数を使用できます:inv、det、isposdef。

vl は検索対象とする固有値の範囲の下限、vu は上限です。

Note

[vl, vu] に A のすべての固有値が含まれていない場合、返される分解は 切り詰められた 分解になります。

source
LinearAlgebra.eigen! — Function
eigen!(A; permute, scale, sortby)
eigen!(A, B; sortby)

eigenと同じですが、コピーを作成せずに入力A(およびB)を上書きするため、メモリを節約できます。

source
LinearAlgebra.Hessenberg — Type
Hessenberg <: Factorization

Hessenbergオブジェクトは、正方行列のヘッセンベルグ分解QHQ'、またはそのシフトQ(H+μI)Q'を表します。これはhessenberg関数によって生成されます。

source
LinearAlgebra.hessenberg — Function
hessenberg(A) -> Hessenberg

A のヘッセンベルグ分解を計算し、Hessenberg オブジェクトを返します。F が分解オブジェクトの場合、ユニタリ行列は F.Q(型は LinearAlgebra.HessenbergQ)で、ヘッセンベルグ行列は F.H(型は UpperHessenberg)で取得できます。どちらも Matrix(F.H) または Matrix(F.Q) で通常の行列に変換できます。

A が Hermitian または実数型の Symmetric の場合、ヘッセンベルグ分解によって実対称三重対角行列が得られ、F.H の型は SymTridiagonal になります。

シフト付き分解 A+μI = Q (H+μI) Q' は、UniformScaling オブジェクト I を使って F + μ*I で効率よく構築できます。この操作では、ストレージを共有し、シフトを変更した新しい Hessenberg オブジェクトが作成されます。指定した F のシフトは F.μ で取得できます。F を作成しておけば、異なる μ や b(またはその両方)に対する複数のシフト付き求解 (F + μ*I) \ b を効率よく実行できるため、便利です。

分解を反復すると、因子 F.Q, F.H, F.μ が得られます。

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
true
source
LinearAlgebra.hessenberg! — Function
hessenberg!(A) -> Hessenberg

hessenberg!はhessenbergと同じですが、コピーを作成せずに入力Aを上書きするため、容量を節約できます。

source
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
true
source
LinearAlgebra.GeneralizedSchur — Type
GeneralizedSchur <: Factorization

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

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

分解を反復すると、成分 F.S、F.T、F.Q、F.Z、F.α、F.β が得られます。

source
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
true
source
schur(A, B) -> F::GeneralizedSchur

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

分解を反復すると、成分 F.S、F.T、F.Q、F.Z、F.α、および F.β が得られます。

source
LinearAlgebra.schur! — Function
schur!(A) -> F::Schur

schurと同じですが、入力引数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.0
source
schur!(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur

schurと同じですが、入力行列AおよびBをワークスペースとして使用します。

source
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 によって必ず両方とも選択するか、両方とも選択しないようにしてください。

source
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.β で求められます。

source
LinearAlgebra.ordschur! — Function
ordschur!(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur

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

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

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

source
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
true
source
LinearAlgebra.GeneralizedSVD — Type
GeneralizedSVD <: Factorization

2つの行列 A と B の一般化特異値分解(SVD)を表す行列因子分解型です。A = F.U*F.D1*F.R0*F.Q' と B = F.V*F.D2*F.R0*F.Q' を満たします。これは、対応する行列因子分解関数 svd(_, _) の戻り値の型です。

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

  • U は M×M の直交行列です。
  • V は P×P の直交行列です。
  • Q は N×N の直交行列です。
  • D1 は 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.0
source
LinearAlgebra.svd — Function
svd(A; full::Bool = false, alg::Algorithm = default_svd_alg(A), atol::Real=0, rtol::Real=0) -> SVD

A の特異値分解(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 の最大特異値です。

Julia 1.3

alg キーワード引数を使用するには、Julia 1.3 以降が必要です。

Julia 1.13

atol 引数と rtol 引数を使用するには、Julia 1.13 以降が必要です。

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
true
source
svd(A, B) -> GeneralizedSVD

A と 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
true
source
LinearAlgebra.svd! — Function
svd!(A; full::Bool = false, alg::Algorithm = default_svd_alg(A), atol::Real=0, rtol::Real=0) -> SVD

svd!はsvdと同じですが、コピーを作成せずに入力のAを上書きするため、メモリを節約できます。詳細については、svdのドキュメントを参照してください。

source
svd!(A, B) -> GeneralizedSVD

svd!はsvdと同じですが、コピーを作成するのではなく、引数AとBをその場で変更します。詳細はsvdのドキュメントを参照してください。

source
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.0
source
svdvals(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.0
source
LinearAlgebra.svdvals! — Function
svdvals!(A)

入力を上書きして領域を節約しながら、A の特異値を返します。svdvals と svd も参照してください。

source
svdvals!(A, B)

A と B の一般化特異値分解から一般化特異値を返します。領域を節約するため、A と B を上書きします。svd および svdvals も参照してください。

source
LinearAlgebra.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。

source
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] = 0

LinearAlgebra.Givens も参照してください。

source
givens(A::AbstractArray, i1::Integer, i2::Integer, j::Integer) -> (G::Givens, r)

ギブンス回転 G とスカラー r を計算します。これらは、次の積の結果が

B = G*A

次の性質を満たすように選ばれます。

B[i1,j] = r
B[i2,j] = 0

LinearAlgebra.Givens も参照してください。

source
givens(x::AbstractVector, i1::Integer, i2::Integer) -> (G::Givens, r)

積の結果が次の性質を満たすような、ギブンス回転 G とスカラー r を計算します。

B = G*x

つまり、

B[i1] = r
B[i2] = 0

関連項目: LinearAlgebra.Givens。

source
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.0
source
LinearAlgebra.triu! — Function
triu!(M)

行列の上三角部分を取り出し、その過程でMを上書きします。triuも参照してください。

source
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  0
source
LinearAlgebra.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.0
source
LinearAlgebra.tril! — Function
tril!(M)

行列の下三角部分。処理中にMを上書きします。trilも参照してください。

source
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  5
source
LinearAlgebra.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(主対角線に対応)とみなされます。

関連項目: diag、diagm、Diagonal。

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)
Julia 1.11

IndexStyle を指定するには、Julia 1.11 以降が必要です。

source
LinearAlgebra.diag — Function
diag(M, k::Integer=0)

行列のk番目の対角成分をベクトルとして取得します。

関連項目: diagm、diagind、Diagonal、isdiag。

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> diag(A,1)
2-element Vector{Int64}:
 2
 6
source
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  0
source
diagm(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  0
source
LinearAlgebra.rank — Function
rank(::QRSparse{Tv,Ti}) -> Ti

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

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

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

source
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です。

Note

数値ランクは、特異値が許容誤差のしきい値max(atol, rtol*σ₁)に近い、悪条件の行列を評価する際に、結果が不安定で精度に欠けることがあります。このような場合、特異値の計算や行列にわずかな摂動が加わるだけで、1つ以上の特異値がしきい値をまたぎ、rankの結果が変わることがあります。こうした差異は、Juliaのバージョン、アーキテクチャ、コンパイラ、オペレーティングシステムの違いによる浮動小数点誤差の変化によっても生じることがあります。

Julia 1.1

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)
1
source
rank(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 です。

Julia 1.12

rank(::SVD) メソッドの使用には、Julia 1.12 以降が必要です。

source
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 です。

Julia 1.12

rank(::QRPivoted) メソッドを使用するには、Julia 1.12 以降が必要です。

source
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)
true
source
norm(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.0
source
LinearAlgebra.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.0
source
opnorm(x::Number, p::Real=2)

数値の場合は、$\left( |x|^p \right)^{1/p}$を返します。これはnormと同等です。

source
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.0
source
LinearAlgebra.normalize! — Function
normalize!(a::AbstractArray, p::Real=2)

配列 a をインプレースで正規化し、その p ノルムを 1 にします。つまり、norm(a, p) == 1 です。normalize と norm も参照してください。

source
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)
NaN
source
LinearAlgebra.cond — Function
cond(M, p::Real=2)

行列 M の条件数。演算子 p ノルムを使って計算します。p に指定できる値は、1、2(デフォルト)、または Inf です。

source
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 条件数、相対条件数、または成分ごとの相対条件数とも呼ばれます。

source
LinearAlgebra.tr — Function
tr(M)

行列のトレース。Mの対角要素の和を求めます。

Examples

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

julia> tr(A)
5
source
LinearAlgebra.det — Function
det(M)

行列式。

関連項目: logdet および logabsdet。

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
2
source
LinearAlgebra.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.0
source
LinearAlgebra.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)
source
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)
true
source
LinearAlgebra.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 を返します。

Julia 1.13

SVD オブジェクトを pinv に渡すには、Julia 1.13 以降が必要です。

詳細については、[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.0
source
LinearAlgebra.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.0

M の零空間の基底を計算します。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.0
source
Base.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  10
source
Base.kron! — Function
kron!(C, A, B)

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

Julia 1.6

この関数を使用するには、Julia 1.6 以降が必要です。

source
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.71828
source
Base.cis — Method
cis(A::AbstractMatrix)

正方行列 A の exp(im*A) を求めるための、より効率的なメソッドです(特に A が Hermitian または実数の Symmetric である場合)。

cispi、sincos、exp も参照してください。

Julia 1.7

行列に対する cis のサポートは Julia 1.7 で追加されました。

Examples

julia> cis([π 0; 0 π]) ≈ -I
true
source
Base.:^ — Method
^(A::AbstractMatrix, p::Number)

行列のべき乗。$\exp(p\log(A))$と等価です。

Examples

julia> [1 2; 0 3]^3
2×2 Matrix{Int64}:
 1  26
 0  27
source
Base.:^ — Method
^(b::Number, A::AbstractMatrix)

行列指数関数。$\exp(\log(b)A)$と等価です。

Julia 1.1

Irrationalの数値(ℯなど)を行列に累乗する機能は、Julia 1.1で追加されました。

Examples

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

julia> ℯ^[1 2; 0 3]
2×2 Matrix{Float64}:
 2.71828  17.3673
 0.0      20.0855
source
Base.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.0
source
Base.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.0
source
Base.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
true
source
Base.cos — Method
cos(A::AbstractMatrix)

正方行列 A の行列余弦を計算します。

A が実対称行列またはエルミート行列の場合は、その固有値分解(eigen)を使って余弦を計算します。それ以外の場合は、exp を呼び出して余弦を求めます。

Examples

julia> cos(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927
source
Base.sin — Method
sin(A::AbstractMatrix)

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

A が実対称行列またはエルミート行列の場合は、その固有分解(eigen)を使って正弦を計算します。それ以外の場合は、exp を呼び出して正弦を求めます。

Examples

julia> sin(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 0.454649  0.454649
 0.454649  0.454649
source
Base.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.291927
source
Base.tan — Method
tan(A::AbstractMatrix)

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

A が実対称行列またはエルミート行列の場合は、その固有分解(eigen)を使って正接を計算します。それ以外の場合は、exp を呼び出して正接を求めます。

Examples

julia> tan(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 -1.09252  -1.09252
 -1.09252  -1.09252
source
Base.Math.sec — Method
sec(A::AbstractMatrix)

正方行列 A の行列正割を計算します。

source
Base.Math.csc — Method
csc(A::AbstractMatrix)

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

source
Base.Math.cot — Method
cot(A::AbstractMatrix)

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

source
Base.cosh — Method
cosh(A::AbstractMatrix)

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

source
Base.sinh — Method
sinh(A::AbstractMatrix)

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

source
Base.tanh — Method
tanh(A::AbstractMatrix)

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

source
Base.Math.sech — Method
sech(A::AbstractMatrix)

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

source
Base.Math.csch — Method
csch(A::AbstractMatrix)

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

source
Base.Math.coth — Method
coth(A::AbstractMatrix)

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

source
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-16im
source
Base.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-16im
source
Base.atan — Method
atan(A::AbstractMatrix)

正方行列 A の逆正接行列を計算します。

A が実対称行列またはエルミート行列の場合、逆正接の計算には固有値分解(eigen)を使用します。それ以外の場合は、log を使用して逆正接を求めます。この関数の計算に用いる理論と対数公式については、[AH16_3] を参照してください。

Examples

julia> atan(tan([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5  0.1
 -0.2  0.3
source
Base.Math.acsc — Method
acsc(A::AbstractMatrix)

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

source
Base.acosh — Method
acosh(A::AbstractMatrix)

正方行列 A の逆双曲線行列余弦を計算します。この関数の計算に用いる理論と対数公式については、[AH16_4] を参照してください。

source
Base.asinh — Method
asinh(A::AbstractMatrix)

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

source
Base.atanh — Method
atanh(A::AbstractMatrix)

正方行列 A の逆双曲線正接を計算します。この関数の計算に用いる理論と対数公式については、[AH16_6] を参照してください。

source
Base.Math.acsch — Method
acsch(A::AbstractMatrix)

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

source
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
true
source
LinearAlgebra.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
true
source
LinearAlgebra.issuccess — Function
issuccess(F::Factorization)

行列の因子分解が成功したことを確認します。

Julia 1.6

issuccess(::CholeskyPivoted) は Julia 1.6 以降が必要です。

Examples

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

julia> issuccess(F)
true
source
issuccess(F::LU; allowsingular = false)

行列の LU 分解が成功したかどうかをテストします。デフォルトでは、有効ではあるものの階数落ちした U 因子を生成する分解は失敗とみなされます。これは allowsingular = true を渡すことで変更できます。

Julia 1.11

allowsingular キーワード引数は Julia 1.11 で追加されました。

Examples

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

julia> issuccess(F)
false

julia> issuccess(F, allowsingular = true)
true
source
LinearAlgebra.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)
false
source
LinearAlgebra.isposdef — Function
isposdef(A) -> Bool

Aのコレスキー分解を試みて、行列が正定値(かつエルミート)かどうかを判定します。

関連項目:isposdef!、cholesky。

Examples

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

julia> isposdef(A)
true
source
LinearAlgebra.isposdef! — Function
isposdef!(A) -> Bool

A のコレスキー分解を試みることで、行列が正定値(かつエルミート)かどうかを判定します。その際、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.78233
source
LinearAlgebra.istril — Function
istril(A::AbstractMatrix, k::Integer = 0) -> Bool

Aが、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)
true
source
LinearAlgebra.istriu — Function
istriu(A::AbstractMatrix, k::Integer = 0) -> Bool

Aが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)
true
source
LinearAlgebra.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)
false
source
LinearAlgebra.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)
true
source
Base.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))
true

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

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

julia> transpose(v) # returns a row-vector
1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> transpose(v) * v # compute the dot product
14

行列の行列の場合、各ブロックに対して再帰的に操作が行われます。

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

julia> D = reshape([C, 2C, 3C, 4C], 2, 2) # construct a block matrix
2×2 Matrix{Matrix{Int64}}:
 [1 3; 2 4]  [3 9; 6 12]
 [2 6; 4 8]  [4 12; 8 16]

julia> transpose(D) # blocks are recursively transposed
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 2; 3 4]   [2 4; 6 8]
 [3 6; 9 12]  [4 8; 12 16]
source
transpose(F::Factorization)

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

source
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+6im
source
transpose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

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

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

source
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  0
source
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)
true

AbstractVector の随伴は行ベクトルです。

julia> x = [3, 4im]
2-element Vector{Complex{Int64}}:
 3 + 0im
 0 + 4im

julia> x'
1×2 adjoint(::Vector{Complex{Int64}}) with eltype Complex{Int64}:
 3+0im  0-4im

julia> x'x # compute the dot product, equivalently x' * x
25 + 0im

行列の行列の場合、各ブロックに対して再帰的に演算が適用されます。

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

julia> C = reshape([A, 2A, 3A, 4A], 2, 2)
2×2 Matrix{Matrix{Complex{Int64}}}:
 [1+1im 3+3im; 2+2im 4+4im]  [3+3im 9+9im; 6+6im 12+12im]
 [2+2im 6+6im; 4+4im 8+8im]  [4+4im 12+12im; 8+8im 16+16im]

julia> C'
2×2 adjoint(::Matrix{Matrix{Complex{Int64}}}) with eltype Adjoint{Complex{Int64}, Matrix{Complex{Int64}}}:
 [1-1im 2-2im; 3-3im 4-4im]    [2-2im 4-4im; 6-6im 8-8im]
 [3-3im 6-6im; 9-9im 12-12im]  [4-4im 8-8im; 12-12im 16-16im]
source
adjoint(F::Factorization)

因子分解 F の遅延随伴。デフォルトでは、AdjointFactorization ラッパーを返します。

source
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+6im
source
adjoint!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

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

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

source
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+0im
source
LinearAlgebra.AdjointFactorization — Type
AdjointFactorization

基になるFactorizationオブジェクトの随伴を表す遅延ラッパー型です。通常、AdjointFactorizationコンストラクターを直接呼び出すべきではありません。代わりにadjoint(:: Factorization)を使用してください。

source
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+0im
source
LinearAlgebra.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)
2
source
LinearAlgebra.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
 5
source
LinearAlgebra.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は、各プロセッサーで解く問題のサイズを表します。

Julia 1.1

この関数を使用するには、Julia 1.1以降が必要です。Julia 1.0では、標準ライブラリInteractiveUtilsから利用できます。

source
LinearAlgebra.hermitianpart — Function
hermitianpart(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

正方行列 A のエルミート部分を、(A + A') / 2 として定義し、Hermitian 行列として返します。実行列 A の場合、これは A の対称部分とも呼ばれます。また、「作用素の実部」と呼ばれることもあります。省略可能な引数 uplo は、Hermitian ビューの対応する引数を制御します。実行列の場合、後者は Symmetric ビューと同等です。

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

Julia 1.10

この関数を使用するには、Julia 1.10 以降が必要です。

source
LinearAlgebra.hermitianpart! — Function
hermitianpart!(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

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

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

Julia 1.10

この関数を使用するには、Julia 1.10 以降が必要です。

source
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) を満たす必要があります。

source
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) を満たす必要があります。

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

source
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)
:L
source
LinearAlgebra.uplo(S::Bidiagonal)::Symbol

上側(:U)または下側(:L)のどちらの非対角帯が格納されているかに応じて、Symbolを返します。

source

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
true

Implementation

独自の行列型やベクトル型では、可能であれば3引数の mul! を直接実装するのではなく、5引数の mul! を実装することを推奨します。

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

行列と行列、または行列とベクトルの積和演算をインプレースで行います $A B α + C β$。結果は C に上書きして格納されます。C は A または B とエイリアスになっていてはならない点に注意してください。

Julia 1.3

5 引数の mul! を使用するには、Julia 1.3 以降が必要です。

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 * β
true
source
mul!(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! ではなく、このメソッドシグネチャをオーバーロードすることを推奨します。

Julia 1.13

このメソッドの使用には Julia 1.13 以降が必要です。また、同じシグネチャを持つ非公開の generic_matvecmul! メソッドに代わるものです。

source
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! ではなく、このメソッドをオーバーロードすることを推奨します。

Julia 1.13

このメソッドには Julia 1.13 以降が必要で、同じシグネチャを持つ非公開の generic_matmatmul! メソッドに代わるものです。

source
LinearAlgebra.lmul! — Function
lmul!(a::Number, B::AbstractArray)

配列 B をスカラー a でスケーリングし、B をインプレースで上書きします。スカラーを右から乗算するには rmul! を使用します。このスケーリング操作は、a と B の要素との乗算 * のセマンティクスに従います。特に、NaN や ±Inf などの非有限数を含む乗算にも適用されます。

Julia 1.1

Julia 1.1 より前は、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}:
 NaN
source
lmul!(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.0
source
LinearAlgebra.rmul! — Function
rmul!(A::AbstractArray, b::Number)

配列 A の各要素にスカラー b を乗算し、A をインプレースで上書きします。スカラーを左から乗算するには lmul! を使用します。このスケーリング操作は、A の要素と b の間の乗算 * のセマンティクスに従います。特に、NaN や ±Inf などの非有限数を含む乗算にも適用されます。

Julia 1.1

Julia 1.1 より前のバージョンでは、A 内の 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}:
 NaN
source
rmul!(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.0
source
LinearAlgebra.ldiv! — Function
ldiv!(Y, A, B) -> Y

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

引数Aには、行列を指定しないでください。行列ではなく、factorizeやcholeskyなどで生成した因子分解オブジェクトを指定してください。因子分解自体はコストが高く、通常はメモリを割り当てるためです(lu!などを使ってインプレースで行うこともできます)。また、ldiv!が必要となるパフォーマンス重視の状況では、通常、Aの因子分解を細かく制御する必要もあります。

Note

DiagonalやUpperTriangularなど、すでに因子分解された形式になっている一部の構造化行列型は使用できます。

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
true
source
ldiv!(A, B)

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

引数 A は行列ではなく、因子分解オブジェクト(たとえば factorize または cholesky で生成されるもの)である必要があります。因子分解自体はコストが高く、通常はメモリを割り当てるためです(ただし、たとえば lu! を使ってインプレースで行うこともできます)。また、ldiv! が必要となるようなパフォーマンス重視の状況では、通常、A の因子分解を細かく制御する必要もあります。

Note

Diagonal や UpperTriangular など、すでに因子分解された形式になっている一部の構造化行列型は使用できます。

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
true
source
ldiv!(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.0
source
ldiv!(A::Tridiagonal, B::AbstractVecOrMat) -> B

A \ Bを部分ピボット選択付きガウス消去法でインプレースに計算し、結果をBに格納して返します。この処理では、Aの対角成分も上書きされます。

Julia 1.11

左辺がTridiagonalである場合のldiv!には、Julia 1.11以降が必要です。

source
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 です。

Julia 1.13

atol 引数と rtol 引数には、Julia 1.13 以降が必要です。

source
LinearAlgebra.rdiv! — Function
rdiv!(A, B)

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

引数Bには、行列を指定しないでください。行列ではなく、factorizeやcholeskyなどで生成される因子分解オブジェクトを指定します。因子分解自体はコストが高く、通常はメモリを割り当てるためです(lu!などを使ってインプレースで行うこともできます)。また、rdiv!が必要となるパフォーマンス重視の状況では、通常、Bの因子分解を細かく制御する必要もあります。

Note

DiagonalやUpperTriangularなどの一部の構造化行列型は、すでに因子分解された形式であるため使用できます。

source
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.0
source

BLAS 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.set_num_threads — Function
set_num_threads(n::Integer)
set_num_threads(::Nothing)

BLASライブラリが使用するスレッド数をn::Integerに設定します。

nothingも指定できます。この場合、juliaはデフォルトのスレッド数を推測しようとします。nothingを渡すことは推奨されません。主に歴史的な理由で残されています。

Note

Apple Accelerateなど、一部のBLASライブラリは、使用するスレッド数を固定するよう設定できません。これらのバックエンドでは、set_num_threads()は何も行いません。get_num_threadsも参照してください。

source
LinearAlgebra.BLAS.get_num_threads — Function
get_num_threads()

BLASライブラリが使用しているスレッド数を取得します。

Julia 1.6

get_num_threadsにはJulia 1.6以降が必要です。

Note

Apple Accelerateなど、一部のBLASライブラリでは、使用するスレッド数を固定できません。これらのバックエンドでは、get_num_threads()は常に1を返します。set_num_threadsも参照してください。

source

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 を返します。

Julia 1.5

rot! には Julia 1.5 以降が必要です。

source
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) が使用されます。

source
LinearAlgebra.BLAS.scal — Function
scal(n, a, X, incx)
scal(a, X)

配列 X の先頭 n 個の要素を、ストライド incx で a 倍し、X を返します。

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

source
LinearAlgebra.BLAS.blascopy! — Function
blascopy!(n, X, incx, Y, incy)

配列 X の要素を incx 個おきに n 個コピーし、配列 Y に incy 個おきに格納します。Y を返します。

source
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.0
source
LinearAlgebra.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.0im
source
LinearAlgebra.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.0im
source
LinearAlgebra.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.0
source
LinearAlgebra.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.0
source
LinearAlgebra.BLAS.iamax — Function
iamax(n, dx, incx)
iamax(dx)

dx の要素のうち、絶対値が最大の要素のインデックスを求めます。n は dx の長さ、incx はストライドです。n と incx が指定されていない場合、それぞれのデフォルト値は n=length(dx) と incx=stride1(dx) です。

source

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 を返します。

source
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を返します。

source
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はスカラーです。

source
LinearAlgebra.BLAS.hemv! — Function
hemv!(ul, alpha, A, x, beta, y)

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

source
LinearAlgebra.BLAS.hemv — Method
hemv(ul, alpha, A, x)

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

source
LinearAlgebra.BLAS.hemv — Method
hemv(ul, A, x)

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

source
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 を返します。

Julia 1.5

hpmv! は Julia 1.5 以降で利用できます。

source
LinearAlgebra.BLAS.symv! — Function
symv!(ul, alpha, A, x, beta, y)

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

source
LinearAlgebra.BLAS.symv — Method
symv(ul, alpha, A, x)

alpha*A*xを返します。Aは対称であると仮定します。Aのうち、ulの三角部分のみを使用します。alphaはスカラーです。

source
LinearAlgebra.BLAS.symv — Method
symv(ul, A, x)

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

source
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 を返します。

source
LinearAlgebra.BLAS.sbmv — Method
sbmv(uplo, k, alpha, A, x)

A は、size(A,2) 次の対称帯行列です。k 本の上対角線は、引数 A に格納されています。A の uplo 三角部分のみが使用されます。alpha*A*x

source
LinearAlgebra.BLAS.sbmv — Method
sbmv(uplo, k, A, x)

A が次数 size(A,2) の対称帯行列で、k 本の上側対角線が引数 A に格納されている場合、A*x を返します。A のうち、uplo 三角部分のみが使用されます。

source
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 を返します。

Julia 1.5

spmv! には Julia 1.5 以降が必要です。

source
LinearAlgebra.BLAS.trmv! — Function
trmv!(ul, tA, dA, A, b)

op(A)*bを返します。opはtAによって決まります。Aのul三角部分のみが使用されます。対角要素の値を読み取るか、すべて1とみなすかはdAによって決まります。乗算はb上でインプレースに行われます。

source
LinearAlgebra.BLAS.trmv — Function
trmv(ul, tA, dA, A, b)

op(A)*bを返します。opはtAによって決まります。ulの三角部分のみがAに使用されます。dAによって、対角要素の値を読み取るか、すべて1とみなすかが決まります。

source
LinearAlgebra.BLAS.trsv! — Function
trsv!(ul, tA, dA, A, b)

b を、A*x = b の解、または tA と ul によって決まる他の2つのバリエーションのいずれかで上書きしてください。対角成分の値を読み込むか、すべて1とみなすかは、dA によって決まります。更新後の b を返してください。

source
LinearAlgebra.BLAS.trsv — Function
trsv(ul, tA, dA, A, b)

A*x = bの解、またはtAとulによって決まる他の2つのバリアントのいずれかを返します。対角成分を読み込むか、すべて1とみなすかはdAによって決まります。

source

行列を返す

LinearAlgebra.BLAS.ger! — Function
ger!(alpha, x, y, A)

行列 A をベクトル x および y で alpha*x*y' + A としてランク1更新します。

source
LinearAlgebra.BLAS.geru! — Function
geru!(alpha, x, y, A)

行列 A をベクトル x および y によって alpha*x*transpose(y) + A としてランク1更新します。

source
LinearAlgebra.BLAS.her! — Function
her!(uplo, alpha, x, A)

複素数配列専用のメソッドです。ベクトル x を用いて、エルミート行列 A を alpha*x*x' + A としてランク1更新します。uplo によって、A のどちらの三角部分を更新するかが決まります。A を返します。

source
LinearAlgebra.BLAS.syr! — Function
syr!(uplo, alpha, x, A)

対称行列 A をベクトル x で alpha*x*transpose(x) + A としてランク1更新します。uplo は、A のどちらの三角部分を更新するかを指定します。A を返します。

source
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 を返します。

Julia 1.8

spr! の使用には Julia 1.8 以降が必要です。

source

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を返します。

Julia 1.11

gemmt!にはJulia 1.11以降が必要です。

source
LinearAlgebra.BLAS.gemmt — Method
gemmt(uplo, tA, tB, alpha, A, B)

uploで指定されたA*Bの下三角部分または上三角部分を返します。ほかの3つのバリアントについても、tAとtBに従って返します。

Julia 1.11

gemmtを使用するには、Julia 1.11以降が必要です。

source
LinearAlgebra.BLAS.gemmt — Method
gemmt(uplo, tA, tB, A, B)

uploで指定されたA*Bの下三角部分または上三角部分を返します。ほかの3つのバリエーションについては、tAとtBに従います。

Julia 1.11

gemmtにはJulia 1.11以降が必要です。

source
LinearAlgebra.BLAS.gemm! — Function
gemm!(tA, tB, alpha, A, B, beta, C)

tAおよびtBに従って、Cをalpha*A*B + beta*Cまたはその他3つのバリエーションに更新してください。更新後のCを返してください。

source
LinearAlgebra.BLAS.gemm — Method
gemm(tA, tB, alpha, A, B)

tA と tB に応じて、alpha*A*B または残りの3つのバリエーションを返します。

source
LinearAlgebra.BLAS.gemm — Method
gemm(tA, tB, A, B)

A*B、またはtAとtBに応じて、残り3つのバリアントのいずれかを返します。

source
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を返します。

source
LinearAlgebra.BLAS.symm — Method
symm(side, ul, alpha, A, B)

alpha*A*B または alpha*B*A を、side に応じて返します。A は対称であると仮定します。A のうち、ul 三角形のみを使用します。

source
LinearAlgebra.BLAS.symm — Method
symm(side, ul, A, B)

sideに応じて、A*BまたはB*Aを返します。Aは対称であると仮定します。Aのうち、ul三角部分のみを使用します。

source
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を返します。

source
LinearAlgebra.BLAS.hemm — Method
hemm(side, ul, alpha, A, B)

sideに応じて、alpha*A*Bまたはalpha*B*Aを返します。Aはエルミート行列であると仮定されます。Aのうち、使用されるのはul三角部分のみです。

source
LinearAlgebra.BLAS.hemm — Method
hemm(side, ul, A, B)

sideに応じて、A*BまたはB*Aを返します。Aはエルミート行列であると仮定されます。Aのうち、使用されるのはul三角部分のみです。

source
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を返します。

source
LinearAlgebra.BLAS.syrk — Function
syrk(uplo, trans, alpha, A)

A の上三角部分または下三角部分を返します。どちらを返すかは uplo に従い、対象は alpha*A*transpose(A) または alpha*transpose(A)*A のいずれかです。どちらを対象とするかは trans に従います。

source
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を返します。

source
LinearAlgebra.BLAS.herk — Function
herk(uplo, trans, alpha, A)

複素数配列に対するメソッドのみです。transに応じて、alpha*A*A'またはalpha*A'*Aのuplo三角部分を返します。

source
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を返します。

source
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三角行列を返します。

source
syr2k(uplo, trans, A, B)

transに応じて、A*transpose(B) + B*transpose(A)またはtranspose(A)*B + transpose(B)*Aのuplo三角形を返します。

source
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 を返します。

source
LinearAlgebra.BLAS.her2k — Function
her2k(uplo, trans, alpha, A, B)

uplo の三角形を、trans に応じて alpha*A*B' + alpha'*B*A' または alpha*A'*B + alpha'*B'*A で返します。

source
her2k(uplo, trans, A, B)

uplo の三角形を、trans に従って A*B' + B*A' または A'*B + B'*A で返します。

source
LinearAlgebra.BLAS.trmm! — Function
trmm!(side, ul, tA, dA, alpha, A, B)

B を alpha*A*B、または side と tA によって決まる他の 3 つのバリアントのいずれかとして更新します。A のうち、使用されるのは ul の三角部分だけです。対角成分の値を読み取るか、すべて 1 とみなすかは dA によって決まります。更新後の B を返します。

source
LinearAlgebra.BLAS.trmm — Function
trmm(side, ul, tA, dA, alpha, A, B)

alpha*A*B、またはsideとtAによって決まる、ほかの3つのバリアントのいずれかを返します。Aのうち、ulの三角部分だけが使用されます。対角成分の値を読み取るか、すべて1とみなすかは、dAによって決まります。

source
LinearAlgebra.BLAS.trsm! — Function
trsm!(side, ul, tA, dA, alpha, A, B)

B を、A*X = alpha*B の解、または side と tA によって決まる他の 3 つのバリアントのいずれかで上書きします。A のうち、ul の三角部分のみが使用されます。対角要素の値を読み込むか、すべて 1 とみなすかは dA によって決まります。更新後の B を返します。

source
LinearAlgebra.BLAS.trsm — Function
trsm(side, ul, tA, dA, alpha, A, B)

A*X = alpha*Bの解、またはsideとtAによって決まる他の3つのバリアントのいずれかを返します。Aのul三角部分のみが使用されます。対角要素の値を読み込むか、すべて1とみなすかはdAによって決まります。

source

LAPACK functions

LinearAlgebra.LAPACK は、線形代数用の LAPACK 関数の一部をラップして提供します。入力配列のいずれかを上書きする関数の名前は、'!' で終わります。

通常、関数には Float64、Float32、ComplexF64、ComplexF32 の各配列に対応する 4 つのメソッドが定義されています。

Julia が提供する LAPACK API は、今後変更される可能性があり、実際に変更されることもあります。この API はユーザー向けではないため、今後のリリースでこの特定の関数群をサポートまたは非推奨化することは保証されません。

LinearAlgebra.LAPACK.gbtrf! — Function
gbtrf!(kl, ku, m, AB) -> (AB, ipiv)

帯行列 AB の LU 分解を計算します。kl は非ゼロ要素を含む最初の劣対角線、ku は非ゼロ要素を含む最後の上対角線、m は行列 AB の第 1 次元です。LU 分解はインプレースで返され、使用されたピボットを格納するベクトル ipiv も返されます。

source
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 をインプレースで上書きします。

source
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 には、実行されたスケーリング/置換に関する情報が含まれます。

source
LinearAlgebra.LAPACK.gebak! — Function
gebak!(job, side, ilo, ihi, scale, V)

gebal! を使ってバランス調整した行列の固有ベクトル V を、元の行列のスケーリングおよび並べ替え前の固有ベクトルに変換します。V をインプレースで変更します。side には L(左固有ベクトルを変換)または R(右固有ベクトルを変換)を指定できます。

source
LinearAlgebra.LAPACK.gebrd! — Function
gebrd!(A) -> (A, d, e, tauq, taup)

Aをその場で二重対角形A = QBP'に変換します。戻り値は、二重対角行列Bを格納するA、Bの対角要素を格納するd、Bの非対角要素を格納するe、Qを表す基本反射子を格納するtauq、およびPを表す基本反射子を格納するtaupです。

source
LinearAlgebra.LAPACK.gelqf! — Function
gelqf!(A, tau)

A の A = LQ に対する LQ 分解を計算します。tau には、この分解の基本反射をパラメーター化するスカラーが格納されます。tau の長さは、A の最小次元以上でなければなりません。

A と tau をインプレースで変更して返します。

source
gelqf!(A) -> (A, tau)

LQ 因子分解を A に計算します。A = LQ

変更された A と、因子分解の基本反射子をパラメーター化するスカラーを格納した tau を返します。

source
LinearAlgebra.LAPACK.geqlf! — Function
geqlf!(A, tau)

QL の A, A = QL 分解を計算します。tau には、この分解の基本反射子をパラメーター化するスカラーが格納されています。tau の長さは、A の最小次元以上でなければなりません。

A と tau をインプレースで変更して返します。

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

QL の A 因子分解を計算します。A = QL

インプレースで変更された A と、因子分解の基本反射子をパラメーター化するスカラーを格納した tau を返します。

source
LinearAlgebra.LAPACK.geqrf! — Function
geqrf!(A, tau)

A の QR 分解を計算します。A = QR。tau には、分解の基本反射子をパラメーター化するスカラーが格納されます。tau の長さは、A の最小次元以上でなければなりません。

A と tau をインプレースで変更して返します。

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

A の A = QR 因子分解を計算します(QR)。

インプレースで変更された A と、因子分解の基本反射子をパラメーター化するスカラーを格納した tau を返します。

source
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 はその場で変更されます。

source
LinearAlgebra.LAPACK.gerqf! — Function
gerqf!(A, tau)

A の A = RQ に対する RQ 分解を計算します。tau には、この分解の基本反射子をパラメーター化するスカラーが格納されます。tau の長さは、A の最小次元以上でなければなりません。

A と tau をインプレースで変更して返します。

source
gerqf!(A) -> (A, tau)

A、A = RQのRQ分解を計算します。

インプレースで変更されたAと、分解の基本反射子をパラメーター化するスカラーを格納したtauを返します。

source
LinearAlgebra.LAPACK.geqrt! — Function
geqrt!(A, T)

QR のブロック化された A の因子分解を、A = QR を用いて計算します。T には、因子分解の基本反射子をパラメーター化する上三角ブロック反射子が格納されます。T の第1次元はブロックサイズを指定し、1 以上 n 以下でなければなりません。T の第2次元は、A の最小次元と等しくなければなりません。

A と T をインプレースで変更して返します。

source
geqrt!(A, nb) -> (A, T)

A、A = QRのブロック化QR分解を計算します。nbはブロックサイズを指定します。ブロックサイズは1以上、Aの第2次元であるn以下でなければなりません。

インプレースで変更されたAと、分解の基本反射子をパラメーター化する上三角ブロック反射子を格納するTを返します。

source
LinearAlgebra.LAPACK.geqrt3! — Function
geqrt3!(A, T)

A の A = QR に対するブロック化 QR 分解を再帰的に計算します。T には、分解の基本反射をパラメーター化する上三角ブロック反射子が格納されます。T の第 1 次元でブロックサイズを指定します。これは 1 以上 n 以下でなければなりません。T の第 2 次元は、A の最小次元と等しくなければなりません。

A と T をインプレースで変更して返します。

source
geqrt3!(A) -> (A, T)

A のブロック化された QR 分解を、A = QR に対して再帰的に計算します。

インプレースで変更された A と、分解の基本反射子をパラメーター化する上三角ブロック反射子を格納した T を返します。

source
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)が格納されます。

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

A のピボット付き LU 分解を計算します(A = LU)。

インプレースで変更された A、ピボット情報である ipiv、および成功を示す info(info = 0)、U 内の特異値(この場合、U[i,i] は特異です。info = i)、またはエラーコード(info < 0)を返します。

source
LinearAlgebra.LAPACK.tzrzf! — Function
tzrzf!(A) -> (A, tau)

上三角台形行列 A を、インプレースで上三角行列に変換します。変換に用いる基本反射のスカラー・パラメーターである A と tau を返します。

source
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 を返します。

source
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 に返されます。

source
LinearAlgebra.LAPACK.gesv! — Function
gesv!(A, B) -> (B, A, ipiv)

A が正方行列である場合、A の LU 分解を用いて、線形方程式 A * X = B を解きます。A は LU 分解で上書きされ、B は解 X で上書きされます。ipiv には、A の LU 分解におけるピボット情報が格納されています。

source
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(共役転置)を指定できます。

source
LinearAlgebra.LAPACK.getri! — Function
getri!(A, ipiv)

getrf!で求めたAのLU分解を使って、その逆行列を計算します。ipivは出力されたピボット情報であり、Aにはgetrf!のLU分解が格納されています。Aは逆行列で上書きされます。

source
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 も返されます。

source
gesvx!(A, B)

gesvx! の平衡化も転置も行わない簡略化。

source
LinearAlgebra.LAPACK.gelsd! — Function
gelsd!(A, B, rcond) -> (B, rnk)

A * X = B の最小ノルム解を、A の SVD 分解を求めてから、分割統治法で問題を解くことで計算します。B は解 X で上書きされます。rcond 未満の特異値はゼロとして扱われます。解は B に、A の有効ランクは rnk に返されます。

source
LinearAlgebra.LAPACK.gelsy! — Function
gelsy!(A, B, rcond) -> (B, rnk)

A の完全な QR 分解を求めた後、分割統治法で問題を解くことで、A * X = B の最小ノルム解を計算します。B は解 X で上書きされます。rcond 未満の特異値はゼロとして扱われます。解は B に、A の有効ランクは rnk に返されます。

source
LinearAlgebra.LAPACK.gglse! — Function
gglse!(A, c, B, d) -> (X,res)

A * x = c の方程式を解きます。ここで、x は等式制約 B * x = d を満たします。||c - A*x||^2 = 0 の公式を使って解を求め、X と残差平方和を返します。

source
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 に返されます。

source
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'の行が計算され、個別に返されます。

source
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 の特異値です。

source
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 より前のバージョンでのみ利用できます。

source
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 が必要です。

source
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 の場合、右固有ベクトルと左固有ベクトルの両方を計算する必要があります。

source
LinearAlgebra.LAPACK.ggev! — Function
ggev!(jobvl, jobvr, A, B) -> (alpha, beta, vl, vr)

A と B の一般化固有値分解を求めます。jobvl = N の場合、左固有ベクトルは計算されません。jobvr = N の場合、右固有ベクトルは計算されません。jobvl = V または jobvr = V の場合は、対応する固有ベクトルが計算されます。

source
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 が必要です。

source
LinearAlgebra.LAPACK.gtsv! — Function
gtsv!(dl, d, du, B)

方程式 A * X = B を解きます。ここで、A は、劣対角成分が dl、対角成分が d、優対角成分が du の三重対角行列です。

B を解 X で上書きし、その値を返します。

source
LinearAlgebra.LAPACK.gttrf! — Function
gttrf!(dl, d, du) -> (dl, d, du, du2, ipiv)

劣対角にdl、対角にd、超対角にduを持つ三重対角行列のLU分解を求めます。

dl、d、duをインプレースで変更し、それらに加えて第2超対角du2とピボットベクトルipivを返します。

source
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を上書きします。

source
LinearAlgebra.LAPACK.orglq! — Function
orglq!(A, tau, k = length(tau))

A に対して gelqf! を呼び出した後、LQ 分解の行列 Q を明示的に取得します。gelqf! の出力を使用します。A は Q によって上書きされます。

source
LinearAlgebra.LAPACK.orgqr! — Function
orgqr!(A, tau, k = length(tau))

A に対して geqrf! を呼び出した後、QR 分解の行列 Q を明示的に求めます。geqrf! の出力を使用します。A は Q によって上書きされます。

source
LinearAlgebra.LAPACK.orgql! — Function
orgql!(A, tau, k = length(tau))

A に対して geqlf! を呼び出した後、QL 分解の行列 Q を明示的に求めます。geqlf! の出力を使用します。A は Q によって上書きされます。

source
LinearAlgebra.LAPACK.orgrq! — Function
orgrq!(A, tau, k = length(tau))

A に対して gerqf! を呼び出した後、RQ 分解の行列 Q を明示的に求めます。gerqf! の出力を使用します。A は Q によって上書きされます。

source
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は上書きされます。

source
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は上書きされます。

source
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は上書きされます。

source
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は上書きされます。

source
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は上書きされます。

source
LinearAlgebra.LAPACK.posv! — Function
posv!(uplo, A, B) -> (A, B)

A が対称正定値行列またはエルミート正定値行列である場合に、A * X = B の解を求めます。uplo = U の場合は、A の上三角コレスキー分解を計算します。uplo = L の場合は、A の下三角コレスキー分解を計算します。A はコレスキー分解で上書きされます。B は解 X で上書きされます。

source
LinearAlgebra.LAPACK.potrf! — Function
potrf!(uplo, A)

正定値行列 A のコレスキー分解を計算します(uplo = U の場合は上三角、uplo = L の場合は下三角)。A は上書きされ、情報コードとともに返されます。

source
LinearAlgebra.LAPACK.potri! — Function
potri!(uplo, A)

potrf!を呼び出して正定値行列Aのコレスキー分解(uplo = Uの場合は上三角、uplo = Lの場合は下三角)を求めた後、その逆行列を計算します。

Aは逆行列で上書きされ、その値が返されます。

source
LinearAlgebra.LAPACK.potrs! — Function
potrs!(uplo, A, B)

A が対称正定値またはエルミート正定値行列であり、そのコレスキー分解が potrf! によって計算されている場合に、A * X = B の解を求めます。uplo = U の場合は、A の上三角コレスキー分解が計算されています。uplo = L の場合は、A の下三角コレスキー分解が計算されています。B は、解 X で上書きされます。

source
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 は不定値またはランク落ちです。

source
LinearAlgebra.LAPACK.ptsv! — Function
ptsv!(D, E, B)

正定値三重対角行列 A に対して、A * X = B を解きます。D は A の対角成分、E は非対角成分です。B は解 X で上書きされ、その値が返されます。

source
LinearAlgebra.LAPACK.pttrf! — Function
pttrf!(D, E)

対角成分がD、非対角成分がEである正定値三重対角行列のLDLt分解を計算します。DとEは上書きされ、返されます。

source
LinearAlgebra.LAPACK.pttrs! — Function
pttrs!(D, E, B)

pttrf!を使用してAのLDLt分解を計算した後、対角成分がD、非対角成分がEである正定値三重対角Aに対して、A * X = Bを解きます。Bは解Xで上書きされます。

source
LinearAlgebra.LAPACK.trtri! — Function
trtri!(uplo, diag, A)

(uplo = U の場合は上三角、uplo = L の場合は下三角)行列 A の逆行列を求めます。diag = N の場合、A の対角要素は単位元ではありません。diag = U の場合、A の対角要素はすべて 1 です。A は逆行列で上書きされます。

source
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 で上書きされます。

source
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 ノルムで条件数を求めます。

source
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 の値に対応する固有ベクトルのみを計算します。

source
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 は後退誤差で、いずれも成分ごとの誤差です。

source
LinearAlgebra.LAPACK.stev! — Function
stev!(job, dv, ev) -> (dv, Zmat)

対称三重対角行列の固有系を計算します。対角成分は dv、非対角成分は ev です。job = N の場合は、固有値のみを求めて dv に返します。job = V の場合は、固有ベクトルも求めて Zmat に返します。

source
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 を設定できます。

source
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に返されます。

source
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には、部分行列ブロック間の分割点を指定します。

source
LinearAlgebra.LAPACK.syconv! — Function
syconv!(uplo, A, ipiv) -> (A, work)

三角行列に分解された対称行列 A を、2つの行列 L と D に変換します。uplo = U の場合、A は上三角行列になります。uplo = L の場合は、下三角行列になります。ipiv は、三角分解で得られたピボットベクトルです。A は、L と D で上書きされます。

source
LinearAlgebra.LAPACK.sysv! — Function
sysv!(uplo, A, B) -> (B, A, ipiv)

対称行列 A に対する A * X = B の解を求めます。uplo = U の場合、A の上半分が格納されています。uplo = L の場合は、下半分が格納されています。B は解 X で上書きされます。A は、そのバンチ・カウフマン分解で上書きされます。ipiv には、分解に関するピボット情報が格納されています。

source
LinearAlgebra.LAPACK.sytrf! — Function
sytrf!(uplo, A) -> (A, ipiv, info)

対称行列 A の Bunch-Kaufman 分解を計算します。uplo = U の場合、A の上半分が格納されます。uplo = L の場合、下半分が格納されます。

分解によって上書きされる A、ピボットベクトル ipiv、および非負整数のエラーコード info を返します。info が正の場合、行列は特異であり、分解の対角部分は位置 info で厳密にゼロになります。

source
sytrf!(uplo, A, ipiv) -> (A, ipiv, info)

対称行列 A の Bunch-Kaufman 分解を計算します。uplo = U の場合、A の上半分が格納されます。uplo = L の場合、下半分が格納されます。

分解によって上書きされた A、ピボットベクトル ipiv、および非負整数のエラーコード info を返します。info が正の場合、行列は特異であり、分解の対角部分は位置 info で厳密にゼロになります。

source
LinearAlgebra.LAPACK.sytri! — Function
sytri!(uplo, A, ipiv)

sytrf! の計算結果を用いて、対称行列 A の逆行列を計算します。uplo = U の場合、A の上半分が格納されています。uplo = L の場合は、下半分が格納されています。A は逆行列で上書きされます。

source
LinearAlgebra.LAPACK.sytrs! — Function
sytrs!(uplo, A, ipiv, B)

sytrf! の結果を用いて、対称行列 A に対する方程式 A * X = B を解きます。uplo = U の場合、A の上半分が格納されます。uplo = L の場合は、下半分が格納されます。B は、解 X で上書きされます。

source
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 には、分解に関するピボット情報が格納されます。

source
LinearAlgebra.LAPACK.hetrf! — Function
hetrf!(uplo, A) -> (A, ipiv, info)

エルミート行列 A の Bunch-Kaufman 分解を計算します。uplo = U の場合、A の上半分が格納されます。uplo = L の場合、下半分が格納されます。

分解によって上書きされた A、ピボットベクトル ipiv、および非負整数のエラーコード info を返します。info が正の場合、行列は特異であり、分解の対角部分は位置 info で厳密にゼロになります。

source
hetrf!(uplo, A, ipiv) -> (A, ipiv, info)

エルミート行列 A の Bunch-Kaufman 分解を計算します。uplo = U の場合、A の上半分が格納されます。uplo = L の場合、下半分が格納されます。

分解結果で上書きされた A、ピボットベクトル ipiv、および非負整数のエラーコード info を返します。info が正の場合、行列は特異であり、分解の対角部分は位置 info で厳密にゼロになります。

source
LinearAlgebra.LAPACK.hetri! — Function
hetri!(uplo, A, ipiv)

sytrf! の結果を用いて、エルミート行列 A の逆行列を計算します。uplo = U の場合、A の上半分が格納されています。uplo = L の場合は、下半分が格納されています。A は逆行列で上書きされます。

source
LinearAlgebra.LAPACK.hetrs! — Function
hetrs!(uplo, A, ipiv, B)

sytrf! の結果を用いて、エルミート行列 A に対する方程式 A * X = B を解きます。uplo = U の場合、A の上半分が格納されます。uplo = L の場合は、下半分が格納されます。B は、解 X で上書きされます。

source
LinearAlgebra.LAPACK.syev! — Function
syev!(jobz, uplo, A)

対称行列 A の固有値(jobz = N)、または固有値と固有ベクトル(jobz = V)を求めます。uplo = U の場合は A の上三角部分を使用し、uplo = L の場合は A の下三角部分を使用します。

source
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 に返されます。

source
LinearAlgebra.LAPACK.syevd! — Function
syevd!(jobz, uplo, A)

対称行列 A の固有値(jobz = N)、または固有値と固有ベクトル(jobz = V)を求めます。uplo = U の場合は A の上三角部分を使用し、uplo = L の場合は A の下三角部分を使用します。

source
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 です。

source
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 で上書きされます。

source
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 に返します。

source
LinearAlgebra.LAPACK.gecon! — Function
gecon!(normtype, A, anorm)

行列 A の逆条件数を求めます。normtype = I の場合、条件数は無限大ノルムで求められます。normtype = O または 1 の場合は、1ノルムで求められます。A は getrf! の結果でなければならず、anorm は該当するノルムにおける A のノルムです。

source
LinearAlgebra.LAPACK.gehrd! — Function
gehrd!(ilo, ihi, A) -> (A, tau)

行列 A をヘッセンベルグ形式に変換します。A が gebal! とともにバランス調整されている場合、ilo と ihi が gebal! の出力になります。そうでない場合は、ilo = 1 と ihi = size(A,2) が出力になります。tau には、因子分解における基本反射子が格納されています。

source
LinearAlgebra.LAPACK.orghr! — Function
orghr!(ilo, ihi, A, tau)

gehrd!から直交行列/ユニタリ行列Qを明示的に求めます。ilo、ihi、A、tauは、gehrd!への入力/出力に対応している必要があります。

source
LinearAlgebra.LAPACK.gees! — Function
gees!(jobvs, A) -> (A, vs, w)

行列 A の固有値(jobvs = N)、または固有値とシュールベクトル(jobvs = V)を計算します。A はシュール形式で上書きされます。

A を返します。vs にはシュールベクトルが、w には固有値が格納されます。

source
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 に返されます。

source
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 に返されます。

source
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引数メソッドを呼び出します。

source
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 を返します。

source
LinearAlgebra.LAPACK.tgsen! — Function
tgsen!(select, S, T, Q, Z) -> (S, T, alpha, beta, Q, Z)

一般化シュール分解のベクトルの順序を並べ替えます。selectは、各クラスターに含まれる固有値を指定します。

source
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 を返します。

source
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 には、分解に用いる基本反射子が格納されています。

source

Developer Documentation

LinearAlgebra.matprod_dest — Function
matprod_dest(A, B, T)

AbstractArray(要素型がT)のうち、A * Bの結果を格納するために使用できるものを返します。

Compat

この関数を使用するには、Julia 1.11 以降が必要です。

source
LinearAlgebra.haszero — Function
haszero(T::Type)

型 T に、zero(T) を使って定義された一意のゼロ要素があるかどうかを返します。型 M が zero(M) を特殊化する場合、haszero(M) を true に設定することもできます。デフォルトでは、haszero は false とみなされます。この場合、ゼロ要素は型ではなく値から推定されます。

Note

haszero は、最適化された処理経路へのディスパッチに使われる保守的なチェックです。拡張は任意ですが、推奨されます。

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