Linear Algebra

NoPivot

Pivoting yapılmaz. LU faktorizasyonu gibi matris faktorizasyonları, pivotlama olmadan başarısız olabilir ve yuvarlama hatası karşısında kayan nokta matrisleri için sayısal olarak kararsız olabilir. Bu pivot stratejisi esasen öğretici amaçlar için faydalıdır.

RowNonZero

Kalan sıfır olmayan ilk eleman, kalan satırlarda pivot eleman olarak seçilir.

Kayan nokta matrisleri için, elde edilen LU algoritması sayısal olarak kararsızdır — bu strateji esasen el hesaplamalarıyla (genellikle bu stratejiyi kullanan) veya yuvarlama hatalarına duyarlı olmayan diğer cebirsel türlerle (örneğin, rasyonel sayılar) karşılaştırma için faydalıdır. Aksi takdirde, Gauss eliminasyonunda genellikle varsayılan RowMaximum pivotlama stratejisi tercih edilmelidir.

Matrisin eleman türü bir iszero yöntemini kabul etmelidir.

RowMaximum

Kalan satırların maksimum büyüklükteki elemanı pivot eleman olarak seçilir. Bu, kayan nokta matrislerinin LU faktörizasyonu için varsayılan stratejidir ve bazen "kısmi pivotlama" algoritması olarak adlandırılır.

Matrisin eleman tipi abs (@ref) yöntemini kabul etmelidir ve sonuç tipi < yöntemini kabul etmelidir.

ColumnNorm

Maksimum norm'a sahip sütun, sonraki hesaplamalar için kullanılır. Bu, pivotlu QR faktorizasyonu için kullanılır.

Matrisin eleman tipi norm (@ref) ve abs (@ref) yöntemlerini kabul etmelidir; bunların sonuç türleri de < yöntemini kabul etmelidir.

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

Matris çarpımı.

Örnekler

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

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

3 veya 4 matrisin zincirleme çarpımı, dizilerin boyutlarına dayalı olarak en verimli sırada yapılır. Yani, (A * B) * C (3 yoğun matris ile) için gereken skalar çarpım sayısı, A * (B * C) için gerekenle karşılaştırılır ve bunlardan hangisinin yürütüleceğine karar verilir.

Son faktör bir vektörse veya ilk faktör transpoze bir vektörse, bunlarla önce ilgilenmek verimlidir. Özellikle x' * B * y, sıradan bir sütun-büyük B::Matrix için (x' * B) * y anlamına gelir. dot(x, B, y)'den farklı olarak, bu ara bir dizi ayırır.

İlk veya son faktör bir sayıysa, bu matris çarpımı ile birleştirilecektir ve 5-arg mul! kullanılacaktır.

Ayrıca muladd, dot bakınız.

\(A, B)

Bir polialgoritma kullanarak matris bölme. Girdi matrisleri A ve B için sonuç X, A kare olduğunda A*X == B olacak şekilde tanımlanır. Kullanılan çözücü, A'nın yapısına bağlıdır. Eğer A üst veya alt üçgen (veya diyagonal) ise, A'nın faktörizasyonuna gerek yoktur ve sistem ileri veya geri yerine koyma ile çözülür. Üçgen olmayan kare matrisler için LU faktörizasyonu kullanılır.

Dikdörtgen A için sonuç, A'nın pivotlu QR faktörizasyonu ve A'nın R faktörüne dayanan bir sıralama tahmini ile hesaplanan minimum-norm en küçük kareler çözümüdür.

A seyrek olduğunda, benzer bir polialgoritma kullanılır. Belirsiz matrisler için, LDLt faktörizasyonu sayısal faktörizasyon sırasında pivotlama kullanmaz ve bu nedenle prosedür, tersine çevrilebilir matrisler için bile başarısız olabilir.

Ayrıca bakınız: factorize, pinv.

Örnekler

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

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

julia> A * X == B
true

A / B

Matris sağ-bölümü: A / B, (B' \ A')' ile eşdeğerdir; burada \ sol-bölüm operatörüdür. Kare matrisler için, sonuç X öyle ki A == X*B olur.

Ayrıca bakınız: rdiv!.

Örnekler

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

TekilHata

Girdi matrisinin bir veya daha fazla sıfır değerli özdeğere sahip olduğu ve tersinir olmadığı durumlarda fırlatılan bir istisna. Böyle bir matrisle ilgili bir doğrusal çözüm hesaplanamaz. info alanı, (bir) tekil değerin yerini gösterir.

PosDefException

Girdi matrisinin pozitif belirli olmadığı durumlarda fırlatılan istisna. Bazı lineer cebir fonksiyonları ve faktorizasyonları yalnızca pozitif belirli matrislere uygulanabilir. info alanı, 0'dan küçük veya eşit olan (bir) özdeğerin yerini gösterir.

ZeroPivotException <: Exception

Bir matris faktörizasyonu/çözümü, bir pivot (diyagonal) konumunda sıfırla karşılaştığında ve devam edemediğinde fırlatılan istisna. Bu, matrisin tekil olduğu anlamına gelmeyebilir: yanıltıcı sıfır pivotları ortadan kaldırmak için değişkenleri yeniden sıralayabilen pivotlu LU gibi farklı bir faktörizasyona geçmek faydalı olabilir. info alanı, sıfır pivotlardan (birinden) birinin konumunu gösterir.

RankDeficientException

Girdi matrisinin rank eksik olduğu zaman fırlatılan istisna. Cholesky ayrıştırması gibi bazı lineer cebir fonksiyonları, yalnızca rank eksik olmayan matrislere uygulanabilir. info alanı, matrisin hesaplanan rankını gösterir.

LAPACKException

Genel LAPACK istisnası, ya doğrudan LAPACK fonksiyonları çağrılırken ya da LAPACK fonksiyonlarını dahili olarak kullanan ancak özel hata işleme eksik olan diğer fonksiyonlara yapılan çağrılarda fırlatılır. info alanı, çağrılan LAPACK fonksiyonuna bağlı olarak temel hata hakkında ek bilgi içerir.

dot(x, y)
x ⋅ y

İki vektör arasındaki nokta çarpımını hesaplayın. Karmaşık vektörler için, ilk vektör konjuge edilir.

dot ayrıca, dot'un elemanlar üzerinde tanımlı olduğu sürece, herhangi bir boyuttaki diziler de dahil olmak üzere, rastgele yinelemeli nesnelerde de çalışır.

dot, argümanların eşit uzunlukta olması kısıtlaması ile birlikte, sum(dot(vx,vy) for (vx,vy) in zip(x, y)) ile anlamsal olarak eşdeğerdir.

x ⋅ y (burada ⋅, REPL'de \cdot yazarak tamamlanabilir) dot(x, y) için bir eşanlamlıdır.

Örnekler

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

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

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

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

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

julia> dot(x, y)
150.0

dot(x, A, y)

İki vektör x ve y arasında, A*y ara sonucunu saklamadan genel bir nokta çarpımı dot(x, A*y) hesaplar. İki argümanlı dot(_,_) gibi, bu da özyinelemeli olarak çalışır. Ayrıca, karmaşık vektörler için, ilk vektör konjuge edilir.

Örnekler

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

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

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

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

İki 3-vektörün çarpımını hesaplayın.

Örnekler

julia> a = [0;1;0]
3-element Vector{Int64}:
 0
 1
 0

julia> b = [0;0;1]
3-element Vector{Int64}:
 0
 0
 1

julia> cross(a,b)
3-element Vector{Int64}:
 1
 0
 0

axpy!(α, x::AbstractArray, y::AbstractArray)

y'yi x * α + y ile üzerine yazın ve y'yi döndürün. Eğer x ve y aynı eksenlere sahipse, bu y .+= x .* a ile eşdeğerdir.

Örnekler

julia> x = [1; 2; 3];

julia> y = [4; 5; 6];

julia> axpy!(2, x, y)
3-element Vector{Int64}:
  6
  9
 12

axpby!(α, x::AbstractArray, β, y::AbstractArray)

y'yi x * α + y * β ile üzerine yazın ve y'yi döndürün. x ve y aynı eksenlere sahipse, bu y .= x .* a .+ y .* β ile eşdeğerdir.

Örnekler

julia> x = [1; 2; 3];

julia> y = [4; 5; 6];

julia> axpby!(2, x, 2, y)
3-element Vector{Int64}:
 10
 14
 18

rotate!(x, y, c, s)

x'i c*x + s*y ile ve y'yi -conj(s)*x + c*y ile üstüne yazar. x ve y'yi döner.

reflect!(x, y, c, s)

x'i c*x + s*y ile ve y'yi conj(s)*x - c*y ile üzerine yazar. x ve y'yi döner.

factorize(A)

A'nın türüne dayalı olarak uygun bir faktorizasyon hesaplar. factorize, A'nın genel bir matris olarak geçilip geçilmediğini kontrol eder ve simetrik/üçgen vb. olup olmadığını belirler. factorize, A'nın her bir elemanını kontrol ederek her özelliği doğrular/çürütür. Simetri/üçgen yapısını çürütmek için mümkün olan en kısa sürede duracaktır. Dönüş değeri, birden fazla sistemin verimli bir şekilde çözülmesi için yeniden kullanılabilir. Örneğin: A=factorize(A); x=A\b; y=A\C.

Örneğin, factorize bir Hermitian pozitif belirli matris üzerinde çağrıldığında, factorize bir Cholesky faktorizasyonu döndürecektir.

Örnekler

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

julia> factorize(A) # factorize, A'nın zaten faktörize olup olmadığını kontrol edecektir
5×5 Bidiagonal{Float64, Vector{Float64}}:
 1.0  1.0   ⋅    ⋅    ⋅
  ⋅   1.0  1.0   ⋅    ⋅
  ⋅    ⋅   1.0  1.0   ⋅
  ⋅    ⋅    ⋅   1.0  1.0
  ⋅    ⋅    ⋅    ⋅   1.0

Bu, artık diğer lineer cebir fonksiyonlarına (örneğin, özdeğer çözücüleri) geçirilebilecek bir 5×5 Bidiagonal{Float64} döndürür; bu fonksiyonlar Bidiagonal türleri için özel yöntemler kullanacaktır.

Diagonal(V::AbstractVector)

V'yi köşegen olarak kullanan tembel bir matris oluşturur.

Ayrıca, tembel bir kimlik matris olan I için UniformScaling, yoğun bir matris oluşturmak için diagm ve köşegen elemanları çıkarmak için diag ile de bakabilirsiniz.

Örnekler

julia> d = Diagonal([1, 10, 100])
3×3 Diagonal{Int64, Vector{Int64}}:
 1   ⋅    ⋅
 ⋅  10    ⋅
 ⋅   ⋅  100

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

julia> ans + I
2×2 Matrix{Int64}:
 8   0
 0  14

julia> I(2)
2×2 Diagonal{Bool, Vector{Bool}}:
 1  ⋅
 ⋅  1

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

julia> Diagonal(A)
1×1 Diagonal{Float64, Vector{Float64}}:
 7.0

Diagonal(A::AbstractMatrix)

A'nın ana köşegeninden bir matris oluşturur. Girdi matris A dikdörtgen olabilir, ancak çıktı kare olacaktır.

Örnekler

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

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

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

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

Diagonal{T}(undef, n)

Başlangıç değeri verilmemiş Diagonal{T} nesnesi oluşturur ve uzunluğu n'dir. undef'e bakın.

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

Verilen diagonal (dv) ve off-diagonal (ev) vektörlerini kullanarak üst (uplo=:U) veya alt (uplo=:L) bir bidiagonal matris oluşturur. Sonuç Bidiagonal türündedir ve verimli özel lineer çözücüler sağlar, ancak convert(Array, _) (veya kısaca Array(_)) ile normal bir matrise dönüştürülebilir. ev'nin uzunluğu dv'nin uzunluğundan bir eksik olmalıdır.

Örnekler

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 birinci süperdiagonalde
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 ⋅  2  8  ⋅
 ⋅  ⋅  3  9
 ⋅  ⋅  ⋅  4

julia> Bl = Bidiagonal(dv, ev, :L) # ev birinci altdiagonalde
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 7  2  ⋅  ⋅
 ⋅  8  3  ⋅
 ⋅  ⋅  9  4

Bidiagonal(A, uplo::Symbol)

A'n ana diyagonalından ve ilk süper (eğer uplo=:U) veya alt diyagonalından (eğer uplo=:L) bir Bidiagonal matris oluşturur.

Örnekler

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

julia> Bidiagonal(A, :U) # A'nın ana diyagonalını ve ilk süper diyagonalını içerir
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  1  ⋅  ⋅
 ⋅  2  2  ⋅
 ⋅  ⋅  3  3
 ⋅  ⋅  ⋅  4

julia> Bidiagonal(A, :L) # A'nın ana diyagonalını ve ilk alt diyagonalını içerir
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 2  2  ⋅  ⋅
 ⋅  3  3  ⋅
 ⋅  ⋅  4  4

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

Diyagonal (dv) ve ilk alt/üst diyagonal (ev) kullanarak simetrik bir tridiagonal matris oluşturur. Sonuç SymTridiagonal türündedir ve verimli özel özdeğer çözücüleri sağlar, ancak convert(Array, _) (veya kısaca Array(_)) ile normal bir matrise dönüştürülebilir.

SymTridiagonal blok matrisleri için, dv elemanları simetrik hale getirilir. ev argümanı üst diyagonal olarak yorumlanır. Alt diyagonal bloklar, karşılık gelen üst diyagonal blokların (materyalize edilmiş) transpozudur.

Örnekler

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

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

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

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

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

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

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

SymTridiagonal(A::AbstractMatrix)

Simetrik bir matrisin A diagonal ve ilk süperdiagonalinden simetrik bir tridiagonal matris oluşturur.

Örnekler

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

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

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

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

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

İlk alt diyagonal, diyagonal ve ilk üst diyagonal kullanılarak bir üçlü matris oluşturur. Sonuç Tridiagonal türündedir ve verimli özel lineer çözücüler sağlar, ancak convert(Array, _) (veya kısaca Array(_)) ile normal bir matrise dönüştürülebilir. dl ve du'nun uzunlukları, d'nin uzunluğundan bir eksik olmalıdır.

Örnekler

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

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

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

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

Tridiagonal(A)

Bir tridiagonal matris oluşturur A matrisinin ilk alt-diagonal, diagonal ve ilk üst-diagonalinden.

Örnekler

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

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

Matris Anın üst (eğer uplo = :U) veya alt (eğer uplo = :L) üçgeninin bir Simetrik görünümünü oluşturur.

Simetrik görünümler, esas olarak gerçek simetrik matrisler için yararlıdır; bu matrisler için özel algoritmalar (örneğin, özdeğer problemleri için) Simetrik türleri için etkinleştirilmiştir. Daha genel olarak, karmaşık matrisler için de yararlı olan A == A' koşulunu sağlayan Hermit matrisleri için Hermitian(A) kısmına da bakabilirsiniz. (Karmaşık Simetrik matrisler desteklenmektedir ancak çok az veya hiç özel algoritma yoktur.)

Gerçek bir matrisin simetrik kısmını veya daha genel olarak bir gerçek veya karmaşık matris Anın Hermit kısmını (A + A') / 2 hesaplamak için hermitianpart fonksiyonunu kullanın.

Örnekler

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 = Simetrik(A)
3×3 Simetrik{Int64, Matrix{Int64}}:
 1  2  3
 2  5  6
 3  6  9

julia> Slower = Simetrik(A, :L)
3×3 Simetrik{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'ın Slower ile eşit olmayacağını unutmayın, eğer A kendisi simetrik değilse (örneğin, A == transpose(A) ise).

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

A matrisinin üst (eğer uplo = :U) veya alt (eğer uplo = :L) üçgeninin bir Hermitian görünümünü oluşturur.

A'nın Hermitian kısmını hesaplamak için hermitianpart fonksiyonunu kullanın.

Örnekler

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

julia> Hupper = Hermitian(A)
3×3 Hermitian{Complex{Int64}, Matrix{Complex{Int64}}}:
 1+0im  2+2im  3-3im
 2-2im  5+0im  6-6im
 3+3im  6+6im  9+0im

julia> Hlower = Hermitian(A, :L)
3×3 Hermitian{Complex{Int64}, Matrix{Complex{Int64}}}:
 1+0im  4+0im  7+0im
 4+0im  5+0im  8-8im
 7+0im  8+8im  9+0im

julia> hermitianpart(A)
3×3 Hermitian{ComplexF64, Matrix{ComplexF64}}:
 1.0+0.0im  3.0+1.0im  5.0-1.5im
 3.0-1.0im  5.0+0.0im  7.0-7.0im
 5.0+1.5im  7.0+7.0im  9.0+0.0im

Hupper'ın Hlower ile eşit olmayacağını unutmayın, eğer A kendisi Hermitian değilse (örneğin, eğer A == adjoint(A) ise).

Diyagonalın tüm gerçek olmayan kısımları göz ardı edilecektir.

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

LowerTriangular(A::AbstractMatrix)

Matris A'nın bir LowerTriangular görünümünü oluşturur.

Örnekler

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

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

UpperTriangular(A::AbstractMatrix)

Matris A'nın bir UpperTriangular görünümünü oluşturur.

Örnekler

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

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

UnitLowerTriangular(A::AbstractMatrix)

Matris A'nın bir UnitLowerTriangular görünümünü oluşturur. Böyle bir görünüm, A'nın eltype türünün oneunit değerine sahip bir diyagonal içerir.

Örnekler

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

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

UnitUpperTriangular(A::AbstractMatrix)

Matris A'nın bir UnitUpperTriangular görünümünü oluşturur. Böyle bir görünüm, A'nın eltype türünün oneunit değerine sahip bir diyagonal içerir.

Örnekler

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

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

UpperHessenberg(A::AbstractMatrix)

Matris A'nın bir UpperHessenberg görünümünü oluşturur. A'nın ilk alt diyagonalinin altındaki girişler göz ardı edilir.

H \ b, det(H) ve benzeri işlemler için verimli algoritmalar uygulanmıştır.

Benzer bir üst-Hessenberg matrisine herhangi bir matrisin faktörleştirilmesi için hessenberg fonksiyonuna da bakın.

Eğer F::Hessenberg faktörizasyon nesnesi ise, birim matris F.Q ile erişilebilir ve Hessenberg matrisi F.H ile erişilebilir. Q çıkarıldığında, sonuç türü HessenbergQ nesnesidir ve convert(Array, _) (veya kısaca Array(_)) ile normal bir matrise dönüştürülebilir.

Ayrıştırmayı yinelemek, F.Q ve F.H faktörlerini üretir.

Örnekler

julia> A = [1 2 3 4; 5 6 7 8; 9 10 11 12; 13 14 15 16]
4×4 Matrix{Int64}:
  1   2   3   4
  5   6   7   8
  9  10  11  12
 13  14  15  16

julia> UpperHessenberg(A)
4×4 UpperHessenberg{Int64, Matrix{Int64}}:
 1   2   3   4
 5   6   7   8
 ⋅  10  11  12
 ⋅   ⋅  15  16

UniformScaling{T<:Number}

Bir skalar ile kimlik operatörünün çarpımı olarak tanımlanan genel boyutlu uniform ölçekleme operatörü, λ*I. Açık bir boyut olmadan, birçok durumda bir matris gibi davranır ve bazı dizinlemeleri destekler. Ayrıca I için de bakınız.

Örnekler

julia> J = UniformScaling(2.)
UniformScaling{Float64}
2.0*I

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

julia> J*A
2×2 Matrix{Float64}:
 2.0  4.0
 6.0  8.0

julia> J[1:2, 1:2]
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  2.0

I

Herhangi bir boyuttaki bir kimlik matrisini temsil eden UniformScaling türünde bir nesne.

Örnekler

julia> fill(1, (5,6)) * I == fill(1, (5,6))
true

julia> [1 2im 3; 1im 2 3] * I
2×3 Matrix{Complex{Int64}}:
 1+0im  0+2im  3+0im
 0+1im  2+0im  3+0im

(I::UniformScaling)(n::Integer)

Bir UniformScaling'den bir Diagonal matris oluşturur.

Örnekler

julia> I(3)
3×3 Diagonal{Bool, Vector{Bool}}:
 1  ⋅  ⋅
 ⋅  1  ⋅
 ⋅  ⋅  1

julia> (0.7*I)(3)
3×3 Diagonal{Float64, Vector{Float64}}:
 0.7   ⋅    ⋅
  ⋅   0.7   ⋅
  ⋅    ⋅   0.7

LinearAlgebra.Factorization

matris faktorizasyonları yani matris ayrıştırmaları için soyut tür. Mevcut matris faktorizasyonlarının bir listesi için çevrimiçi belgeler kısmına bakın.

LU <: Factorizasyon

Kare matris A'nın LU faktorizasyonunun matris faktorizasyon türü. Bu, ilgili matris faktorizasyon fonksiyonu olan lu için dönüş türüdür.

Faktorizasyonun bireysel bileşenlerine F::LU aracılığıyla getproperty ile erişilebilir:

Faktorizasyonu yinelemek, F.L, F.U ve F.p bileşenlerini üretir.

Örnekler

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 faktörü:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U faktörü:
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); # yineleme ile parçalama

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

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

Seyrek bir matris A'nın LU faktorizasyonunu hesaplayın.

Gerçek veya karmaşık eleman türüne sahip seyrek A için, F'nin dönüş türü UmfpackLU{Tv, Ti}'dir; burada Tv = Float64 veya ComplexF64 ve Ti bir tam sayı türüdür (Int32 veya Int64).

check = true olduğunda, ayrıştırma başarısız olursa bir hata fırlatılır. check = false olduğunda, ayrıştırmanın geçerliliğini kontrol etme sorumluluğu (issuccess aracılığıyla) kullanıcıya aittir.

Permütasyon q ya bir permütasyon vektörü ya da nothing olabilir. Eğer hiçbir permütasyon vektörü sağlanmamışsa veya q nothing ise, UMFPACK'in varsayılanı kullanılır. Eğer permütasyon sıfır tabanlı değilse, sıfır tabanlı bir kopya yapılır.

control vektörü, Julia SparseArrays paketinin UMFPACK için varsayılan yapılandırmasına (Not: bu, iteratif iyileştirmeyi devre dışı bırakmak için UMFPACK varsayılanlarından değiştirilmiştir) varsayılan olarak ayarlanmıştır, ancak UMFPACK_CONTROL uzunluğunda bir vektör geçirerek değiştirilebilir; olası yapılandırmalar için UMFPACK kılavuzuna bakın. Örneğin, iteratif iyileştirmeyi yeniden etkinleştirmek için:

umfpack_control = SparseArrays.UMFPACK.get_umfpack_control(Float64, Int64) # Float64 seyrek matris için Julia varsayılan yapılandırmasını oku
SparseArrays.UMFPACK.show_umf_ctrl(umfpack_control) # isteğe bağlı - değerleri göster
umfpack_control[SparseArrays.UMFPACK.JL_UMFPACK_IRSTEP] = 2.0 # iteratif iyileştirmeyi yeniden etkinleştir (2, UMFPACK varsayılan maksimum iteratif iyileştirme adımıdır)

Alu = lu(A; control = umfpack_control)
x = Alu \ b   # Ax = b'yi çöz, UMFPACK iteratif iyileştirmesini de dahil et

Faktorizasyonun F bireysel bileşenlerine indeksleme ile erişilebilir:

F ile A arasındaki ilişki

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

F ayrıca aşağıdaki işlevleri destekler:

• \
• det

Ayrıca lu! ile de bakın.

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

A'nın LU faktorizasyonunu hesaplayın.

check = true olduğunda, ayrıştırma başarısız olursa bir hata fırlatılır. check = false olduğunda, ayrıştırmanın geçerliliğini kontrol etme sorumluluğu (issuccess aracılığıyla) kullanıcıya aittir.

Varsayılan olarak, check = true ile, ayrıştırma geçerli faktörler ürettiğinde de bir hata fırlatılır, ancak üst üçgen faktör U sıralı eksiktir. Bu, allowsingular = true geçerek değiştirilebilir.

Çoğu durumda, A, +, -, * ve / destekleyen bir eleman türü T ile AbstractMatrix{T}'nin bir alt türü S ise, dönüş türü LU{T,S{T}}'dir.

Genel olarak, LU faktorizasyonu, matrisin satırlarının bir permütasyonunu içerir (aşağıda açıklanan F.p çıktısına karşılık gelen), "pivotlama" olarak bilinir (çünkü "pivot" olan, F.U'nun diyagonal girişi hangi satırın içerdiğini seçmekle ilgilidir). Aşağıdaki pivotlama stratejilerinden biri, isteğe bağlı pivot argümanı aracılığıyla seçilebilir:

• RowMaximum() (varsayılan): standart pivotlama stratejisi; pivot, kalan, faktörleştirilecek satırlar arasında maksimum mutlak değere sahip elemana karşılık gelir. Bu pivotlama stratejisi, eleman türünün de abs ve < desteklemesini gerektirir. (Bu, genellikle kayan nokta matrisleri için tek sayısal olarak kararlı seçenektir.)
• RowNonZero(): pivot, kalan, faktörleştirilecek satırlar arasında ilk sıfır olmayan elemana karşılık gelir. (Bu, el hesaplamalarında tipik seçime karşılık gelir ve iszero destekleyen ancak abs veya < desteklemeyen daha genel cebirsel sayı türleri için de yararlıdır.)
• NoPivot(): pivotlama kapalı (bir pivot pozisyonunda sıfır girişi ile karşılaşılırsa başarısız olur, hatta allowsingular = true olsa bile).

Faktorizasyonun bireysel bileşenlerine getproperty aracılığıyla erişilebilir:

Faktorizasyonu yinelemek, bileşenleri F.L, F.U ve F.p üretir.

F ile A arasındaki ilişki

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

F ayrıca aşağıdaki işlevleri destekler:

Örnekler

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 faktörü:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U faktörü:
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); # yineleme ile parçalama

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 faktörü:
2×2 Matrix{Float64}:
 1.0  0.0
 1.0  1.0
U faktörü (sıralı eksik):
2×2 Matrix{Float64}:
 1.0  2.0
 0.0  0.0

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

Seyrek bir matris A'nın LU faktorizasyonunu hesaplayın, zaten mevcut olan F'de saklanan sembolik faktorizasyonu yeniden kullanarak. reuse_symbolic false olarak ayarlanmadığı sürece, seyrek matris A'nın, LU faktorizasyonu F'yi oluşturmak için kullanılan matrisle aynı sıfır dışı desenine sahip olması gerekir, aksi takdirde bir hata fırlatılır. A ve F'nin boyutları farklıysa, tüm vektörler buna göre yeniden boyutlandırılacaktır.

check = true olduğunda, ayrıştırma başarısız olursa bir hata fırlatılır. check = false olduğunda, ayrıştırmanın geçerliliğini kontrol etme sorumluluğu (via issuccess) kullanıcıya aittir.

Permütasyon q ya bir permütasyon vektörü ya da nothing olabilir. Eğer hiçbir permütasyon vektörü sağlanmazsa veya q nothing ise, UMFPACK'in varsayılanı kullanılır. Eğer permütasyon sıfır tabanlı değilse, sıfır tabanlı bir kopya oluşturulur.

Ayrıca bkz. lu

Örnekler

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

julia> F = lu(A);

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

julia> lu!(F, B);

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

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

lu! aynı lu ile aynı işlevi görür, ancak girdi A'yı kopyalamak yerine üzerine yazarak yer tasarrufu sağlar. Faktörizasyon, A'nın eleman türü tarafından temsil edilemeyen bir sayı üretirse, örneğin tam sayı türleri için, bir InexactError istisnası fırlatılır.

Örnekler

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 faktörü:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U faktörü:
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)
HATA: InexactError: Int64(0.6666666666666666)
Yığın izi:
[...]

Cholesky <: Factorizasyon

Yoğun simetrik/Hermitian pozitif belirli matris A için Cholesky faktorizasyonunun matris faktorizasyon türü. Bu, cholesky ile ilgili matris faktorizasyon fonksiyonunun dönüş türüdür.

Üçgen Cholesky faktörü, faktorizasyon F::Cholesky üzerinden F.L ve F.U ile elde edilebilir; burada A ≈ F.U' * F.U ≈ F.L * F.L'.

Cholesky nesneleri için aşağıdaki fonksiyonlar mevcuttur: size, \, inv, det, logdet ve isposdef.

Ayrıştırmayı yinelemek, L ve U bileşenlerini üretir.

Örnekler

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 faktörü:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

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

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

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

julia> l, u = C; # yineleme ile parçalama

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

CholeskyPivoted

Yoğun simetrik/Hermitian pozitif yarı-tam bir matris A için pivotlu Cholesky faktorizasyonunun matris faktorizasyon türü. Bu, cholesky(_, ::RowMaximum) ile ilgili matris faktorizasyon fonksiyonunun dönüş türüdür.

Üçgen Cholesky faktörü, faktorizasyon F::CholeskyPivoted üzerinden F.L ve F.U ile elde edilebilir ve permütasyon F.p ile elde edilir; burada A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' ile Ur = F.U[1:F.rank, :] ve Lr = F.L[:, 1:F.rank], veya alternatif olarak A ≈ Up' * Up ≈ Lp * Lp' ile Up = F.U[1:F.rank, invperm(F.p)] ve Lp = F.L[invperm(F.p), 1:F.rank].

CholeskyPivoted nesneleri için aşağıdaki fonksiyonlar mevcuttur: size, \, inv, det ve rank.

Ayrıştırma işlemi L ve U bileşenlerini üretir.

Örnekler

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 faktörü ile sıralama 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
permutasyon:
4-elemanlı 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; # yineleme ile ayrıştırma

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

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

Yoğun simetrik pozitif belirli bir matris A'nın Cholesky faktorizasyonunu hesaplar ve bir Cholesky faktorizasyonu döner. Matris A, ya bir Symmetric ya da Hermitian AbstractMatrix veya tamamen simetrik veya Hermitian bir AbstractMatrix olabilir.

Üçgen Cholesky faktörü, faktorizasyon F üzerinden F.L ve F.U ile elde edilebilir; burada A ≈ F.U' * F.U ≈ F.L * F.L'.

Cholesky nesneleri için aşağıdaki fonksiyonlar mevcuttur: size, \, inv, det, logdet ve isposdef.

Eğer A matrisiniz, yapımındaki yuvarlama hataları nedeniyle hafifçe non-Hermitian ise, cholesky'ye geçmeden önce Hermitian(A) ile sarmalayarak onu tamamen Hermitian olarak ele alabilirsiniz.

check = true olduğunda, ayrıştırma başarısız olursa bir hata fırlatılır. check = false olduğunda, ayrıştırmanın geçerliliğini kontrol etme sorumluluğu (via issuccess) kullanıcıya aittir.

Örnekler

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 faktörü:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

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

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

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

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

Yoğun simetrik pozitif yarı-tam bir matris A için pivotlu Cholesky faktörizasyonunu hesaplayın ve bir CholeskyPivoted faktörizasyonu döndürün. Matris A, ya bir Symmetric ya da Hermitian AbstractMatrix veya tamamen simetrik veya Hermitian bir AbstractMatrix olabilir.

Faktörizasyondan F aracılığıyla üçgen Cholesky faktörü F.L ve F.U ile elde edilebilir ve permütasyon F.p ile elde edilir; burada A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' ile Ur = F.U[1:F.rank, :] ve Lr = F.L[:, 1:F.rank], veya alternatif olarak A ≈ Up' * Up ≈ Lp * Lp' ile Up = F.U[1:F.rank, invperm(F.p)] ve Lp = F.L[invperm(F.p), 1:F.rank].

CholeskyPivoted nesneleri için aşağıdaki fonksiyonlar mevcuttur: size, \, inv, det ve rank.

tol argümanı, rengi belirlemek için toleransı belirler. Negatif değerler için tolerans makine hassasiyetidir.

Eğer A matrisiniz, inşasında yuvarlama hataları nedeniyle hafifçe non-Hermitian ise, cholesky fonksiyonuna geçmeden önce Hermitian(A) ile sarmalayın, böylece onu tamamen Hermitian olarak ele alabilirsiniz.

check = true olduğunda, ayrıştırma başarısız olursa bir hata fırlatılır. check = false olduğunda, ayrıştırmanın geçerliliğini kontrol etme sorumluluğu (via issuccess) kullanıcıya aittir.

Örnekler

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 faktörü ile rengi 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
permutasyon:
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; # iterasyon ile parçalama

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

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

Sıkı pozitif belirli bir matris A'nın Cholesky faktörizasyonunu hesaplar. A, bir SparseMatrixCSC veya bir Symmetric/Hermitian görünümü olmalıdır. A'nın tür etiketi olmasa bile, hala simetrik veya Hermitian olması gerekir. perm verilmemişse, bir dolgu azaltıcı permütasyon kullanılır. F = cholesky(A) genellikle F\b ile denklemler sistemlerini çözmek için kullanılır, ancak diag, det ve logdet gibi yöntemler de F için tanımlanmıştır. Ayrıca, F'den bireysel faktörler çıkartabilirsiniz, F.L kullanarak. Ancak, varsayılan olarak pivotlama açık olduğundan, faktörizasyon içsel olarak A == P'*L*L'*P şeklinde bir permütasyon matris P ile temsil edilir; sadece L'yi P'yi hesaba katmadan kullanmak yanlış sonuçlar verecektir. Permütasyon etkilerini dahil etmek için, genellikle PtL = F.PtL (eşdeğeri P'*L) ve LtP = F.UP (eşdeğeri L'*P) gibi "birleşik" faktörler çıkartmak tercih edilir.

check = true olduğunda, ayrıştırma başarısız olursa bir hata fırlatılır. check = false olduğunda, ayrıştırmanın geçerliliğini kontrol etme sorumluluğu (issuccess aracılığıyla) kullanıcıya aittir.

İsteğe bağlı shift anahtar argümanını ayarlamak, A yerine A+shift*I'nin faktörizasyonunu hesaplar. perm argümanı sağlanırsa, bu, kullanılacak sıralamayı veren 1:size(A,1)'in bir permütasyonu olmalıdır (CHOLMOD'un varsayılan AMD sıralaması yerine).

Örnekler

Aşağıdaki örnekte, kullanılan dolgu azaltıcı permütasyon [3, 2, 1]'dir. perm 1:3 olarak ayarlandığında, yani hiç permütasyon uygulanmadığında, faktördeki sıfırdan farklı eleman sayısı 6'dır.

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

julia> C = cholesky(sparse(A))
SparseArrays.CHOLMOD.Factor{Float64, Int64}
type:    LLt
method:  simplicial
maxnnz:  5
nnz:     5
success: true

julia> C.p
3-element Vector{Int64}:
 3
 2
 1

julia> L = sparse(C.L);

julia> Matrix(L)
3×3 Matrix{Float64}:
 1.41421   0.0       0.0
 0.0       1.41421   0.0
 0.707107  0.707107  1.0

julia> L * L' ≈ A[C.p, C.p]
true

julia> P = sparse(1:3, C.p, ones(3))
3×3 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
  ⋅    ⋅   1.0
  ⋅   1.0   ⋅
 1.0   ⋅    ⋅

julia> P' * L * L' * P ≈ A
true

julia> C = cholesky(sparse(A), perm=1:3)
SparseArrays.CHOLMOD.Factor{Float64, Int64}
type:    LLt
method:  simplicial
maxnnz:  6
nnz:     6
success: true

julia> L = sparse(C.L);

julia> Matrix(L)
3×3 Matrix{Float64}:
 1.41421    0.0       0.0
 0.707107   1.22474   0.0
 0.707107  -0.408248  1.1547

julia> L * L' ≈ A
true

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

cholesky ile aynı, ancak girişi A üzerine yazarak alan tasarrufu sağlar, kopya oluşturmadan. Faktörizasyon, A'nın eleman türü tarafından temsil edilemeyen bir sayı üretirse, örneğin tam sayı türleri için, bir InexactError istisnası fırlatılır.

Örnekler

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

julia> cholesky!(A)
HATA: InexactError: Int64(6.782329983125268)
Yığın İzleme:
[...]

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

cholesky ile aynı, ancak bir kopya oluşturmak yerine girdi A'yı üst üste yazarak alan tasarrufu sağlar. Faktörizasyon, A'nın eleman türü tarafından temsil edilemeyen bir sayı üretirse, örneğin tam sayı türleri için, bir InexactError istisnası fırlatılır.

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

A'n Cholesky ($LL'$) faktorizasyonunu F'yi sembolik faktorizasyon olarak yeniden kullanarak hesaplayın. A, bir SparseMatrixCSC veya bir Symmetric/ Hermitian görünümü olmalıdır. A'nın tür etiketi olmasa bile, yine de simetrik veya Hermitian olması gerekir.

Ayrıca bkz. cholesky.

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

Bir Cholesky faktörizasyonu C'yi v vektörü ile güncelleyin. Eğer A = C.U'C.U ise, CC = cholesky(C.U'C.U + v*v') ancak CC'nin hesaplanması yalnızca O(n^2) işlemi kullanır.

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

Bir LDLt Faktörizasyonu A + C*C' için, A'nın LDLt veya LLt faktörizasyonu F verildiğinde.

Dönen faktör her zaman bir LDLt faktörizasyonudur.

Ayrıca bkz. lowrankupdate!, lowrankdowndate, lowrankdowndate!.

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

Bir Cholesky faktörizasyonunu C vektörü v ile güncelleyin. Eğer A = C.U'C.U ise, CC = cholesky(C.U'C.U - v*v') ancak CC'nin hesaplanması yalnızca O(n^2) işlemi kullanır.

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

Bir LDLt Faktörizasyonu A + C*C' için, A'nın LDLt veya LLt faktörizasyonu F verildiğinde.

Dönen faktör her zaman bir LDLt faktörizasyonudur.

Ayrıca bkz. lowrankdowndate!, lowrankupdate, lowrankupdate!.

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

Bir Cholesky faktörizasyonu C'yi v vektörü ile güncelleyin. Eğer A = C.U'C.U ise, CC = cholesky(C.U'C.U + v*v') ancak CC'nin hesaplanması yalnızca O(n^2) işlemi kullanır. Girdi faktörizasyonu C yerinde güncellenir, böylece çıkışta C == CC olur. v vektörü hesaplama sırasında yok edilir.

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

Bir LDLt veya LLt Faktörizasyonu F'yi A + C*C''nin bir faktörizasyonuna güncelleyin.

LLt faktörizasyonları LDLt'ye dönüştürülür.

Ayrıca bkz. lowrankupdate, lowrankdowndate, lowrankdowndate!.

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

Bir Cholesky faktörizasyonunu C vektörü v ile güncelleyin. Eğer A = C.U'C.U ise, CC = cholesky(C.U'C.U - v*v') ancak CC'nin hesaplanması yalnızca O(n^2) işlemi kullanır. Girdi faktörizasyonu C yerinde güncellenir, böylece çıkışta C == CC olur. Vektör v hesaplama sırasında yok edilir.

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

Bir LDLt veya LLt Faktörizasyonu F'yi A - C*C''nin bir faktörizasyonuna günceller.

LLt faktörizasyonları LDLt'ye dönüştürülür.

Ayrıca bkz. lowrankdowndate, lowrankupdate, lowrankupdate!.

LDLt <: Factorizasyon

Gerçek SymTridiagonal matris S için S = L*Diagonal(d)*L' şeklinde LDLt faktorizasyonunun matris faktorizasyon türü, burada L bir UnitLowerTriangular matris ve d bir vektördür. F = ldlt(S) şeklindeki bir LDLt faktorizasyonunun ana kullanımı, Sx = b doğrusal denklemler sistemini F\b ile çözmektir. Bu, ilgili matris faktorizasyon fonksiyonu olan ldlt için dönüş türüdür.

Faktorizasyonun bireysel bileşenleri F::LDLt aracılığıyla getproperty ile erişilebilir:

Örnekler

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 faktörü:
3×3 UnitLowerTriangular{Float64, SymTridiagonal{Float64, Vector{Float64}}}:
 1.0        ⋅         ⋅
 0.333333  1.0        ⋅
 0.0       0.545455  1.0
D faktörü:
3×3 Diagonal{Float64, Vector{Float64}}:
 3.0   ⋅        ⋅
  ⋅   3.66667   ⋅
  ⋅    ⋅       3.90909

ldlt(S::SymTridiagonal) -> LDLt

Gerçek simetrik tridiagonal matris S için LDLt (yani, $LDL^T$) faktorizasyonu hesaplayın; burada S = L*Diagonal(d)*L' şeklindedir ve L birim alt üçgen matris, d ise bir vektördür. F = ldlt(S) şeklindeki bir LDLt faktorizasyonunun ana kullanımı, Sx = b doğrusal denklemler sistemini F\b ile çözmektir.

Benzer, ancak pivotlu, genel simetrik veya Hermit matrislerin faktorizasyonu için bunchkaufman kısmına da bakın.

Örnekler

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

julia> ldltS = ldlt(S);

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

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

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

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

Sıkışık bir matris A'nın $LDL'$ faktorizasyonunu hesaplar. A, bir SparseMatrixCSC veya bir Symmetric/Hermitian görünümü olmalıdır. A'nın tür etiketi olmasa bile, hala simetrik veya Hermitian olmalıdır. Bir dolgu azaltıcı permütasyon kullanılır. F = ldlt(A) genellikle A*x = b denklemlerini F\b ile çözmek için kullanılır. Döndürülen faktorizasyon nesnesi F, ayrıca diag, det, logdet ve inv yöntemlerini de destekler. F'den bireysel faktörleri F.L kullanarak çıkarabilirsiniz. Ancak, varsayılan olarak pivotlama açık olduğundan, faktorizasyon içsel olarak A == P'*L*D*L'*P şeklinde temsil edilir; P ile hesaba katmadan sadece L kullanmak yanlış sonuçlar verecektir. Permütasyon etkilerini dahil etmek için, genellikle PtL = F.PtL (eşdeğeri P'*L) ve LtP = F.UP (eşdeğeri L'*P) gibi "birleşik" faktörleri çıkarmak tercih edilir. Desteklenen faktörlerin tam listesi :L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP'dir.

check = true olduğunda, ayrıştırma başarısız olursa bir hata fırlatılır. check = false olduğunda, ayrıştırmanın geçerliliğini kontrol etme sorumluluğu (via issuccess) kullanıcıya aittir.

İsteğe bağlı shift anahtar argümanını ayarlamak, A yerine A+shift*I'nin faktorizasyonunu hesaplar. perm argümanı sağlanırsa, bu, kullanılacak sıralamayı veren 1:size(A,1)'in bir permütasyonu olmalıdır (CHOLMOD'un varsayılan AMD sıralaması yerine).

ldlt!(S::SymTridiagonal) -> LDLt

ldlt ile aynı, ancak bir kopya oluşturmak yerine girdi S'yi üst üste yazarak alan tasarrufu sağlar.

Örnekler

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

julia> ldltS = ldlt!(S);

julia> ldltS === S
false

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

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

A'nın $LDL'$ faktorizasyonunu hesaplayın, sembolik faktorizasyonu F'yi yeniden kullanarak. A, bir SparseMatrixCSC veya bir Symmetric/Hermitian görünümü olmalıdır. A'nın tür etiketi olmasa bile, yine de simetrik veya Hermitian olması gerektiğini unutmayın.

Ayrıca bkz. ldlt.

QR <: Factorization

Bir QR matris faktorizasyonu, genellikle qr ile elde edilen, paketlenmiş bir formatta saklanır. Eğer $A$ bir m×n matris ise, o zaman

\[A = Q R\]

burada $Q$ ortogonal/birleşik bir matris ve $R$ üst üçgen matristir. Matris $Q$, aşağıdaki gibi Householder yansıtıcılarının $v_i$ ve katsayılarının $\tau_i$ bir dizisi olarak saklanır:

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

Ayrıştırmayı yineleyerek Q ve R bileşenlerini üretiriz.

Nesne iki alana sahiptir:

• factors, m×n boyutunda bir matristir.

  • Üst üçgen kısmı $R$'nin elemanlarını içerir, yani R = triu(F.factors) bir QR nesnesi F için.
  • Alt diyagonal kısmı, $v_i$'lerin paketlenmiş formatta saklandığı, V = I + tril(F.factors, -1) matrisinin $i$'nci sütunu olan yansıtıcıları içerir.

• τ, $au_i$ katsayılarını içeren min(m,n) uzunluğunda bir vektördür.

QRCompactWY <: Factorization

Kompakt blok formatında saklanan bir QR matris faktorizasyonu, genellikle qr ile elde edilir. Eğer $A$ bir m×n matris ise, o zaman

\[A = Q R\]

burada $Q$ ortogonal/birleşik bir matris ve $R$ üst üçgen bir matristir. Bu, ortogonal/birleşik matris $Q$'nun Kompakt WY formatında saklandığı için QR formatına benzer ^{[Schreiber1989]}. Blok boyutu $n_b$ için, m×n alt trapezoidal matris $V$ ve $b = \lceil \min(m,n) / n_b \rceil$ üst üçgen matrislerden oluşan bir matris $T = (T_1 \; T_2 \; ... \; T_{b-1} \; T_b')$ olarak saklanır; burada $T_j$ boyutu $n_b$×$n_b$ olan ($j = 1, ..., b-1$) ve üst trapezoidal $n_b$×$\min(m,n) - (b-1) n_b$ matris $T_b'$ ($j=b$) ile birlikte $T_b$ ile gösterilen üst kare kısmı ile birlikte

\[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)\]

şeklindedir; burada $v_i$ $V$'nin $i$'inci sütunu, $\tau_i$ ise [diag(T_1); diag(T_2); …; diag(T_b)]'nin $i$'inci elemanıdır ve $(V_1 \; V_2 \; ... \; V_b)$ $V$'nin sol m×min(m, n) bloğudur. qr kullanılarak oluşturulduğunda, blok boyutu $n_b = \min(m, n, 36)$ olarak verilir.

Ayrıştırmayı yinelemek Q ve R bileşenlerini üretir.

Nesne iki alana sahiptir:

• factors, QR türünde olduğu gibi, bir m×n matristir.

  • Üst üçgen kısmı $R$'nin elemanlarını içerir, yani R = triu(F.factors) bir QR nesnesi F için.
  • Alt diyagonal kısmı, V = I + tril(F.factors, -1) şeklinde paketlenmiş formatta saklanan yansıtıcılar $v_i$'yi içerir.

• T, yukarıda açıklandığı gibi bir $n_b$-çarpı-$\min(m,n)$ matristir. Her üçgen matris $T_j$ için alt diyagonal elemanlar göz ardı edilir.

QRPivoted <: Factorization

Sütun pivotlamalı bir QR matris faktorizasyonu, genellikle qr ile elde edilen paketlenmiş bir formatta. Eğer $A$ bir m×n matris ise, o zaman

\[A P = Q R\]

burada $P$ bir permütasyon matrisidir, $Q$ ortogonal/birleşik bir matris ve $R$ üst üçgen bir matristir. Matris $Q$, bir dizi Householder yansıtıcısı olarak saklanır:

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

Ayrıştırmayı yineleyerek Q, R ve p bileşenlerini üretir.

Nesne üç alana sahiptir:

• factors, m×n boyutunda bir matristir.

  • Üst üçgen kısmı $R$'nin elemanlarını içerir, yani R = triu(F.factors) bir QR nesnesi F için.
  • Alt diyagonal kısmı, $v_i$'lerin yansıtıcılarını içerir ve bunlar, $v_i$'nin matris V = I + tril(F.factors, -1)'nin $i$'inci sütunu olduğu paketlenmiş bir formatta saklanır.

• τ, $au_i$ katsayılarını içeren min(m,n) uzunluğunda bir vektördür.

• jpvt, permütasyon $P$'ye karşılık gelen n uzunluğunda bir tam sayı vektörüdür.

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

Seyrek bir matris A'nın QR faktorizasyonunu hesaplar. F.R = F.Q'*A[F.prow,F.pcol] olacak şekilde dolgu azaltıcı satır ve sütun permütasyonları kullanılır. Bu türün ana uygulaması, \ ile en küçük kareler veya yetersiz problemleri çözmektir. Fonksiyon, C kütüphanesi SPQR'yi çağırır^[ACM933].

Örnekler

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 faktörü:
4×4 SparseArrays.SPQR.QRSparseQ{Float64, Int64}
R faktörü:
2×2 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
 -1.41421    ⋅
   ⋅       -1.41421
Satır permütasyonu:
4 elemanlı Vector{Int64}:
 1
 3
 4
 2
Sütun permütasyonu:
2 elemanlı Vector{Int64}:
 1
 2

qr(A, pivot = NoPivot(); blocksize) -> F

Matris A'nın QR faktorizasyonunu hesaplar: ortogonal (veya A karmaşık değerli ise ünite) bir matris Q ve

\[A = Q R\]

şeklinde bir üst üçgen matris R döner.

Dönen nesne F, faktorizasyonu paketlenmiş bir formatta saklar:

• pivot == ColumnNorm() ise F bir QRPivoted nesnesidir,
• A'nın eleman türü bir BLAS türü (Float32, Float64, ComplexF32 veya ComplexF64) ise, F bir QRCompactWY nesnesidir,
• aksi takdirde F bir QR nesnesidir.

Faktorizasyonun bireysel bileşenleri F üzerinden özellik erişimcileri ile alınabilir:

• F.Q: ortogonal/ünite matris Q
• F.R: üst üçgen matris R
• F.p: pivotun permütasyon vektörü (QRPivoted yalnızca)
• F.P: pivotun permütasyon matris (QRPivoted yalnızca)

Faktorizasyonu yineleyerek Q, R ve mevcutsa p bileşenlerini üretir.

QR nesneleri için aşağıdaki fonksiyonlar mevcuttur: inv, size ve \. A dikdörtgen olduğunda, \ en küçük kareler çözümünü döner ve çözüm benzersiz değilse, en küçük norm olanı döner. A tam sıralı değilse, minimum norm çözümünü elde etmek için (sütun) pivotlama ile faktorizasyon gereklidir.

Tam/kare veya tam olmayan/kare Q ile çarpma mümkündür, yani hem F.Q*F.R hem de F.Q*A desteklenir. Bir Q matrisini Matrix ile normal bir matrise dönüştürebilirsiniz. Bu işlem "ince" Q faktörünü döner, yani A m×n ise ve m>=n ise, Matrix(F.Q) ortonormal sütunlara sahip bir m×n matris döner. "Tam" Q faktörünü almak için, bir m×m ortogonal matris, F.Q*I veya collect(F.Q) kullanın. Eğer m<=n ise, Matrix(F.Q) bir m×m ortogonal matris döner.

QR faktorizasyonu için blok boyutu, pivot == NoPivot() ve A isa StridedMatrix{<:BlasFloat} olduğunda anahtar argüman blocksize :: Integer ile belirtilebilir. blocksize > minimum(size(A)) olduğunda göz ardı edilir. QRCompactWY için bakınız.

Örnekler

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 faktörü: 3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R faktörü:
2×2 Matrix{Float64}:
 -5.0  10.0
  0.0  -1.0

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

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

qr!, qr ile aynı işlevi görür, ancak A'nın bir alt türü olduğunda AbstractMatrix, girişi A ile üzerine yazarak alan tasarrufu sağlar, kopya oluşturmaktan kaçınır. Faktörizasyon, A'nın eleman türü tarafından temsil edilemeyen bir sayı üretirse, örneğin tam sayı türleri için, bir InexactError istisnası fırlatılır.

Örnekler

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 faktörü: 2×2 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R faktörü:
2×2 Matrix{Float64}:
 -3.16228  -4.42719
  0.0      -0.632456

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

julia> qr!(a)
HATA: InexactError: Int64(3.1622776601683795)
Yığın izi:
[...]

LQ <: Factorizasyon

Bir matris A'nın LQ faktorizasyonunun matris faktorizasyon türü. LQ ayrıştırması, transpose(A)'nın QR ayrıştırmasıdır. Bu, ilgili matris faktorizasyon fonksiyonu olan lq'nin dönüş türüdür.

Eğer S::LQ faktorizasyon nesnesi ise, alt üçgen bileşeni S.L aracılığıyla elde edilebilir ve ortogonal/unitary bileşen S.Q aracılığıyla elde edilir, böylece A ≈ S.L*S.Q olur.

Ayrıştırmayı yinelemek, bileşenleri S.L ve S.Q üretir.

Örnekler

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

julia> S = lq(A)
LQ{Float64, Matris{Float64}, Vektör{Float64}}
L faktörü:
2×2 Matris{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q faktörü: 2×2 LinearAlgebra.LQPackedQ{Float64, Matris{Float64}, Vektör{Float64}}

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

julia> l, q = S; # yineleme ile parçalama

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

lq(A) -> S::LQ

A'nın LQ ayrıştırmasını hesaplayın. Ayrıştırmanın alt üçgen bileşeni, S nesnesinden S.L aracılığıyla elde edilebilir ve ortogonal/unitary bileşen S.Q aracılığıyla elde edilebilir, böylece A ≈ S.L*S.Q olur.

Ayrıştırmayı yineleyerek S.L ve S.Q bileşenlerini elde edersiniz.

LQ ayrıştırması, transpose(A)'nın QR ayrıştırmasıdır ve lq(A) \ b ifadesi ile bir belirsiz denklemler sistemine ( A'nın satır sayısından daha fazla sütunu var, ancak tam satır rütbesine sahip) minimum-norm çözümünü hesaplamak için faydalıdır.

Örnekler

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 faktörü:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q faktörü: 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; # yineleme ile parçalama

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

lq!(A) -> LQ

A matrisinin LQ faktorizasyonunu hesaplayın, girdi matrisini bir çalışma alanı olarak kullanarak. Ayrıca lq ile de bakın.

BunchKaufman <: Factorization

Simetrik veya Hermit bir matris A için Bunch-Kaufman faktorizasyonunun matris faktorizasyon türü P'UDU'P veya P'LDL'P şeklindedir; bu, A'da üst (varsayılan) veya alt üçgenin saklanıp saklanmadığına bağlıdır. Eğer A karmaşık simetrik ise, U' ve L' karmaşık olmayan transpozları, yani sırasıyla transpose(U) ve transpose(L) anlamına gelir. Bu, bunchkaufman fonksiyonunun dönüş türüdür.

Eğer S::BunchKaufman faktorizasyon nesnesi ise, bileşenler S.D, S.U veya S.L aracılığıyla, S.uplo ve S.p'ye bağlı olarak elde edilebilir.

Ayrıştırmayı yinelemek, S.D, S.U veya S.L bileşenlerini, S.uplo ve S.p'ye bağlı olarak üretir.

Örnekler

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

julia> S = bunchkaufman(A) # A, içsel olarak Symmetric(A) ile sarılır
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D faktörü:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U faktörü:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
permutasyon:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # yineleme ile parçalama

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

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

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

Bir simetrik veya Hermit matris A'nın Bunch-Kaufman ^[Bunch1977] faktorizasyonunu P'*U*D*U'*P veya P'*L*D*L'*P olarak hesaplayın; bu, A'da hangi üçgenin saklandığına bağlıdır ve bir BunchKaufman nesnesi döndürün. A karmaşık simetrik ise, U' ve L' karmaşık olmayan transpozları, yani transpose(U) ve transpose(L)'yi ifade eder.

Ayrıştırmayı yinelemek, S.uplo'ya bağlı olarak uygun olan S.D, S.U veya S.L bileşenlerini ve S.p'yi üretir.

Eğer rook true ise, rook pivotlama kullanılır. Eğer rook false ise, rook pivotlama kullanılmaz.

check = true olduğunda, ayrıştırma başarısız olursa bir hata fırlatılır. check = false olduğunda, ayrıştırmanın geçerliliğini kontrol etme sorumluluğu (issuccess aracılığıyla) kullanıcıya aittir.

BunchKaufman nesneleri için aşağıdaki fonksiyonlar mevcuttur: size, \, inv, issymmetric, ishermitian, getindex.

Örnekler

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

julia> S = bunchkaufman(A) # A, Symmetric(A) tarafından dahili olarak sarılır
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D faktörü:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U faktörü:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
permutasyon:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # yineleme ile parçalama

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

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

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

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

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

bunchkaufman!, bunchkaufman ile aynıdır, ancak girişi A üzerine yazarak alan tasarrufu sağlar, kopya oluşturmaktansa.

Eigen <: Factorization

Kare matris A'nın özdeğer/spektral ayrıştırma matris ayrıştırma türüdür. Bu, eigen olan ilgili matris ayrıştırma fonksiyonunun dönüş türüdür.

Eğer F::Eigen ayrıştırma nesnesi ise, özdeğerler F.values aracılığıyla elde edilebilir ve özvektörler F.vectors matrisinin sütunları olarak elde edilebilir. (k'nci özvektör F.vectors[:, k] diliminden elde edilebilir.)

Ayrıştırmayı yinelemek, F.values ve F.vectors bileşenlerini üretir.

Örnekler

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

GenelleştirilmişEigen <: Faktörizasyon

A ve B'nin genelleştirilmiş özdeğer/spektral ayrıştırmasının matris faktörizasyon türü. Bu, iki matris argümanıyla çağrıldığında eigen ile ilgili matris faktörizasyon fonksiyonunun dönüş türüdür.

Eğer F::GenelleştirilmişEigen faktörizasyon nesnesi ise, özdeğerler F.values aracılığıyla elde edilebilir ve özvektörler F.vectors matrisinin sütunları olarak elde edilebilir. (k'nci özvektör F.vectors[:, k] diliminden elde edilebilir.)

Ayrıştırmayı yinelemek, F.values ve F.vectors bileşenlerini üretir.

Örnekler

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)
GenelleştirilmişEigen{ComplexF64, ComplexF64, Matrix{ComplexF64}, Vector{ComplexF64}}
values:
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im
vectors:
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> F.values
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> F.vectors
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

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

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

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

A'nın özdeğerlerini döndürür.

Genel simetrik olmayan matrisler için, özdeğer hesaplamasından önce matrisin nasıl dengeleneceğini belirtmek mümkündür. permute, scale ve sortby anahtar kelimeleri, eigen için olanlarla aynıdır.

Örnekler

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

Bir skalar girdi için, eigvals bir skalar döndürecektir.

Örnekler

julia> eigvals(-2)
-2

eigvals(A, B) -> değerler

A ve B'nin genel özdeğerlerini hesaplayın.

Örnekler

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

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

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

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

A'nın özdeğerlerini döndürür. Sıralanmış özdeğerlerin indekslerini kapsayan bir UnitRange irange belirterek yalnızca bir alt kümesini hesaplamak mümkündür; örneğin, 2. ile 8. özdeğerler.

Örnekler

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

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

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

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

A'nın özdeğerlerini döndürür. Özdeğerlerin alt ve üst sınırları için bir çift vl ve vu belirterek yalnızca bir alt kümesini hesaplamak mümkündür.

Örnekler

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

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

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

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

eigvals ile aynı, ancak bir kopya oluşturmak yerine girdi A'yı üst üste yazarak yer tasarrufu sağlar. permute, scale ve sortby anahtar kelimeleri eigen için olanlarla aynıdır.

Örnekler

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

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

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

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

eigvals ile aynı, ancak kopyalar oluşturmak yerine giriş A (ve B) üzerine yazarak alan tasarrufu sağlar.

Örnekler

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

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

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

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

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

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

eigvals ile aynı, ancak bir kopya oluşturmak yerine girdi A'yı üst üste yazarak alan tasarrufu sağlar. irange, aramak için bir özdeğer indisleri aralığıdır - örneğin, 2. ile 8. özdeğerler.

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

eigvals ile aynı, ancak bir kopya oluşturmak yerine giriş A'yı üst üste yazarak alan tasarrufu sağlar. vl, özdeğerleri aramak için aralığın alt sınırıdır ve vu üst sınırdır.

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

A'nın en büyük özdeğerini döndürür. permute=true seçeneği, matrisin üst üçgensel hale daha yakın hale gelmesi için permütasyon yapar ve scale=true seçeneği, satır ve sütunların norm açısından daha eşit hale gelmesi için matrisin köşegen elemanlarıyla ölçeklenmesini sağlar. A'nın özdeğerleri karmaşık ise, bu yöntem başarısız olacaktır, çünkü karmaşık sayılar sıralanamaz.

Örnekler

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)
HATA: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` karmaşık özdeğerlere sahip olamaz.
Stacktrace:
[...]

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

A'n en küçük özdeğerini döndürür. permute=true seçeneği, matrisin üst üçgen forma daha yakın hale gelmesi için permütasyon yapar ve scale=true seçeneği, satır ve sütunların norm açısından daha eşit hale gelmesi için matrisin köşegen elemanlarıyla ölçeklenmesini sağlar. A'nın özdeğerleri karmaşık ise, bu yöntem başarısız olacaktır, çünkü karmaşık sayılar sıralanamaz.

Örnekler

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)
HATA: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` karmaşık özdeğerlere sahip olamaz.
Stacktrace:
[...]

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

Bir matris M döndürür; M'nin sütunları A'nın özvektörleridir. (k'nci özvektör, M[:, k] diliminden elde edilebilir.)

Eğer isteğe bağlı özdeğerler vektörü eigvals belirtilmişse, eigvecs belirli karşılık gelen özvektörleri döndürür.

Örnekler

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

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

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

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

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

A'nın özvektillerini içeren M matrisini döndürür. (k'nci özvektör M[:, k] diliminden elde edilebilir.) permute, scale ve sortby anahtar kelimeleri eigen ile aynıdır.

Örnekler

julia> eigvecs([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

eigvecs(A, B) -> Matrix

Bir matris M döndürün, sütunları A ve B'nin genelleştirilmiş özvektörleridir. (k'nci özvektör, M[:, k] diliminden elde edilebilir.)

Örnekler

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

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

julia> eigvecs(A, B)
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

eigen(A; permute::Bool=true, scale::Bool=true, sortby) -> Eigen

A'nın özdeğer ayrıştırmasını hesaplar ve özdeğerleri F.values içinde ve özvektörleri matris F.vectors'ın sütunlarında içeren bir Eigen faktörizasyon nesnesi F döner. Bu, Ax = λx biçiminde bir özdeğer problemini çözmekle ilgilidir; burada A bir matris, x bir özvektör ve λ bir özdeğerdir. (k'nci özvektör F.vectors[:, k] diliminden elde edilebilir.)

Ayrıştırmayı yinelemek, F.values ve F.vectors bileşenlerini üretir.

Eigen nesneleri için aşağıdaki fonksiyonlar mevcuttur: inv, det ve isposdef.

Genel simetrik olmayan matrisler için, özvektör hesaplamasından önce matrisin nasıl dengeleneceğini belirtmek mümkündür. permute=true seçeneği, matrisin üst üçgen forma daha yakın hale gelmesi için permütasyon yapar ve scale=true seçeneği, matrisin satır ve sütunlarının norm açısından daha eşit hale gelmesi için matrisin köşegen elemanlarıyla ölçeklenmesini sağlar. Her iki seçenek için varsayılan değer true'dur.

Varsayılan olarak, özdeğerler ve vektörler (real(λ),imag(λ)) açısından leksikografik olarak sıralanır. sortby'ye farklı bir karşılaştırma fonksiyonu by(λ) geçirilebilir veya özdeğerleri rastgele bir sırada bırakmak için sortby=nothing geçilebilir. Bazı özel matris türleri (örneğin, Diagonal veya SymTridiagonal) kendi sıralama kuralını uygulayabilir ve sortby anahtar kelimesini kabul etmeyebilir.

Örnekler

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

eigen(A, B; sortby) -> GenelleşmişEigen

A ve B matrislerinin genelleşmiş özdeğer ayrıştırmasını hesaplayarak, F.values içinde genelleşmiş özdeğerleri ve F.vectors matrisinin sütunlarında genelleşmiş özvektörleri içeren bir GenelleşmişEigen faktörizasyon nesnesi F döndürür. Bu, Ax = λBx biçiminde bir genelleşmiş özdeğer problemini çözmekle ilgilidir; burada A, B matrislerdir, x bir özvektördür ve λ bir özdeğerdir. (k'nci genelleşmiş özvektör, F.vectors[:, k] diliminden elde edilebilir.)

Ayrıştırmayı yinelemek, F.values ve F.vectors bileşenlerini üretir.

Varsayılan olarak, özdeğerler ve vektörler (real(λ),imag(λ)) sıralamasıyla leksikografik olarak sıralanır. sortby'ya farklı bir karşılaştırma fonksiyonu by(λ) geçirilebilir veya özdeğerleri rastgele bir sırada bırakmak için sortby=nothing geçirebilirsiniz.

Örnekler

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; # yineleme ile parçalama

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

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

A'n özdeğer ayrıştırmasını hesaplayarak, özdeğerleri F.values içinde ve özvektörleri matris F.vectors'ın sütunlarında içeren bir Eigen faktörizasyon nesnesi F döndürür. (k'nci özvektör, F.vectors[:, k] diliminden elde edilebilir.)

Ayrıştırmayı yineleyerek F.values ve F.vectors bileşenlerini elde edebilirsiniz.

Eigen nesneleri için aşağıdaki fonksiyonlar mevcuttur: inv, det ve isposdef.

UnitRange irange, aranan sıralı özdeğerlerin indekslerini belirtir.

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

A'n özdeğer ayrıştırmasını hesaplayarak, özdeğerleri F.values içinde ve özvektörleri matris F.vectors'ın sütunlarında içeren bir Eigen faktörizasyon nesnesi F döndürür. (k'nci özvektör, F.vectors[:, k] diliminden elde edilebilir.)

Ayrıştırmayı yineleyerek F.values ve F.vectors bileşenlerini elde edebilirsiniz.

Eigen nesneleri için aşağıdaki fonksiyonlar mevcuttur: inv, det ve isposdef.

vl, aramak için özdeğerlerin alt sınırıdır ve vu üst sınırdır.

eigen!(A; permute, scale, sortby)
eigen!(A, B; sortby)

eigen ile aynı, ancak bir kopya oluşturmak yerine girdi A (ve B) üzerine yazarak alan tasarrufu sağlar.

Hessenberg <: Faktörizasyon

Bir Hessenberg nesnesi, bir kare matrisin Hessenberg faktörizasyonunu QHQ' veya bunun bir kaydırmasını Q(H+μI)Q' temsil eder; bu, hessenberg fonksiyonu tarafından üretilir. ```

hessenberg(A) -> Hessenberg

A'n Hessenberg ayrıştırmasını hesaplayın ve bir Hessenberg nesnesi döndürün. F faktörizasyon nesnesi ise, birim matris F.Q (tipi LinearAlgebra.HessenbergQ) ile ve Hessenberg matris F.H (tipi UpperHessenberg) ile erişilebilir; bunların her biri Matrix(F.H) veya Matrix(F.Q) ile normal bir matrise dönüştürülebilir.

Eğer A Hermitian veya gerçek-Symmetric ise, o zaman Hessenberg ayrıştırması gerçek-simetrik tridiagonal bir matris üretir ve F.H tipi SymTridiagonal olur.

Kaydırılmış faktörizasyon A+μI = Q (H+μI) Q' verimli bir şekilde F + μ*I kullanılarak oluşturulabilir; burada UniformScaling nesnesi I yeni bir Hessenberg nesnesi oluşturur ve paylaşılan depolama ile değiştirilmiş bir kaydırma sağlar. Verilen bir F için kaydırma F.μ ile elde edilir. Bu, F oluşturulduktan sonra farklı μ ve/veya b için birden fazla kaydırılmış çözüm (F + μ*I) \ b'nin verimli bir şekilde gerçekleştirilebilmesi açısından faydalıdır.

Ayrıştırmayı yinelemek, faktörleri F.Q, F.H, F.μ üretir.

Örnekler

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 faktörü: 3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}
H faktörü:
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; # yineleme ile parçalama

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

hessenberg!(A) -> Hessenberg

hessenberg! hessenberg ile aynıdır, ancak girişi A üzerine yazarak bir kopya oluşturmak yerine alan tasarrufu sağlar.

Schur <: Factorizasyon

Bir matris A'nın Schur faktorizasyonu için matris faktorizasyon türü. Bu, schur(_) ile ilgili matris faktorizasyon fonksiyonunun dönüş türüdür.

Eğer F::Schur faktorizasyon nesnesi ise, (quasi) üçgen Schur faktörü F.Schur veya F.T ile elde edilebilir ve ortogonal/unitary Schur vektörleri F.vectors veya F.Z ile elde edilebilir, böylece A = F.vectors * F.Schur * F.vectors'. A'nın özdeğerleri F.values ile elde edilebilir.

Ayrıştırmayı yinelemek, F.T, F.Z ve F.values bileşenlerini üretir.

Örnekler

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 faktörü:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z faktörü:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
özdeğerler:
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; # yineleme ile parçalama

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

GenelleştirilmişSchur <: Faktörizasyon

İki matris A ve B için genelleştirilmiş Schur faktörizasyonunun matris faktörizasyon türü. Bu, schur(_, _) ile ilgili matris faktörizasyon fonksiyonunun dönüş türüdür.

Eğer F::GenelleştirilmişSchur faktörizasyon nesnesi ise, (quasi) üçgen Schur faktörleri F.S ve F.T aracılığıyla elde edilebilir, sol birim/ortogonal Schur vektörleri F.left veya F.Q ile, sağ birim/ortogonal Schur vektörleri ise F.right veya F.Z ile elde edilebilir; böylece A=F.left*F.S*F.right' ve B=F.left*F.T*F.right'. A ve B'nin genelleştirilmiş özdeğerleri F.α./F.β ile elde edilebilir.

Ayrıştırmayı yinelemek, bileşenleri F.S, F.T, F.Q, F.Z, F.α ve F.β üretir.

schur(A) -> F::Schur

Matris A'nın Schur faktorizasyonunu hesaplar. (quasi) üçgen Schur faktörü, F Schur nesnesinden F.Schur veya F.T ile elde edilebilir ve ortogonal/unitary Schur vektörleri F.vectors veya F.Z ile elde edilebilir; böylece A = F.vectors * F.Schur * F.vectors'. A'nın özdeğerleri F.values ile elde edilebilir.

Gerçek A için Schur faktorizasyonu "quasitriangular"dır, bu da üst üçgen olduğu anlamına gelir, ancak karmaşık özdeğerlerin herhangi bir konjugat çifti için 2×2 diyagonal bloklar içerir; bu, karmaşık özdeğerler olsa bile faktorizasyonun tamamen gerçek olmasını sağlar. Gerçek bir quasitriangular faktorizasyondan (karmaşık) tamamen üst üçgen Schur faktorizasyonunu elde etmek için Schur{Complex}(schur(A)) kullanabilirsiniz.

Ayrıştırmayı yinelemek, F.T, F.Z ve F.values bileşenlerini üretir.

Örnekler

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 faktörü:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z faktörü:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
özdeğerler:
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; # yineleme ile parçalama

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

schur(A, B) -> F::GenelleştirilmişSchur

Matrislerin A ve B Genel Schur (veya QZ) faktorizasyonunu hesaplar. (kuazi) üçgen Schur faktörleri F nesnesinden F.S ve F.T ile elde edilebilir, sol birim/ortogonal Schur vektörleri F.left veya F.Q ile elde edilebilir ve sağ birim/ortogonal Schur vektörleri F.right veya F.Z ile elde edilebilir, böylece A=F.left*F.S*F.right' ve B=F.left*F.T*F.right'. A ve B'nin genel özdeğerleri F.α./F.β ile elde edilebilir.

Ayrıştırmayı yinelemek, bileşenleri F.S, F.T, F.Q, F.Z, F.α ve F.β üretir.

schur!(A) -> F::Schur

Girdi argümanı A'yı çalışma alanı olarak kullanan schur ile aynı.

Örnekler

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 faktörü:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z faktörü:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
özdeğerler:
2-element Vector{Float64}:
  3.0
 -2.0

julia> A
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0

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

schur ile aynı, ancak giriş matrisleri A ve B çalışma alanı olarak kullanılır.

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

Bir matris A = Z*T*Z''nin Schur faktorizasyonu F'yi mantıksal dizi select'e göre yeniden sıralar ve yeniden sıralanmış faktorizasyon F nesnesini döndürür. Seçilen özdeğerler F.Schur'un öncelikli diyagonalinde görünür ve F.vectors'ın karşılık gelen öncelikli sütunları, ilgili sağ invariyant alt uzayının ortogonal/unitary bir tabanını oluşturur. Gerçek durumda, bir karmaşık eşlenik özdeğer çifti ya her ikisi de dahil edilmeli ya da her ikisi de select aracılığıyla hariç tutulmalıdır.

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

Bir matris çifti (A, B) = (Q*S*Z', Q*T*Z') için Genel Schur faktörizasyonu F'yi mantıksal dizi select'e göre yeniden sıralar ve bir GenelSchur nesnesi F döndürür. Seçilen özdeğerler, hem F.S hem de F.T'nin öncelikli diyagonalinde görünür ve sol ve sağ ortogonal/unitary Schur vektörleri de yeniden sıralanır, böylece (A, B) = F.Q*(F.S, F.T)*F.Z' hala geçerli kalır ve A ve B'nin genel özdeğerleri hala F.α./F.β ile elde edilebilir.

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

ordschur ile aynı, ancak faktorizasyonu F üzerine yazar.

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

Aynı ordschur gibi, ancak faktorizasyonu F ile üzerine yazar.

SVD <: Factorization

Bir matrisin tekil değer ayrıştırmasının (SVD) matris faktörizasyon türü A. Bu, svd(_) ile ilgili matris faktörizasyon fonksiyonunun dönüş türüdür.

Eğer F::SVD faktörizasyon nesnesi ise, U, S, V ve Vt F.U, F.S, F.V ve F.Vt aracılığıyla elde edilebilir; böylece A = U * Diagonal(S) * Vt. S içindeki tekil değerler azalan sırada sıralanmıştır.

Ayrıştırmayı yinelemek, U, S ve V bileşenlerini üretir.

Örnekler

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 faktörü:
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
tekil değerler:
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0
Vt faktörü:
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; # yineleme ile parçalama

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

GenelleştirilmişSVD <: Faktörizasyon

İki matris A ve B için genelleştirilmiş tekil değer ayrıştırmasının (SVD) matris faktörizasyon türü, A = F.U*F.D1*F.R0*F.Q' ve B = F.V*F.D2*F.R0*F.Q' şeklindedir. Bu, svd(_, _) fonksiyonunun döndürdüğü türdür, ilgili matris faktörizasyon fonksiyonu.

Bir M-by-N matris A ve P-by-N matris B için,

• U M-by-M ortogonal bir matristir,
• V P-by-P ortogonal bir matristir,
• Q N-by-N ortogonal bir matristir,
• D1 ilk K girişinde 1'ler bulunan M-by-(K+L) diyagonal bir matristir,
• D2 üst sağ L-by-L bloğu diyagonal olan P-by-(K+L) bir matristir,
• R0 sağdaki (K+L)-by-(K+L) bloğu tekil üst blok üçgen olan (K+L)-by-N bir matristir,

K+L, matrisin etkili sayısal derecesidir [A; B].

Ayrıştırmayı yinelemek, U, V, Q, D1, D2 ve R0 bileşenlerini üretir.

F.D1 ve F.D2 girişleri, genelleştirilmiş SVD için LAPACK belgelerinde ve altında çağrılan xGGSVD3 rutininde açıklandığı gibi ilişkilidir (LAPACK 3.6.0 ve daha yenilerinde).

Örnekler

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)
GenelleştirilmişSVD{Float64, Matrix{Float64}, Float64, Vector{Float64}}
U faktörü:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
V faktörü:
2×2 Matrix{Float64}:
 -0.0  -1.0
  1.0   0.0
Q faktörü:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
D1 faktörü:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
D2 faktörü:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
R0 faktörü:
2×2 Matrix{Float64}:
 1.41421   0.0
 0.0      -1.41421

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

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

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

A'nın tekil değer ayrıştırmasını (SVD) hesaplayın ve bir SVD nesnesi döndürün.

U, S, V ve Vt, F.U, F.S, F.V ve F.Vt ile ayrıştırmadan elde edilebilir; böylece A = U * Diagonal(S) * Vt. Algoritma Vt'yi üretir ve bu nedenle Vt'yi çıkarmak V'den daha verimlidir. S'deki tekil değerler azalan sırada sıralanmıştır.

Ayrıştırmayı yineleyerek U, S ve V bileşenlerini elde edersiniz.

Eğer full = false (varsayılan), "ince" bir SVD döndürülür. $M \times N$ boyutundaki bir matris A için, tam ayrıştırmada U $M \times M$ ve V $N \times N$ iken, ince ayrıştırmada U $M \times K$ ve V $N \times K$'dır; burada $K = \min(M,N)$ tekil değerlerin sayısıdır.

Eğer alg = DivideAndConquer() ise SVD'yi hesaplamak için bir böl ve fethet algoritması kullanılır. Diğer bir (genellikle daha yavaş ama daha doğru) seçenek alg = QRIteration()'dır.

Örnekler

julia> A = rand(4,3);

julia> F = svd(A); # Ayrıştırma Nesnesini Sakla

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

julia> U, S, V = F; # yineleme ile parçalama

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

julia> Uonly, = svd(A); # Sadece U'yu Sakla

julia> Uonly == U
true

svd(A, B) -> GenelSVD

A ve B'nin genel SVD'sini hesaplayın, [A;B] = [F.U * F.D1; F.V * F.D2] * F.R0 * F.Q' şeklinde bir GeneralizedSVD faktörizasyon nesnesi F döndürün.

• U M-by-M ortogonal bir matristir,
• V P-by-P ortogonal bir matristir,
• Q N-by-N ortogonal bir matristir,
• D1 ilk K girişinde 1'ler bulunan M-by-(K+L) diyagonal bir matristir,
• D2 üst sağ L-by-L bloğu diyagonal olan P-by-(K+L) bir matristir,
• R0 sağdaki (K+L)-by-(K+L) bloğu tekil üst blok üçgen olan (K+L)-by-N bir matristir,

K+L, [A; B] matrisinin etkili sayısal derecesidir.

Ayrıştırmayı yinelemek U, V, Q, D1, D2 ve R0 bileşenlerini üretir.

Genel SVD, A ile B arasındaki karşılaştırmalar yapmak istendiğinde, insan ile maya genomu, sinyal ile gürültü veya kümeler arası ile kümeler içi gibi uygulamalarda kullanılır. (Tartışma için Edelman ve Wang'a bakın: https://arxiv.org/abs/1901.00485)

[A; B]'yi [UC; VS]H şeklinde ayrıştırır, burada [UC; VS], [A; B]'nin sütun uzayı için doğal bir ortogonal temeldir ve H = RQ', [A;B]'nin satır uzayı için doğal bir ortogonal olmayan temeldir; burada üst satırlar en çok A matrisine atfedilir ve alt satırlar B matrisine atfedilir. Çoklu kosinüs/sinüs matrisleri C ve S, A ile B arasındaki oranı ölçen çoklu bir ölçü sağlar ve U ile V, bunların ölçüldüğü yönleri sağlar.

Örnekler

julia> A = randn(3,2); B=randn(4,2);

julia> F = svd(A, B);

julia> U,V,Q,C,S,R = F;

julia> H = R*Q';

julia> [A; B] ≈ [U*C; V*S]*H
true

julia> [A; B] ≈ [F.U*F.D1; F.V*F.D2]*F.R0*F.Q'
true

julia> Uonly, = svd(A,B);

julia> U == Uonly
true

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

svd!, svd ile aynıdır, ancak bir kopya oluşturmak yerine girdi A'yı üst üste yazarak alan tasarrufu sağlar. Ayrıntılar için svd belgesine bakın.

svd!(A, B) -> Genel SVD

svd!, svd ile aynıdır, ancak A ve B argümanlarını yerinde değiştirir, kopyalarını oluşturmak yerine. Ayrıntılar için svd belgesine bakın.

svdvals(A)

A'nın tekil değerlerini azalan sırayla döndürür.

Örnekler

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

julia> svdvals(A)
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0

svdvals(A, B)

Genelleştirilmiş tekil değerleri A ve B'nin genelleştirilmiş tekil değer ayrıştırmasından döndürür. Ayrıca svd bakınız.

Örnekler

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

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

julia> svdvals(A, B)
2-element Vector{Float64}:
 1.0
 1.0

svdvals!(A)

A'nın tekil değerlerini döndürün, girişi üzerine yazarak yer tasarrufu sağlayın. Ayrıca bkz. svdvals ve svd.

svdvals!(A, B)

Genelleştirilmiş tekil değerleri A ve B'nin genelleştirilmiş tekil değer ayrıştırmasından döndürür, A ve B'yi üst üste yazarak alan tasarrufu sağlar. Ayrıca bkz. svd ve svdvals.

LinearAlgebra.Givens(i1,i2,c,s) -> G

Bir Givens rotasyonu lineer operatörü. c ve s alanları, sırasıyla döndürme açısının kosinüsünü ve sinüsünü temsil eder. Givens türü, sol çarpma G*A ve konjuge transpoze sağ çarpma A*G' destekler. Bu türün bir boyutu yoktur ve bu nedenle G*A için i2<=size(A,2) veya A*G' için i2<=size(A,1) olduğu sürece, rastgele boyutlardaki matrislerle çarpılabilir.

Ayrıca bkz. givens.

givens(f::T, g::T, i1::Integer, i2::Integer) where {T} -> (G::Givens, r::T)

Givens rotasını G ve herhangi bir vektör x için

x[i1] = f
x[i2] = g

şu şekilde hesaplar:

y = G*x

sonucunun şu özelliğe sahip olmasını sağlar:

y[i1] = r
y[i2] = 0

Ayrıca bkz. LinearAlgebra.Givens.

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

Givens rotasını G ve çarpan r'yi hesaplar, böylece çarpmanın sonucu

B = G*A

şu özelliğe sahip olur:

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

Ayrıca bkz. LinearAlgebra.Givens.

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

Givens rotasını G ve çarpan r'yi hesaplar, böylece çarpmanın sonucu

B = G*x

şu özelliğe sahip olur:

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

Ayrıca bkz. LinearAlgebra.Givens.

triu(M)

Bir matrisin üst üçgeni.

Örnekler

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

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

triu(M, k::Integer)

M matrisinin k'nci süperdiagonalinden başlayarak üst üçgenini döndürür.

Örnekler

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

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

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

triu!(M)

Bir matrisin üst üçgeni, bu süreçte M'yi üzerine yazar. Ayrıca bkz. triu.

triu!(M, k::Integer)

M matrisinin k'nci süperdiagonalinden başlayarak üst üçgenini döndürür ve bu süreçte M'yi üzerine yazar.

Örnekler

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

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

tril(M)

Bir matrisin alt üçgeni.

Örnekler

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

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

tril(M, k::Integer)

k'nci üst diyagonalden başlayarak M'nin alt üçgenini döndürür.

Örnekler

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

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

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

tril!(M)

Bir matrisin alt üçgenini alır, bu süreçte M'yi üzerine yazar. Ayrıca bkz. tril.

tril!(M, k::Integer)

M matrisinin k'nci süperdiagonalinden başlayarak alt üçgenini döndürür ve bu süreçte M'yi üzerine yazar.

Örnekler

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

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

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

M matrisinin k'nci diyagonalinin indekslerini veren bir AbstractRange. İsteğe bağlı olarak, döndürülen aralığın türünü belirleyen bir indeks stili belirtilebilir. Eğer indstyle isa IndexLinear (varsayılan), bu bir AbstractRange{Integer} döndürür. Öte yandan, eğer indstyle isa IndexCartesian ise, bu bir AbstractRange{CartesianIndex{2}} döndürür.

Eğer k sağlanmazsa, 0 (ana diyagonal ile ilişkili) olduğu varsayılır.

Ayrıca bakınız: diag, diagm, Diagonal.

Örnekler

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

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

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

diag(M, k::Integer=0)

Bir matrisin k'nci diyagonalını, bir vektör olarak.

Ayrıca bkz. diagm, diagind, Diagonal, isdiag.

Örnekler

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

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

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

`Pair`'lerin diyagonal ve vektörlerden oluşan bir matris oluşturur. Vektör `kv.second`, `kv.first` diyagonalinde yer alacaktır. Varsayılan olarak matris kare olup boyutu `kv`'den çıkarılır, ancak `m,n`'yi ilk argümanlar olarak geçirerek dikdörtgen bir boyut `m`×`n` (gerekirse sıfırlarla doldurulmuş) belirtilebilir. Tekrar eden diyagonal indeksleri `kv.first` için, karşılık gelen vektörlerdeki `kv.second` değerleri toplanacaktır.

`diagm`, tam bir matris oluşturur; eğer hızlı aritmetik ile depolama verimli versiyonlar istiyorsanız, [`Diagonal`](@ref), [`Bidiagonal`](@ref) [`Tridiagonal`](@ref) ve [`SymTridiagonal`](@ref) bakın.

# Örnekler

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

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

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

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

Bir matris oluşturur ve vektörün elemanlarını köşegen elemanlar olarak kullanır. Varsayılan olarak, matris kare olup boyutu length(v) ile belirlenir, ancak m,n ilk argümanlar olarak geçilerek dikdörtgen bir boyut m×n belirtilebilir.

Örnekler

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

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

QR faktorizasyonunun derecesini döndürür

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

S'nin sıralamasını, QR faktörizasyonunu hesaplayarak hesaplayın. tol'dan daha küçük değerler sıfır olarak kabul edilir. SPQR'nin kılavuzuna bakın.

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

Bir matrisin sayısal sırasını, svdvals(A) çıktılarından kaç tanesinin max(atol, rtol*σ₁) değerinden büyük olduğunu sayarak hesaplayın; burada σ₁, A'nın hesaplanan en büyük tekil değeridir. atol ve rtol sırasıyla mutlak ve göreli toleranslardır. Varsayılan göreli tolerans n*ϵ'dir; burada n, A'nın en küçük boyutunun boyutudur ve ϵ, A'nın eleman türünün eps değeridir.

Örnekler

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

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

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

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

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

norm(A, p::Real=2)

Herhangi bir sayılar (veya norm'un tanımlı olduğu herhangi bir eleman türü) içeren A adlı iterable konteyner için, A'yı ilgili uzunluktaki bir vektör gibi kabul ederek p-normunu (varsayılan olarak p=2) hesaplayın.

p-normu şu şekilde tanımlanır:

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

burada $a_i$ A'nın elemanları, $| a_i |$ a_i'nin norm değeri ve $n$ A'nın uzunluğudur. p-normu, A'nın elemanlarının norm değerleri kullanılarak hesaplandığı için, p != 2 olduğunda bir vektörler vektörünün p-normu, genel olarak bir blok vektör olarak yorumlanmasıyla uyumlu değildir.

p, herhangi bir sayısal değeri alabilir (her ne kadar tüm değerler matematiksel olarak geçerli bir vektör normu üretmese de). Özellikle, norm(A, Inf) abs.(A) içindeki en büyük değeri döndürürken, norm(A, -Inf) en küçük değeri döndürür. Eğer A bir matris ise ve p=2 ise, bu Frobenius normuna eşdeğerdir.

İkinci argüman p, norm arayüzünün bir parçası olmak zorunda değildir; yani, özel bir tür yalnızca norm(A)'yi ikinci argüman olmadan uygulayabilir.

Bir matrisin operatör normunu hesaplamak için opnorm kullanın.

Örnekler

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

julia> norm(v)
7.0

julia> norm(v, 1)
11.0

julia> norm(v, Inf)
6.0

julia> norm([1 2 3; 4 5 6; 7 8 9])
16.881943016134134

julia> norm([1 2 3 4 5 6 7 8 9])
16.881943016134134

julia> norm(1:9)
16.881943016134134

julia> norm(hcat(v,v), 1) == norm(vcat(v,v), 1) != norm([v,v], 1)
true

julia> norm(hcat(v,v), 2) == norm(vcat(v,v), 2) == norm([v,v], 2)
true

julia> norm(hcat(v,v), Inf) == norm(vcat(v,v), Inf) != norm([v,v], Inf)
true

norm(x::Number, p::Real=2)

Sayılar için, $\left( |x|^p \right)^{1/p}$ değerini döndür.

Örnekler

julia> norm(2, 1)
2.0

julia> norm(-2, 1)
2.0

julia> norm(2, 2)
2.0

julia> norm(-2, 2)
2.0

julia> norm(2, Inf)
2.0

julia> norm(-2, Inf)
2.0

opnorm(A::AbstractMatrix, p::Real=2)

Vektör p-normu tarafından indüklenen operatör normunu (veya matris normunu) hesaplayın; burada geçerli p değerleri 1, 2 veya Inf'dir. (Seyrek matrisler için, p=2 şu anda uygulanmamıştır.) Frobenius normunu hesaplamak için norm kullanın.

p=1 olduğunda, operatör normu A'nın maksimum mutlak sütun toplamıdır:

\[\|A\|_1 = \max_{1 ≤ j ≤ n} \sum_{i=1}^m | a_{ij} |\]

burada $a_{ij}$, $A$'nın elemanlarıdır ve $m$ ile $n$ onun boyutlarıdır.

p=2 olduğunda, operatör normu spektral normdur ve A'nın en büyük tekil değerine eşittir.

p=Inf olduğunda, operatör normu A'nın maksimum mutlak satır toplamıdır:

\[\|A\|_\infty = \max_{1 ≤ i ≤ m} \sum _{j=1}^n | a_{ij} |\]

Örnekler

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

julia> opnorm(A, Inf)
6.0

julia> opnorm(A, 1)
5.0

opnorm(x::Number, p::Real=2)

Sayılar için, $\left( |x|^p \right)^{1/p}$ değerini döndür. Bu, norm ile eşdeğerdir.

opnorm(A::Adjoint{<:Any,<:AbstractVector}, q::Real=2)
opnorm(A::Transpose{<:Any,<:AbstractVector}, q::Real=2)

Adjoint/Transpose ile sarılmış vektörler için, A'nın operatör $q$-normunu döndürün; bu, p-normu ile p = q/(q-1) değeri ile eşdeğerdir. p = q = 2 olduğunda örtüşürler. A'nın bir vektör olarak p normunu hesaplamak için norm kullanın.

Bir vektör uzayı ile onun ikili arasındaki norm farkı, ikilik ve nokta çarpımı arasındaki ilişkiyi korumak için ortaya çıkar ve sonuç, 1 × n matrisinin operatör p-normu ile tutarlıdır.

Örnekler

julia> v = [1; im];

julia> vc = v';

julia> opnorm(vc, 1)
1.0

julia> norm(vc, 1)
2.0

julia> norm(v, 1)
2.0

julia> opnorm(vc, 2)
1.4142135623730951

julia> norm(vc, 2)
1.4142135623730951

julia> norm(v, 2)
1.4142135623730951

julia> opnorm(vc, Inf)
2.0

julia> norm(vc, Inf)
1.0

julia> norm(v, Inf)
1.0

normalize!(a::AbstractArray, p::Real=2)

Diziyi a'yı, p-normunun bir eşit olacak şekilde yerinde normalize et, yani norm(a, p) == 1. Ayrıca bkz. normalize ve norm.

normalize(a, p::Gerçek=2)

a'yı p-normunun birim olmasını sağlayacak şekilde normalize et, yani norm(a, p) == 1. Skalarlar için bu, sign(a)'ya benzer, ancak normalize(0) = NaN'dir. Ayrıca normalize!, norm ve sign ile de bakabilirsiniz.

Örnekler

julia> a = [1,2,4];

julia> b = normalize(a)
3-element Vector{Float64}:
 0.2182178902359924
 0.4364357804719848
 0.8728715609439696

julia> norm(b)
1.0

julia> c = normalize(a, 1)
3-element Vector{Float64}:
 0.14285714285714285
 0.2857142857142857
 0.5714285714285714

julia> norm(c, 1)
1.0

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

julia> norm(a)
6.48074069840786

julia> normalize(a)
2×3 Matrix{Float64}:
 0.154303  0.308607  0.617213
 0.154303  0.308607  0.617213

julia> normalize(3, 1)
1.0

julia> normalize(-8, 1)
-1.0

julia> normalize(0, 1)
NaN

cond(M, p::Gerçek=2)

Matris M'nin koşul sayısı, p-norm operatörü kullanılarak hesaplanır. p için geçerli değerler 1, 2 (varsayılan) veya Inf'dir.

condskeel(M, [x, p::Gerçek=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}\]

Matris M'nin Skeel koşul sayısı $\kappa_S$, isteğe bağlı olarak x vektörüne göre, p-norm operatörü kullanılarak hesaplanır. $\left\vert M \right\vert$, $M$'nin (eleman bazında) mutlak değerler matrisini ifade eder; $\left\vert M \right\vert_{ij} = \left\vert M_{ij} \right\vert$. p için geçerli değerler 1, 2 ve Inf'dir (varsayılan).

Bu miktar, literatürde Bauer koşul sayısı, göreceli koşul sayısı veya bileşen bazında göreceli koşul sayısı olarak da bilinir.

tr(M)

Matris izini. M'nin köşe elemanlarını toplar.

Örnekler

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

julia> tr(A)
5

det(M)

Matris determinantı.

Ayrıca bakınız: logdet ve logabsdet.

Örnekler

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

julia> det(M)
2.0

logdet(M)

Matris determinantının logaritması. log(det(M)) ile eşdeğerdir, ancak daha fazla doğruluk sağlayabilir ve taşma/azalma sorunlarını önleyebilir.

Örnekler

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

julia> logdet(M)
0.6931471805599453

julia> logdet(Matrix(I, 3, 3))
0.0

logabsdet(M)

Matris determinantının mutlak değerinin logaritması. (log(abs(det(M))), sign(det(M))) ile eşdeğerdir, ancak daha fazla doğruluk ve/veya hız sağlayabilir.

Örnekler

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

julia> det(A)
-1.0

julia> logabsdet(A)
(0.0, -1.0)

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

julia> det(B)
2.0

julia> logabsdet(B)
(0.6931471805599453, 1.0)

inv(M)

Matrisin tersi. M * N = I eşitliğini sağlayan N matrisini hesaplar; burada I birim matristir. Sol bölme N = M \ I çözülerek hesaplanır.

Örnekler

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

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

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

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

Moore-Penrose pseudoinversini hesaplar.

M matrisleri için, kayan nokta elemanları ile, pseudoinversi yalnızca max(atol, rtol*σ₁) değerinden büyük olan tekil değerleri ters çevirerek hesaplamak uygundur; burada σ₁, M'nin en büyük tekil değeridir.

Kesinlik (atol) ve göreceli tolerans (rtol) için en iyi seçim, hem M'nin değeri hem de pseudoinversin amaçlanan uygulaması ile değişir. Varsayılan göreceli tolerans n*ϵ'dir; burada n, M'nin en küçük boyutunun boyutudur ve ϵ, M'nin eleman türünün eps değeridir.

Yoğun, kötü koşullu matrisleri en küçük kareler anlamında ters çevirmek için rtol = sqrt(eps(real(float(oneunit(eltype(M)))))) önerilir.

Daha fazla bilgi için bkz. ^[issue8859], ^[B96], ^[S84], ^[KY88].

Örnekler

julia> M = [1.5 1.3; 1.2 1.9]
2×2 Matrix{Float64}:
 1.5  1.3
 1.2  1.9

julia> N = pinv(M)
2×2 Matrix{Float64}:
  1.47287   -1.00775
 -0.930233   1.16279

julia> M * N
2×2 Matrix{Float64}:
 1.0          -2.22045e-16
 4.44089e-16   1.0

nullspace(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
nullspace(M, rtol::Real) = nullspace(M; rtol=rtol) # Julia 2.0'da kullanılmayacak

`M`'nin nullspace'inin bir tabanını, `M`'nin en büyük singular değeri `σ₁` için `max(atol, rtol*σ₁)` değerinden daha küçük büyüklüğe sahip singular vektörlerini dahil ederek hesaplar.

Varsayılan olarak, göreceli tolerans `rtol`, `M`'nin en küçük boyutunun büyüklüğü `n` ve `M`'nin eleman tipinin [`eps`](@ref) ile `ϵ`'dir.

# Örnekler

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

julia> nullspace(M) 3×1 Matrix{Float64}: 0.0 0.0 1.0

julia> nullspace(M, rtol=3) 3×3 Matrix{Float64}: 0.0 1.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0

julia> nullspace(M, atol=0.95) 3×1 Matrix{Float64}: 0.0 0.0 1.0 ```

kron(A, B)

İki vektörün, matrisin veya sayının Kronecker çarpımını hesaplar.

Gerçek vektörler v ve w için, Kronecker çarpımı dış çarpımla kron(v,w) == vec(w * transpose(v)) veya w * transpose(v) == reshape(kron(v,w), (length(w), length(v))) ile ilişkilidir. Bu ifadelerin sol ve sağ tarafındaki v ve w sıralamasının nasıl farklılık gösterdiğine dikkat edin (sütun-birincil depolama nedeniyle). Karmaşık vektörler için, dış çarpım w * v' de v'nin karmaşık eşleniği ile farklılık gösterir.

Örnekler

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

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

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

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

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

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

kron!(C, A, B)

A ve B'nin Kronecker çarpımını hesaplar ve sonucu C'ye yazarak C'nin mevcut içeriğini üzerine yazar. Bu, kron fonksiyonunun yerinde versiyonudur.

exp(A::AbstractMatrix)

A matrisinin üstelini hesaplayın, tanımıyla

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

Simetrik veya Hermit A için, bir özdeğişim (eigen) kullanılır, aksi takdirde ölçekleme ve kareleme algoritması seçilir (bkz. ^[H05]).

Örnekler

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

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

cis(A::AbstractMatrix)

Kare matris A için exp(im*A)'nın daha verimli bir yöntemi (özellikle A Hermitian veya gerçek Simetrik ise).

Ayrıca bkz. cispi, sincos, exp.

Örnekler

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

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

Matris kuvveti, $\exp(p\log(A))$ ile eşdeğerdir.

Örnekler

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

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

Matris üstel, $\exp(\log(b)A)$ ile eşdeğerdir.

Örnekler

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

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

log(A::AbstractMatrix)

Eğer A negatif gerçek özdeğere sahip değilse, A'nın ana matris logaritmasını hesaplayın, yani $e^X = A$ ve $-\pi < Im(\lambda) < \pi$ koşulunu sağlayan, X matrisinin benzersiz matrisini hesaplayın; burada X'in tüm özdeğerleri $\lambda$'dır. Eğer A'nın negatif veya sıfır özdeğerleri varsa, mümkün olduğunda bir ana olmayan matris fonksiyonu döndürülür.

Eğer A simetrik veya Hermit ise, özdeğişimi (eigen) kullanılır, eğer A üçgen bir matris ise, ters ölçekleme ve kare alma yönteminin geliştirilmiş bir versiyonu uygulanır (bkz. ^[AH12] ve ^[AHR13]). Eğer A negatif özdeğere sahip olmayan gerçek bir matris ise, gerçek Schur formu hesaplanır. Aksi takdirde, karmaşık Schur formu hesaplanır. Daha sonra, ^[AHR13]’teki üst (kuazi-) üçgen algoritması, üst (kuazi-) üçgen faktör üzerinde kullanılır.

Örnekler

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

√(x)

Sonuç $\sqrt{x}$.

Negatif Real argümanlar için DomainError fırlatır. Bunun yerine karmaşık negatif argümanlar kullanın. sqrt'ın negatif reel eksen boyunca bir dal kesimi olduğunu unutmayın.

Önek operatör √, sqrt ile eşdeğerdir.

Ayrıca bkz: hypot.

Örnekler

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
HATA: -81.0 ile DomainError:
NaN girişi için NaN olmayan sonuç.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

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

julia> sqrt(-81 - 0.0im)  # -0.0im dal kesiminin altında
0.0 - 9.0im

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

sqrt(A::AbstractMatrix)

Eğer A negatif gerçek özdeğerlere sahip değilse, A'nın ana matris karekökünü hesaplayın, yani $X^2 = A$ olacak şekilde pozitif gerçek parçaya sahip özdeğerlere sahip olan benzersiz matris. Aksi takdirde, bir nonprincipal karekök döndürülür.

Eğer A gerçek-simetrik veya Hermit ise, karekökü hesaplamak için özdeğerlendirmesi (eigen) kullanılır. Bu tür matrisler için, yuvarlama hataları nedeniyle hafif negatif görünen özdeğerler sıfırmış gibi kabul edilir. Daha kesin olarak, tüm özdeğerleri ≥ -rtol*(max |λ|) olan matrisler yarı belirli olarak kabul edilir (Hermit karekökü verir), negatif özdeğerler sıfır olarak alınır. rtol, sqrt'a (sadece Hermit/gerçek-simetrik durumda) varsayılan olarak size(A,1) ile ölçeklendirilmiş makine hassasiyeti olan bir anahtar argümandır.

Aksi takdirde, karekök, karmaşık Schur formunu (schur) hesaplayan ve ardından üçgen faktörün karmaşık karekökünü hesaplayan Björck-Hammarling yöntemi ile belirlenir. Eğer gerçek bir karekök varsa, bu yöntemin ^[H87] gerçek Schur formunu hesaplayan ve ardından quasi-üçgen faktörün gerçek karekökünü hesaplayan bir uzantısı kullanılır.

Örnekler

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

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

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

Gerçek değerli bir matris A'nın gerçek değerli küp kökünü hesaplar. Eğer T = cbrt(A) ise, o zaman T*T*T ≈ A olur, aşağıda verilen örneğe bakınız.

Eğer A simetrikse, yani HermOrSym{<:Real} türündeyse, o zaman (eigen) küp kökü bulmak için kullanılır. Aksi takdirde, küp kökünü hesaplamak için gerçek değerli Schur ayrıştırmasını (schur) kullanan p-inci kök algoritmasının özel bir versiyonu ^[S03] kullanılmaktadır.

Örnekler

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

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

julia> T*T*T ≈ A
true

cos(A::AbstractMatrix)

Kare matris A'nın matris kosinüsünü hesaplar.

Eğer A simetrik veya Hermit ise, kosinüsü hesaplamak için özdekompozisyonu (eigen) kullanılır. Aksi takdirde, kosinüs exp çağrılarak belirlenir.

Örnekler

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

sin(A::AbstractMatrix)

Kare matris A'nın matris sinüsünü hesaplar.

Eğer A simetrik veya Hermit ise, sinüs hesaplamak için özdekompozisyonu (eigen) kullanılır. Aksi takdirde, sinüs exp çağrılarak belirlenir.

Örnekler

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

sincos(A::AbstractMatrix)

Bir kare matris A için matris sinüs ve kosinüsünü hesaplar.

Örnekler

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

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

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

tan(A::AbstractMatrix)

Bir kare matris Anın matris tanjantını hesaplar.

Eğer A simetrik veya Hermit ise, tanjantı hesaplamak için özdeğişim (eigen) kullanılır. Aksi takdirde, tanjant exp çağrılarak belirlenir.

Örnekler

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

sec(A::AbstractMatrix)

Kare matris A'nın matris sekantını hesaplar.

csc(A::AbstractMatrix)

Kare matris A'nın matris koskecantını hesaplar.

cot(A::AbstractMatrix)

Kare matris A'nın kotanjantını hesaplar.

cosh(A::AbstractMatrix)

Bir kare matris A'nın matris hiperbolik kosinüsünü hesaplar.

sinh(A::AbstractMatrix)

Bir kare matris A'nın matris hiperbolik sinüsünü hesaplar.

tanh(A::AbstractMatrix)

Bir kare matris A'nın matris hiperbolik tanjantını hesaplar.

sech(A::AbstractMatrix)

Kare matris A'nın hiperbolik secantını hesaplar.

csch(A::AbstractMatrix)

Kare matris A'nın hiperbolik cosecant'ını hesaplar.

coth(A::AbstractMatrix)

Kare matris A'nın hiperbolik kotanjantını hesaplar.

acos(A::AbstractMatrix)

Bir kare matris A'nın ters matris kosinüsünü hesaplar.

Eğer A simetrik veya Hermit ise, ters kosinüs hesaplamak için özdeğişim (eigen) kullanılır. Aksi takdirde, ters kosinüs log ve sqrt kullanılarak belirlenir. Bu fonksiyonu hesaplamak için kullanılan teori ve logaritmik formüller için bkz. ^[AH16_1].

Örnekler

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

asin(A::AbstractMatrix)

Bir kare matris A'nın ters matris sinüsünü hesaplar.

Eğer A simetrik veya Hermit ise, ters sinüs hesaplamak için özdekompozisyon (eigen) kullanılır. Aksi takdirde, ters sinüs log ve sqrt kullanılarak belirlenir. Bu fonksiyonu hesaplamak için kullanılan teori ve logaritmik formüller için bkz. ^[AH16_2].

Örnekler

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

atan(A::AbstractMatrix)

Bir kare matris A'nın ters matris tanjantını hesaplar.

Eğer A simetrik veya Hermit ise, ters tanjantı hesaplamak için özdeğişim (eigen) kullanılır. Aksi takdirde, ters tanjant log kullanılarak belirlenir. Bu fonksiyonu hesaplamak için kullanılan teori ve logaritmik formüller için bkz. ^[AH16_3].

Örnekler

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

asec(A::AbstractMatrix)

A'nın ters matris sekantını hesaplar.

acsc(A::AbstractMatrix)

A matrisinin ters matris kosekanti hesaplanır.

acot(A::AbstractMatrix)

A matrisinin ters kotanjantını hesaplar.

acosh(A::AbstractMatrix)

Bir kare matris A için ters hiperbolik matris kosinüsünü hesaplar. Bu fonksiyonu hesaplamak için kullanılan teori ve logaritmik formüller için bkz. ^[AH16_4].

asinh(A::AbstractMatrix)

Bir kare matris A için ters hiperbolik matris sinüsünü hesaplar. Bu fonksiyonu hesaplamak için kullanılan teori ve logaritmik formüller için bkz. ^[AH16_5].

atanh(A::AbstractMatrix)

Bir kare matris A için ters hiperbolik matris tanjantını hesaplar. Bu fonksiyonu hesaplamak için kullanılan teori ve logaritmik formüller için bkz. ^[AH16_6].

asech(A::AbstractMatrix)

A'nın ters matris hiperbolik sekantını hesaplar.

acsch(A::AbstractMatrix)

A'n ters matris hiperbolik kosinüsünü hesaplar.

acoth(A::AbstractMatrix)

A'nın ters matris hiperbolik kotanjantını hesaplar.

lyap(A, C)

Sürekli Lyapunov denklemi AX + XA' + C = 0 için X çözümünü hesaplar; burada A'nın hiçbir özdeğeri sıfır reel parçaya sahip değildir ve iki özdeğeri birbirinin negatif karmaşık eşleniği değildir.

Örnekler

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

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

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

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

sylvester(A, B, C)

Sylvester denklemi AX + XB + C = 0 için çözüm X'i hesaplar; burada A, B ve C uyumlu boyutlara sahiptir ve A ile -B'nin eşit gerçek parçaya sahip özdeğerleri yoktur.

Örnekler

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

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

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

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

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

issuccess(F::Factorization)

Bir matrisin faktorizasyonunun başarılı olup olmadığını test eder.

Örnekler

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

julia> issuccess(F)
true

issuccess(F::LU; allowsingular = false)

Bir matrisin LU faktörizasyonunun başarılı olup olmadığını test eder. Varsayılan olarak, geçerli ancak sıralı eksik U faktörü üreten bir faktörizasyon başarısız olarak kabul edilir. Bu, allowsingular = true geçerek değiştirilebilir.

Örnekler

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

julia> issuccess(F)
false

julia> issuccess(F, allowsingular = true)
true

issymmetric(A) -> Bool

Bir matrisin simetrik olup olmadığını test eder.

Örnekler

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

julia> issymmetric(a)
true

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

julia> issymmetric(b)
false

isposdef(A) -> Bool

Bir matrisin pozitif tanımlı (ve Hermit) olup olmadığını A'nın Cholesky faktörizasyonunu gerçekleştirmeye çalışarak test eder.

Ayrıca bkz. isposdef!, cholesky.

Örnekler

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

julia> isposdef(A)
true

isposdef!(A) -> Bool

Bir matrisin pozitif tanımlı (ve Hermit) olup olmadığını, A üzerinde Cholesky faktörizasyonu yapmaya çalışarak test eder, bu süreçte A'yı üzerine yazar. Ayrıca isposdef bakınız.

Örnekler

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

julia> isposdef!(A)
true

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

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

A'nın k'nci süperdiagonalden itibaren alt üçgensel olup olmadığını test eder.

Örnekler

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

julia> istril(a)
false

julia> istril(a, 1)
true

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

julia> istril(c)
false

julia> istril(c, 1)
true

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

A'n k'nci süperdiagonalından başlayarak üst üçgen olup olmadığını test edin.

Örnekler

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

julia> istriu(a)
false

julia> istriu(a, -1)
true

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

julia> istriu(c)
false

julia> istriu(c, -1)
true

isdiag(A) -> Bool

Bir matrisin, iszero(A[i,j]) ifadesinin i == j olmadığı sürece doğru olduğu anlamında diyagonal olup olmadığını test eder. A'nın kare olması gerekmez; eğer bunu da kontrol etmek istiyorsanız, size(A, 1) == size(A, 2) kontrolünü yapmanız gerekir.

Örnekler

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

julia> isdiag(a)
false

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

julia> isdiag(b)
true

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

julia> isdiag(c)
true

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

julia> isdiag(d)
false

ishermitian(A) -> Bool

Bir matrisin Hermit olup olmadığını test eder.

Örnekler

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

julia> ishermitian(a)
true

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

julia> ishermitian(b)
true

transpose(A)

Tembel transpoze. Döndürülen nesnenin değiştirilmesi, A'yı uygun şekilde değiştirmelidir. Genellikle, ama her zaman değil, Transpose(A) verir; burada Transpose, tembel bir transpoze sarmalayıcıdır. Bu işlemin özyinelemeli olduğunu unutmayın.

Bu işlem, lineer cebir kullanımı için tasarlanmıştır - genel veri manipülasyonu için permutedims bakın, bu özyinelemeli değildir.

Örnekler

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 # bir transpozenin transpozu üst nesneyi açar
true

julia> Transpose(B) # ancak, yapıcı her zaman argümanını sarar
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
 3  2
 0  0

julia> B[1,2] = 4; # B'yi değiştirmek A'yı otomatik olarak değiştirecektir

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

Karmaşık matrisler için adjoint işlemi, bir konjugat-transpoze ile eşdeğerdir.

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

Bir AbstractVector'ın transpose'u bir satır vektörüdür:

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

julia> transpose(v) # bir satır vektörü döndürür
1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> transpose(v) * v # nokta çarpımını hesapla
14

Matrislerden oluşan bir matris için, bireysel bloklar özyinelemeli olarak işlenir:

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

julia> D = reshape([C, 2C, 3C, 4C], 2, 2) # bir blok matris oluştur
2×2 Matrix{Matrix{Int64}}:
 [1 3; 2 4]  [3 9; 6 12]
 [2 6; 4 8]  [4 12; 8 16]

julia> transpose(D) # bloklar özyinelemeli olarak transpoze edilir
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 2; 3 4]   [2 4; 6 8]
 [3 6; 9 12]  [4 8; 12 16]

transpose(F::Factorization)

F faktorizasyonunun tembel transpozunu döndürür. Varsayılan olarak, gerçek eltype'a sahip Factorization'lar hariç, bir TransposeFactorization döndürür; bu durumda bir AdjointFactorization döndürür.

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

Matris A'yı transpoze eder ve sonucu X matrisine kaydeder. size(X) değeri size(transpose(A)) ile eşit olmalıdır. Gerekirse yalnızca X'in rowval ve nzval'ını yeniden boyutlandırmak dışında ek bellek tahsis edilmez.

halfperm!'e bakınız.

transpose!(dest,src)

Dizi src'yi transpoze edin ve sonucu önceden tahsis edilmiş dest dizisine kaydedin; bu dizinin boyutu (size(src,2),size(src,1)) ile uyumlu olmalıdır. Yerinde transpozisyon desteklenmez ve src ile dest'in örtüşen bellek bölgeleri varsa beklenmedik sonuçlar ortaya çıkabilir.

Örnekler

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

Transpoze

Temel lineer cebir nesnesinin, genellikle bir AbstractVector/AbstractMatrix'in transpoze görünümü için tembel bir sarmalayıcı türü. Genellikle, Transpose yapıcısı doğrudan çağrılmamalıdır, bunun yerine transpose kullanın. Görünümü somutlaştırmak için copy kullanın.

Bu tür, lineer cebir kullanımı için tasarlanmıştır - genel veri manipülasyonu için permutedims kullanın.

Örnekler

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

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

TransposeFactorization

Temel Factorization nesnesinin transpozu için tembel sarmalayıcı türü. Genellikle, TransposeFactorization yapıcısı doğrudan çağrılmamalıdır, bunun yerine transpose(:: Factorization) kullanın.

A'
adjoint(A)

Tembel adjoint (karmaşık transpozisyon). adjoint'in elemanlara özyinelemeli olarak uygulandığını unutmayın.

Sayı türleri için adjoint, karmaşık eşleniği döndürür ve bu nedenle gerçek sayılar için kimlik fonksiyonu ile eşdeğerdir.

Bu işlem, lineer cebir kullanımı için tasarlanmıştır - genel veri manipülasyonu için permutedims bakın.

Örnekler

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

julia> B = A' # eşdeğer olarak 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 # bir adjoint'in adjoint'i üst öğeyi açar
true

julia> Adjoint(B) # ancak, yapıcı her zaman argümanını sarar
2×2 adjoint(adjoint(::Matrix{Complex{Int64}})) with eltype Complex{Int64}:
 3+2im  9+2im
 0+0im  0+0im

julia> B[1,2] = 4 + 5im; # B'yi değiştirmek A'yı otomatik olarak değiştirir

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 4-5im  0+0im

Gerçek matrisler için adjoint işlemi, bir transpose ile eşdeğerdir.

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

Bir AbstractVector'ın adjoint'i bir satır vektörüdür:

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 # nokta çarpımını hesapla, eşdeğer olarak x' * x
25 + 0im

Matrislerin matrisleri için, bireysel bloklar özyinelemeli olarak işlenir:

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

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

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

adjoint(F::Factorization)

Faktorizasyon F'nin tembel adjoint'u. Varsayılan olarak, bir AdjointFactorization sarmalayıcı döner.

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

Matris A'nın transpozunu alır ve X matrisindeki elemanların adjoint'ini depolar. size(X) değeri size(transpose(A)) ile eşit olmalıdır. X'in rowval ve nzval'ını yeniden boyutlandırmak gerekirse, başka bir bellek tahsisi yapılmaz.

halfperm!'e bakınız.

adjoint!(dest,src)

Karmaşık transpoze dizisi src'yi alır ve sonucu önceden tahsis edilmiş dest dizisine kaydeder; bu dizinin boyutu (size(src,2),size(src,1)) ile uyumlu olmalıdır. Yerinde transpozisyon desteklenmez ve src ile dest'in örtüşen bellek bölgeleri varsa beklenmedik sonuçlar ortaya çıkabilir.

Örnekler

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

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

julia> adjoint!(B, A);

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

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

Adjoint

Temel lineer cebir nesnesinin, genellikle bir AbstractVector/AbstractMatrix olan, adjoint görünümünün tembel sarmalayıcı türü. Genellikle, Adjoint yapıcısı doğrudan çağrılmamalıdır, bunun yerine adjoint kullanın. Görünümü somutlaştırmak için copy kullanın.

Bu tür, lineer cebir kullanımı için tasarlanmıştır - genel veri manipülasyonu için permutedims kullanın.

Örnekler

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

julia> Adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

AdjointFactorization

Temel Factorization nesnesinin adjoint'u için tembel sarmalayıcı türü. Genellikle, AdjointFactorization yapıcı fonksiyonu doğrudan çağrılmamalıdır, bunun yerine adjoint(:: Factorization) kullanın.

copy(A::Transpose)
copy(A::Adjoint)

Tembel matris transpozu/adjoint'ını hevesle değerlendirir. Transpozisyonun elemanlara özyinelemeli olarak uygulandığını unutmayın.

Bu işlem, lineer cebir kullanımı için tasarlanmıştır - genel veri manipülasyonu için permutedims bakın, bu özyinelemeli değildir.

Örnekler

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

julia> T = transpose(A)
2×2 transpose(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 1+0im  0-3im
 0+2im  4+0im

julia> copy(T)
2×2 Matrix{Complex{Int64}}:
 1+0im  0-3im
 0+2im  4+0im

stride1(A) -> Int

Başka bir deyişle, eleman boyutu cinsinden boyut 1'deki ardışık dizi elemanları arasındaki mesafeyi döndürür.

Örnekler

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

julia> LinearAlgebra.stride1(A)
1

julia> B = view(A, 2:2:4)
2-element view(::Vector{Int64}, 2:2:4) with eltype Int64:
 2
 4

julia> LinearAlgebra.stride1(B)
2

LinearAlgebra.checksquare(A)

Bir matrisin kare olup olmadığını kontrol edin, ardından ortak boyutunu döndürün. Birden fazla argüman için, bir vektör döndürün.

Örnekler

julia> A = fill(1, (4,4)); B = fill(1, (5,5));

julia> LinearAlgebra.checksquare(A, B)
2-element Vector{Int64}:
 4
 5

LinearAlgebra.peakflops(n::Integer=4096; eltype::DataType=Float64, ntrials::Integer=3, parallel::Bool=false)

peakflops, bilgisayarın tepe flop oranını, çift hassasiyet gemm! kullanarak hesaplar. Varsayılan olarak, eğer hiçbir argüman belirtilmemişse, n x n boyutunda iki Float64 matrisini çarpar; burada n = 4096'dır. Temel BLAS çoklu iş parçacığı kullanıyorsa, daha yüksek flop oranları elde edilir. BLAS iş parçacığı sayısı BLAS.set_num_threads(n) ile ayarlanabilir.

Eğer eltype anahtar kelime argümanı sağlanırsa, peakflops, tepe flop oranını hesaplamak için eltype türünde elemanlara sahip matrisler oluşturur.

Varsayılan olarak, peakflops, 3 denemeden en iyi zamanlamayı kullanır. Eğer ntrials anahtar kelime argümanı sağlanırsa, peakflops, en iyi zamanlamayı seçmek için belirtilen kadar deneme yapar.

Eğer parallel anahtar kelime argümanı true olarak ayarlanırsa, peakflops, tüm işçi işlemcilerinde paralel olarak çalıştırılır. Tüm paralel bilgisayarın flop oranı döndürülür. Paralel çalışırken yalnızca 1 BLAS iş parçacığı kullanılır. n argümanı, her işlemcide çözülen problemin boyutunu ifade etmeye devam eder.

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

Kare matris A'nın Hermit kısmını döndürür; bu, (A + A') / 2 olarak tanımlanır ve bir Hermitian matrisidir. Gerçek matrisler A için bu, A'nın simetrik kısmı olarak da bilinir; bazen "operatör gerçek kısmı" olarak da adlandırılır. İsteğe bağlı uplo argümanı, Hermitian görünümünün karşılık gelen argümanını kontrol eder. Gerçek matrisler için, bu sonuncusu bir Symmetric görünümüne eşdeğerdir.

Ayrıca, karşılık gelen yerinde işlem için hermitianpart! fonksiyonuna da bakın.

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

Kare matris A'yı yerinde Hermit kısmı (A + A') / 2 ile üzerine yazın ve Hermitian(A, uplo) döndürün. Gerçek matrisler A için bu, A'nın simetrik kısmı olarak da bilinir.

Ayrıca hermitianpart ile ilgili yer dışı işlemi için bakın.

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

Matris A'nın elemanlarını B'ye adjunction ile aşağıdaki gibi verimli bir şekilde kopyalayın:

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

B[ir_dest, jr_dest] elemanları üzerine yazılır. Ayrıca, indeks aralığı parametreleri length(ir_dest) == length(jr_src) ve length(jr_dest) == length(ir_src) koşulunu sağlamalıdır.

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

Matris A'nın elemanlarını B'ye transpoze ederek verimli bir şekilde kopyalayın:

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

B[ir_dest, jr_dest] elemanları üzerine yazılır. Ayrıca, indeks aralığı parametreleri length(ir_dest) == length(jr_src) ve length(jr_dest) == length(ir_src) koşulunu sağlamalıdır.

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

Matris M'nin elemanlarını B'ye, karakter parametresi tM'ye bağlı olarak verimli bir şekilde kopyalayın:

Elemanlar B[ir_dest, jr_dest] üzerine yazılır. Ayrıca, indeks aralığı parametreleri length(ir_dest) == length(jr_src) ve length(jr_dest) == length(ir_src) koşulunu sağlamalıdır.

Ayrıca copyto! ve copy_adjoint! ile de bakabilirsiniz.

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

Matris-matris veya matris-vektör çarpımını $A B$ hesaplar ve sonucu Y'de saklar, mevcut Y değerini geçersiz kılar. Y'nin A veya B ile aynı referansı taşımaması gerektiğini unutmayın.

Örnekler

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

Uygulama

Özel matris ve vektör türleri için, mümkünse 3-argümanlı mul!'yi doğrudan uygulamak yerine 5-argümanlı mul!'yi uygulamanız önerilir.

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

Birleştirilmiş yerinde matris-matris veya matris-vektör çarpma-toplama $A B α + C β$. Sonuç C'de saklanır ve üzerine yazılır. C'nin A veya B ile aynı olmaması gerektiğini unutmayın.

Örnekler

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

julia> α, β = 100.0, 10.0;

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

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

julia> C_original = [1.0 2.0; 3.0 4.0]; # C'nin orijinal değerinin bir kopyası

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

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

Bir diziyi B bir skalar a ile ölçeklendirir ve B'yi yerinde günceller. Skaların sağdan çarpılması için rmul! kullanın. Ölçeklendirme işlemi, a ile B'nin bir elemanı arasındaki çarpmanın * anlamlarını dikkate alır. Özellikle, bu durum NaN ve ±Inf gibi sonlu olmayan sayılarla çarpma işlemlerine de uygulanır.

Örnekler

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

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

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

lmul!(A, B)

Matris-matris çarpımını $AB$ hesaplayın, B'yi üzerine yazarak sonucu döndürün. Burada, A özel matris türünde olmalıdır, örneğin, Diagonal, UpperTriangular veya LowerTriangular gibi, ya da bazı ortogonal türlerde, bkz. QR.

Örnekler

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

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

julia> lmul!(A, B);

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

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

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

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

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

Bir diziyi A bir skalar b ile ölçeklendirir ve A'yı yerinde yazar. Skaların soldan çarpılması için lmul! kullanın. Ölçekleme işlemi, A'nın bir elemanı ile b arasındaki çarpma * anlamlarını dikkate alır. Özellikle, bu durum NaN ve ±Inf gibi sonlu olmayan sayılarla çarpma işlemlerine de uygulanır.

Örnekler

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

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

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

rmul!(A, B)

Matris-matris çarpımını $AB$ hesaplayın, A'yı üzerine yazarak sonucu döndürün. Burada, B özel matris türünde olmalıdır, örneğin, Diagonal, UpperTriangular veya LowerTriangular gibi, ya da bazı ortogonal türlerde, bkz. QR.

Örnekler

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

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

julia> rmul!(A, B);

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

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

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

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

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

A \ B işlemini yerinde hesaplayın ve sonucu Y'ye kaydedin, sonucu döndürün.

A argümanı matris olmamalıdır. Bunun yerine, matrisler yerine bir faktorizasyon nesnesi olmalıdır (örneğin, factorize veya cholesky ile üretilmiş). Bunun nedeni, faktorizasyonun hem maliyetli olması hem de genellikle bellek ayırmasıdır (ancak, örneğin, lu! ile yerinde de yapılabilir) ve ldiv!'ı gerektiren performans kritik durumlar genellikle A'nın faktorizasyonu üzerinde ince ayar kontrolü gerektirir.

Örnekler

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

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

julia> Y = zero(X);

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

julia> Y ≈ A\X
true

ldiv!(A, B)

A \ B'yi yerinde hesaplayarak B'yi sonuçla günceller.

A argümanı matris olmamalıdır. Bunun yerine, matrisler yerine bir faktorizasyon nesnesi olmalıdır (örneğin, factorize veya cholesky ile üretilmiş). Bunun nedeni, faktorizasyonun hem pahalı olması hem de genellikle bellek ayırmasıdır (ancak, örneğin, lu! ile yerinde de yapılabilir) ve ldiv!'i gerektiren performans kritik durumlar genellikle A'nın faktorizasyonu üzerinde ince ayar kontrolü gerektirir.

Örnekler

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

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

julia> Y = copy(X);

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

julia> X ≈ A\Y
true

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

Bir dizi B'deki her bir girişi bir skalar a ile bölerek B'yi yerinde günceller. Sağdan skalar bölmek için rdiv! kullanın.

Örnekler

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

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

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

A \ B işlemini, kısmi pivotlama ile Gauss eliminasyonu kullanarak yerinde hesaplayın ve sonucu B'ye kaydedin, sonucu döndürün. Bu süreçte, A'nın diyagonal elemanları da üzerine yazılır.

rdiv!(A, B)

A / B işlemini yerinde hesaplar ve sonucu saklamak için A'yı günceller.

B argümanı bir matris olmamalıdır. Bunun yerine, matrisler yerine bir faktorizasyon nesnesi (örneğin, factorize veya cholesky ile üretilmiş) olmalıdır. Bunun nedeni, faktorizasyonun hem pahalı olması hem de genellikle bellek ayırmasıdır (ancak, örneğin, lu! aracılığıyla yerinde de yapılabilir) ve rdiv! gerektiren performans kritik durumlar genellikle B'nin faktorizasyonu üzerinde ince ayar kontrolü gerektirir.

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

Bir dizideki her bir girişi bir skalar b ile bölerek A'yı yerinde günceller. Soldan skalar bölmek için ldiv! kullanın.

Örnekler

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

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

BLAS alt programlarına arayüz.

set_num_threads(n::Integer)
set_num_threads(::Nothing)

BLAS kütüphanesinin kullanacağı iş parçacığı sayısını n::Integer olarak ayarlayın.

Ayrıca nothing kabul eder, bu durumda julia varsayılan iş parçacığı sayısını tahmin etmeye çalışır. nothing geçmek önerilmez ve esasen tarihsel nedenlerle mevcuttur.

get_num_threads()

BLAS kütüphanesinin kullandığı iş parçacığı sayısını alır.

rot!(n, X, incx, Y, incy, c, s)

X'i c*X + s*Y ile ve Y'yi -conj(s)*X + c*Y ile ilk n elemanı incx adım aralığına sahip dizi X için ve ilk n elemanı incy adım aralığına sahip dizi Y için üst üste yazar. X ve Y'yi döner.

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

Dizinin ilk n elemanını incx adımıyla a*X ile değiştirmek için X'i üzerine yazar. X'i döndürür.

Eğer n ve incx sağlanmamışsa, length(X) ve stride(X,1) kullanılır.

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

Dizinin X ilk n elemanını a ile ölçeklendirir ve incx adım boyutunu kullanır.

Eğer n ve incx sağlanmamışsa, length(X) ve stride(X,1) kullanılır.

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

Dizi X'in incx adımındaki n elemanını dizi Y'ye incy adımıyla kopyalar. Y'yi döner.

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

İki vektörün nokta çarpımı, incx adımıyla X dizisinin n elemanını ve incy adımıyla Y dizisinin n elemanını içerir.

Örnekler

julia> BLAS.dot(10, fill(1.0, 10), 1, fill(1.0, 20), 2)
10.0

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

İki karmaşık vektör için nokta fonksiyonu, incx adımıyla X dizisinin n elemanını ve incy adımıyla Y dizisinin n elemanını içerir.

Örnekler

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

dotc(n, X, incx, U, incy)

İki karmaşık vektör için Dot fonksiyonu, incx adımıyla X dizisinin n elemanını ve incy adımıyla U dizisinin n elemanını alır, ilk vektörü konjuge eder.

Örnekler

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

nrm2(n, X, incx)

X dizisindeki n elemandan oluşan bir vektörün 2-normu, incx adımı ile.

Örnekler

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

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

asum(n, X, incx)

Dizi X'in ilk n elemanının büyüklüklerinin incx adımıyla toplamı.

Gerçek bir dizi için büyüklük, mutlak değerdir. Karmaşık bir dizi için büyüklük, gerçek kısmın mutlak değeri ile hayali kısmın mutlak değerinin toplamıdır.

Örnekler

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

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

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

dx'nin maksimum mutlak değere sahip elemanının indeksini bulun. n, dx'nin uzunluğudur ve incx adım boyutudur. Eğer n ve incx sağlanmazsa, varsayılan değerler n=length(dx) ve incx=stride1(dx) olarak kabul edilir.

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

Vektörü y'yi alpha*A*x + beta*y veya alpha*A'x + beta*y olarak günceller. tA ile ilgili olarak. alpha ve beta skalarlardır. Güncellenmiş y'yi döndür.

gemv(tA, alpha, A, x)

alpha*A*x veya alpha*A'x döndürür tA ile ilgili olarak. alpha bir skalar.

gemv(tA, A, x)

A*x veya A'x döndürün tA ile ilgili.

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

Vektörü y'yi alpha*A*x + beta*y veya alpha*A'*x + beta*y olarak güncelleyin, trans ile ilgili olarak. Matris A, kl alt-diagonal ve ku üst-diagonal ile m boyutunda ve size(A,2) boyutunda genel bir bant matristir. alpha ve beta skalarlardır. Güncellenmiş y'yi döndürün.

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

trans göre alpha*A*x veya alpha*A'*x döndürün. Matris A, kl alt-diagonal ve ku üst-diagonal ile m boyutunda ve size(A,2) boyutunda genel bir bant matrisidir ve alpha bir skalar.

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

Vektörü y'yi alpha*A*x + beta*y olarak güncelleyin. A'nın Hermitiyen olduğu varsayılmaktadır. Sadece ul üçgeni A'nın kullanılır. alpha ve beta skalarlardır. Güncellenmiş y'yi döndürün.

hemv(ul, alpha, A, x)

alpha*A*x döner. A'nın Hermitian olduğu varsayılmaktadır. Sadece ul üçgeni A'nın kullanılır. alpha bir skalar.

hemv(ul, A, x)

A*x döndür. A'nın Hermit olduğu varsayılmaktadır. Sadece ul üçgeni A'nın kullanılır.

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

Vektörü y'yi α*A*x + β*y olarak güncelleyin, burada A paket formatında sağlanan bir Hermit matrisidir AP.

uplo = 'U' olduğunda, dizi AP, Hermit matrisinin üst üçgen kısmını sütun sütun paketlenmiş olarak içermelidir, böylece AP[1] A[1, 1]'i, AP[2] ve AP[3] sırasıyla A[1, 2] ve A[2, 2]'yi içerir ve devam eder.

uplo = 'L' olduğunda, dizi AP, Hermit matrisinin alt üçgen kısmını sütun sütun paketlenmiş olarak içermelidir, böylece AP[1] A[1, 1]'i, AP[2] ve AP[3] sırasıyla A[2, 1] ve A[3, 1]'i içerir ve devam eder.

Skalar girişler α ve β karmaşık veya reel sayılar olmalıdır.

Dizi girişleri x, y ve AP hepsi ComplexF32 veya ComplexF64 türünde olmalıdır.

Güncellenmiş y'yi döndürün.

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

Vektörü y'yi alpha*A*x + beta*y olarak güncelleyin. A'nın simetrik olduğu varsayılmaktadır. Sadece ul üçgeni A'nın kullanılır. alpha ve beta skalarlardır. Güncellenmiş y'yi döndürün.

symv(ul, alpha, A, x)

alpha*A*x döndür. A'nın simetrik olduğu varsayılmaktadır. Sadece ul üçgeni A'nın kullanılır. alpha bir skalar.

symv(ul, A, x)

A*x döndür. A'nın simetrik olduğu varsayılmaktadır. Sadece ul üçgeni A'nın kullanılır.

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

Vektörü y'yi alpha*A*x + beta*y olarak güncelleyin; burada A, A argümanında saklanan k üst diyagonal ile size(A,2) boyutunda simetrik bir bant matristir. A için saklama düzeni, https://www.netlib.org/lapack/explore-html/ adresindeki referans BLAS modülünde açıklanmıştır. Sadece uplo üçgeni A'nın kullanılır.

Güncellenmiş y'yi döndürün.

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

alpha*A*x döndürür; burada A, A argümanında saklanan k üst-diagonal ile size(A,2) boyutunda bir simetrik bant matrisidir. Sadece uplo üçgeni kullanılır.

sbmv(uplo, k, A, x)

A*x döndürür; burada A, argüman A'da saklanan k üst-diagonal ile size(A,2) boyutunda bir simetrik bant matrisidir. Sadece uplo üçgeni kullanılır.

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

Vektörü y'yi α*A*x + β*y olarak güncelleyin, burada A paket formatında sağlanan simetrik bir matristir AP.

uplo = 'U' olduğunda, dizi AP, simetrik matrisin üst üçgen kısmını sütun sütun sıralı olarak içermelidir, böylece AP[1] A[1, 1]'i, AP[2] ve AP[3] sırasıyla A[1, 2] ve A[2, 2]'yi içerir ve devam eder.

uplo = 'L' olduğunda, dizi AP, simetrik matrisin alt üçgen kısmını sütun sütun sıralı olarak içermelidir, böylece AP[1] A[1, 1]'i, AP[2] ve AP[3] sırasıyla A[2, 1] ve A[3, 1]'yi içerir ve devam eder.

Skalar girişler α ve β gerçek olmalıdır.

Dizi girişleri x, y ve AP hepsi Float32 veya Float64 türünde olmalıdır.

Güncellenmiş y'yi döndürün.

trmv!(ul, tA, dA, A, b)

op(A)*b döndür, burada op, tA tarafından belirlenir. Sadece ul üçgeni A'nın kullanılır. dA köşegen değerlerinin okunup okunmayacağını veya hepsinin bir olarak varsayıldığını belirler. Çarpma b üzerinde yerinde gerçekleşir.

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

op(A)*b döndür, burada op, tA tarafından belirlenir. Sadece ul üçgeni A'nın kullanılır. dA köşegen değerlerinin okunup okunmayacağını veya hepsinin bir olarak varsayıldığını belirler.

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

A*x = b denkleminin çözümü veya tA ve ul tarafından belirlenen diğer iki varyanttan biri ile b'yi güncelleyin. dA köşegen değerlerinin okunup okunmadığını veya hepsinin bir olarak varsayıldığını belirler. Güncellenmiş b'yi döndürün.

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

A*x = b çözümünü veya tA ve ul tarafından belirlenen diğer iki varyanttan birini döndürür. dA köşegen değerlerinin okunup okunmayacağını veya hepsinin bir olarak varsayıldığını belirler.

ger!(alpha, x, y, A)

Matris A'yı alpha*x*y' + A şeklinde x ve y vektörleri ile Rank-1 güncellemesi.

her!(uplo, alpha, x, A)

Sadece karmaşık diziler için yöntemler. Hermit matris A'nın sıralı güncellemesi alpha*x*x' + A ile vektör x kullanılarak yapılır. uplo A'nın hangi üçgeninin güncelleneceğini kontrol eder. A döner.

syr!(uplo, alpha, x, A)

Simetrik matris A'nın sıralı güncellemesi alpha*x*transpose(x) + A ile x vektörü kullanılarak yapılır. uplo A'nın hangi üçgeninin güncelleneceğini kontrol eder. A döner.

spr!(uplo, α, x, AP)

Matris A'yı A+α*x*x' olarak güncelleyin, burada A paket formatında sağlanan simetrik bir matristir ve x bir vektördür.

uplo = 'U' olduğunda, dizi AP, simetrik matrisin üst üçgen kısmını sütun sütun sıralı olarak içermelidir, böylece AP[1] A[1, 1]'i, AP[2] ve AP[3] sırasıyla A[1, 2] ve A[2, 2]'yi içerir ve devam eder.

uplo = 'L' olduğunda, dizi AP, simetrik matrisin alt üçgen kısmını sütun sütun sıralı olarak içermelidir, böylece AP[1] A[1, 1]'i, AP[2] ve AP[3] sırasıyla A[2, 1] ve A[3, 1]'i içerir ve devam eder.

Skalar girdi α gerçek olmalıdır.

Dizi girdileri x ve AP tümü Float32 veya Float64 türünde olmalıdır. Güncellenmiş AP'yi döndürün.

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

C'yi uplo tarafından belirtilen alt veya üst üçgen kısmını alpha*A*B + beta*C veya tA ve tB'ye göre diğer varyantlar olarak güncelleyin. Güncellenmiş C'yi döndürün.

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

A*B'nin alt veya üst üçgen kısmını uplo tarafından belirtilen şekilde döndürür veya tA ve tB'ye göre diğer üç varyantı döndürür.

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

A*B'nin uplo ile belirtilen alt veya üst üçgen kısmını veya tA ve tB'ye göre diğer üç varyantı döndürür.

gemm!(tA, tB, alpha, A, B, beta, C)

C'yi alpha*A*B + beta*C veya tA ve tB'ye göre diğer üç varyantla güncelleyin. Güncellenmiş C'yi döndürün.

gemm(tA, tB, alpha, A, B)

alpha*A*B veya tA ve tB'ye göre diğer üç varyantı döndür.

gemm(tA, tB, A, B)

A*B veya tA ve tB'ye göre diğer üç varyantı döndür.

symm!(side, ul, alpha, A, B, beta, C)

C'yi alpha*A*B + beta*C veya alpha*B*A + beta*C olarak güncelleyin, side'a göre. A'nın simetrik olduğu varsayılmaktadır. Sadece A'nın ul üçgeni kullanılır. Güncellenmiş C'yi döndürün.

symm(side, ul, alpha, A, B)