Linear Algebra

NoPivot

Pivotierung wird nicht durchgeführt. Matrixfaktorisierungen wie die LU-Faktorisierung können ohne Pivotierung fehlschlagen und können auch numerisch instabil für Gleitkommatrizen im Angesicht von Rundungsfehlern sein. Diese Pivotstrategie ist hauptsächlich zu pädagogischen Zwecken nützlich.

RowNonZero

Das erste von null verschiedene Element in den verbleibenden Zeilen wird als Pivot-Element gewählt.

Seien Sie vorsichtig, dass der resultierende LU-Algorithmus für Gleitkomma-Matrizen numerisch instabil ist — diese Strategie ist hauptsächlich nützlich für den Vergleich mit Handberechnungen (die typischerweise diese Strategie verwenden) oder für andere algebraische Typen (z. B. rationale Zahlen), die nicht anfällig für Rundungsfehler sind. Andernfalls sollte die Standard-Pivotierungsstrategie RowMaximum im Allgemeinen bei der Gauß-Elimination bevorzugt werden.

Beachten Sie, dass der Elementtyp der Matrix eine iszero Methode unterstützen muss.

RowMaximum

Das Element mit der maximalen Größe in den verbleibenden Zeilen wird als Pivot-Element gewählt. Dies ist die Standardstrategie für die LU-Faktorisierung von Gleitkommazahlen und wird manchmal als der "partielle Pivotierungs"-Algorithmus bezeichnet.

Beachten Sie, dass der Elementtyp der Matrix eine abs-Methode unterstützen muss, deren Ergebnistyp eine <-Methode unterstützen muss.

ColumnNorm

Die Spalte mit der maximalen Norm wird für die nachfolgende Berechnung verwendet. Dies wird für die pivotierte QR-Faktorisierung verwendet.

Beachten Sie, dass der Elementtyp der Matrix die Methoden norm und abs zulassen muss, deren jeweilige Ergebnistypen eine < Methode zulassen müssen.

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

Matrixmultiplikation.

Beispiele

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

Die verkettete Multiplikation von 3 oder 4 Matrizen erfolgt in der effizientesten Reihenfolge, basierend auf den Größen der Arrays. Das heißt, die Anzahl der benötigten skalaren Multiplikationen für (A * B) * C (mit 3 dichten Matrizen) wird mit der für A * (B * C) verglichen, um zu entscheiden, welche dieser beiden Ausdrücke ausgeführt werden soll.

Wenn der letzte Faktor ein Vektor ist oder der erste ein transponierter Vektor, ist es effizient, diese zuerst zu behandeln. Insbesondere bedeutet x' * B * y, dass (x' * B) * y für eine gewöhnliche spaltenmajorisierte B::Matrix. Im Gegensatz zu dot(x, B, y) wird dabei ein Zwischenarray alloziert.

Wenn der erste oder letzte Faktor eine Zahl ist, wird dies mit der Matrizenmultiplikation fusioniert, unter Verwendung von 5-arg mul!.

Siehe auch muladd, dot.

\(A, B)

Matrixdivision mit einem Polyalgorithmus. Für die Eingabematrizen A und B ist das Ergebnis X so beschaffen, dass A*X == B, wenn A quadratisch ist. Der verwendete Solver hängt von der Struktur von A ab. Wenn A ober- oder unterdreieckig (oder diagonal) ist, ist keine Faktorisierung von A erforderlich und das System wird mit Vorwärts- oder Rückwärtssubstitution gelöst. Für nicht-triangular quadratische Matrizen wird eine LU-Faktorisierung verwendet.

Für rechteckige A ist das Ergebnis die Lösung der minimalen Norm der kleinsten Quadrate, die durch eine pivotierte QR-Faktorisierung von A und eine Rangschätzung von A basierend auf dem R-Faktor berechnet wird.

Wenn A spärlich ist, wird ein ähnlicher Polyalgorithmus verwendet. Für indefiniten Matrizen verwendet die LDLt-Faktorisierung während der numerischen Faktorisierung kein Pivoting, und daher kann das Verfahren selbst bei invertierbaren Matrizen fehlschlagen.

Siehe auch: factorize, pinv.

Beispiele

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

Matrix-Rechtsdivision: A / B ist äquivalent zu (B' \ A')', wobei \ der Linksdivisionsoperator ist. Für quadratische Matrizen ist das Ergebnis X so, dass A == X*B.

Siehe auch: rdiv!.

Beispiele

julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

julia> X = A / B
2×3 Matrix{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

julia> isapprox(A, X*B)
true

julia> isapprox(X, A*pinv(B))
true

SingularException

Ausnahme, die ausgelöst wird, wenn die Eingabematrix ein oder mehrere Eigenwerte mit dem Wert Null hat und nicht umkehrbar ist. Eine lineare Lösung, die eine solche Matrix beinhaltet, kann nicht berechnet werden. Das Feld info gibt den Standort des (eines) der singulären Werte an.

PosDefException

Ausnahme, die ausgelöst wird, wenn die Eingabematrix nicht positiv definit ist. Einige lineare Algebra-Funktionen und Faktorisierungen sind nur für positiv definite Matrizen anwendbar. Das Feld info gibt den Standort von (einem der) Eigenwerte an, die kleiner/gleich 0 sind.

ZeroPivotException <: Exception

Ausnahme, die ausgelöst wird, wenn eine Matrixfaktorisierung/-lösung auf eine Null in einer Pivot- (diagonal) Position stößt und nicht fortfahren kann. Dies bedeutet nicht unbedingt, dass die Matrix singulär ist: Es kann sinnvoll sein, zu einer anderen Faktorisierung wie pivotiertem LU zu wechseln, die Variablen neu anordnen kann, um spurious Null-Pivots zu eliminieren. Das Feld info gibt den Standort (einen der) Null-Pivots an.

RankDeficientException

Ausnahme, die ausgelöst wird, wenn die Eingabematrix Rang-defizient ist. Einige Funktionen der linearen Algebra, wie die Cholesky-Zerlegung, sind nur auf Matrizen anwendbar, die nicht rang-defizient sind. Das Feld info gibt den berechneten Rang der Matrix an.

LAPACKException

Allgemeine LAPACK-Ausnahme, die entweder während direkter Aufrufe der LAPACK-Funktionen oder während Aufrufen anderer Funktionen, die die LAPACK-Funktionen intern verwenden, aber keine spezialisierte Fehlerbehandlung haben, ausgelöst wird. Das Feld info enthält zusätzliche Informationen über den zugrunde liegenden Fehler und hängt von der aufgerufenen LAPACK-Funktion ab.

dot(x, y)
x ⋅ y

Berechne das Skalarprodukt zwischen zwei Vektoren. Bei komplexen Vektoren wird der erste Vektor konjugiert.

dot funktioniert auch mit beliebigen iterierbaren Objekten, einschließlich Arrays beliebiger Dimension, solange dot für die Elemente definiert ist.

dot ist semantisch äquivalent zu sum(dot(vx,vy) for (vx,vy) in zip(x, y)), mit der zusätzlichen Einschränkung, dass die Argumente die gleiche Länge haben müssen.

x ⋅ y (wobei ⋅ durch Tab-Vervollständigung von \cdot im REPL eingegeben werden kann) ist ein Synonym für dot(x, y).

Beispiele

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)

Berechne das verallgemeinerte Skalarprodukt dot(x, A*y) zwischen zwei Vektoren x und y, ohne das Zwischenergebnis von A*y zu speichern. Wie beim zweiarugumentigen dot(_,_) wirkt dies rekursiv. Darüber hinaus wird für komplexe Vektoren der erste Vektor konjugiert.

Beispiele

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)

Berechne das Kreuzprodukt von zwei 3-Vektoren.

Beispiele

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)

Überschreibe y mit x * α + y und gebe y zurück. Wenn x und y die gleichen Achsen haben, ist es äquivalent zu y .+= x .* a.

Beispiele

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)

Überschreibe y mit x * α + y * β und gebe y zurück. Wenn x und y die gleichen Achsen haben, ist es äquivalent zu y .= x .* a .+ y .* β.

Beispiele

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)

Überschreibt x mit c*x + s*y und y mit -conj(s)*x + c*y. Gibt x und y zurück.

reflect!(x, y, c, s)

Überschreibt x mit c*x + s*y und y mit conj(s)*x - c*y. Gibt x und y zurück.

factorize(A)

Berechnet eine geeignete Faktorisierung von A, basierend auf dem Typ der Eingabematrix. factorize überprüft A, um festzustellen, ob es symmetrisch/triangular/etc. ist, wenn A als generische Matrix übergeben wird. factorize überprüft jedes Element von A, um jede Eigenschaft zu verifizieren/auszuschließen. Es wird sofort abgebrochen, sobald es Symmetrie/triangular Struktur ausschließen kann. Der Rückgabewert kann für eine effiziente Lösung mehrerer Systeme wiederverwendet werden. Zum Beispiel: A=factorize(A); x=A\b; y=A\C.

Wenn factorize auf einer hermitischen positiv definiten Matrix aufgerufen wird, wird factorize beispielsweise eine Cholesky-Faktorisierung zurückgeben.

Beispiele

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 wird überprüfen, ob A bereits faktorisierte ist
5×5 Bidiagonal{Float64, Vector{Float64}}:
 1.0  1.0   ⋅    ⋅    ⋅
  ⋅   1.0  1.0   ⋅    ⋅
  ⋅    ⋅   1.0  1.0   ⋅
  ⋅    ⋅    ⋅   1.0  1.0
  ⋅    ⋅    ⋅    ⋅   1.0

Dies gibt ein 5×5 Bidiagonal{Float64} zurück, das nun an andere lineare Algebra-Funktionen (z. B. Eigenlöser) übergeben werden kann, die spezialisierte Methoden für Bidiagonal-Typen verwenden.

Diagonal(V::AbstractVector)

Konstruiere eine faule Matrix mit V als ihrer Diagonale.

Siehe auch UniformScaling für die faule Identitätsmatrix I, diagm um eine dichte Matrix zu erstellen, und diag um diagonale Elemente zu extrahieren.

Beispiele

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

!!! Hinweis Eine einspaltige Matrix wird nicht wie ein Vektor behandelt, sondern ruft stattdessen die Methode Diagonal(A::AbstractMatrix) auf, die 1-element diag(A) extrahiert:

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

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

Diagonal(A::AbstractMatrix)

Konstruiere eine Matrix aus der Hauptdiagonale von A. Die Eingabematrix A kann rechteckig sein, aber die Ausgabe wird quadratisch sein.

Beispiele

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)

Konstruiere ein nicht initialisiertes Diagonal{T} der Länge n. Siehe undef.

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

Konstruiert eine obere (uplo=:U) oder untere (uplo=:L) bidiagonale Matrix unter Verwendung der gegebenen Diagonal-(dv) und Off-Diagonal-(ev) Vektoren. Das Ergebnis ist vom Typ Bidiagonal und bietet effiziente spezialisierte lineare Solver, kann jedoch in eine reguläre Matrix mit convert(Array, _) (oder Array(_) für kurz) umgewandelt werden. Die Länge von ev muss um eins kleiner sein als die Länge von dv.

Beispiele

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 ist auf der ersten Superdiagonale
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 ⋅  2  8  ⋅
 ⋅  ⋅  3  9
 ⋅  ⋅  ⋅  4

julia> Bl = Bidiagonal(dv, ev, :L) # ev ist auf der ersten Subdiagonale
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 7  2  ⋅  ⋅
 ⋅  8  3  ⋅
 ⋅  ⋅  9  4

Bidiagonal(A, uplo::Symbol)

Konstruiere eine Bidiagonal-Matrix aus der Hauptdiagonale von A und ihrer ersten Über- (wenn uplo=:U) oder Unterdiagonale (wenn uplo=:L).

Beispiele

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) # enthält die Hauptdiagonale und die erste Überdiagonale von A
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  1  ⋅  ⋅
 ⋅  2  2  ⋅
 ⋅  ⋅  3  3
 ⋅  ⋅  ⋅  4

julia> Bidiagonal(A, :L) # enthält die Hauptdiagonale und die erste Unterdiagonale von A
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 2  2  ⋅  ⋅
 ⋅  3  3  ⋅
 ⋅  ⋅  4  4

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

Konstruiere eine symmetrische tridiagonale Matrix aus der Diagonale (dv) und der ersten Unter-/Überdiagonale (ev). Das Ergebnis ist vom Typ SymTridiagonal und bietet effiziente spezialisierte Eigenlöser, kann jedoch in eine reguläre Matrix mit convert(Array, _) (oder Array(_) für kurz) umgewandelt werden.

Für SymTridiagonal Blockmatrizen werden die Elemente von dv symmetriert. Das Argument ev wird als Überdiagonale interpretiert. Blöcke von der Unterdiagonale sind (materialisierte) Transponierte der entsprechenden Überdiagonalblöcke.

Beispiele

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)

Konstruiere eine symmetrische tridiagonale Matrix aus der Diagonalen und der ersten Überdiagonalen der symmetrischen Matrix A.

Beispiele

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

Konstruiere eine tridiagonale Matrix aus der ersten Subdiagonale, der Diagonale und der ersten Superdiagonale. Das Ergebnis ist vom Typ Tridiagonal und bietet effiziente spezialisierte lineare Solver, kann jedoch in eine reguläre Matrix mit convert(Array, _) (oder Array(_) für kurz) umgewandelt werden. Die Längen von dl und du müssen um eins kleiner sein als die Länge von d.

!!! Hinweis Die Subdiagonale dl und die Superdiagonale du dürfen sich nicht gegenseitig aliasieren. Wenn ein Alias erkannt wird, verwendet der Konstruktor eine Kopie von du als Argument.

Beispiele

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)

Konstruiere eine tridiagonale Matrix aus der ersten Unterdiagonale, Diagonale und ersten Oberdiagonale der Matrix A.

Beispiele

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

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

Konstruiert eine Symmetrisch-Ansicht des oberen (wenn uplo = :U) oder unteren (wenn uplo = :L) Dreiecks der Matrix A.

Symmetrisch-Ansichten sind hauptsächlich nützlich für reelle symmetrische Matrizen, für die spezialisierte Algorithmen (z. B. für Eigenwertprobleme) für Symmetrisch-Typen aktiviert sind. Allgemeiner siehe auch Hermitian(A) für hermitische Matrizen A == A', die effektiv äquivalent zu Symmetrisch für reelle Matrizen sind, aber auch für komplexe Matrizen nützlich sind. (Während komplexe Symmetrisch-Matrizen unterstützt werden, gibt es nur wenige, wenn überhaupt, spezialisierte Algorithmen.)

Um den symmetrischen Teil einer reellen Matrix oder allgemeiner den hermitischen Teil (A + A') / 2 einer reellen oder komplexen Matrix A zu berechnen, verwenden Sie hermitianpart.

Beispiele

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

julia> Slower = Symmetrisch(A, :L)
3×3 Symmetrisch{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

Beachten Sie, dass Supper nicht gleich Slower sein wird, es sei denn, A ist selbst symmetrisch (z. B. wenn A == transpose(A)).

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

Konstruiere eine Hermitian-Ansicht des oberen (wenn uplo = :U) oder unteren (wenn uplo = :L) Dreiecks der Matrix A.

Um den hermiteschen Teil von A zu berechnen, verwende hermitianpart.

Beispiele

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

Beachte, dass Hupper nicht gleich Hlower sein wird, es sei denn, A ist selbst hermitesch (z. B. wenn A == adjoint(A)).

Alle nicht-reellen Teile der Diagonalen werden ignoriert.

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

LowerTriangular(A::AbstractMatrix)

Konstruiere eine LowerTriangular-Ansicht der Matrix A.

Beispiele

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)

Konstruiere eine UpperTriangular-Ansicht der Matrix A.

Beispiele

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)

Konstruiere eine UnitLowerTriangular-Ansicht der Matrix A. Eine solche Ansicht hat das oneunit des eltype von A auf ihrer Diagonalen.

Beispiele

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)

Konstruiere eine UnitUpperTriangular-Ansicht der Matrix A. Eine solche Ansicht hat das oneunit des eltype von A auf ihrer Diagonalen.

Beispiele

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)

Konstruiere eine UpperHessenberg-Ansicht der Matrix A. Einträge von A unterhalb der ersten Subdiagonale werden ignoriert.

Effiziente Algorithmen sind für H \ b, det(H) und Ähnliches implementiert.

Siehe auch die hessenberg Funktion, um jede Matrix in eine ähnliche obere Hessenberg-Matrix zu faktorisieren.

Wenn F::Hessenberg das Faktorisierungsobjekt ist, kann die unitäre Matrix mit F.Q und die Hessenberg-Matrix mit F.H abgerufen werden. Wenn Q extrahiert wird, ist der resultierende Typ das HessenbergQ-Objekt und kann mit convert(Array, _) (oder Array(_) kurz) in eine reguläre Matrix umgewandelt werden.

Das Iterieren über die Zerlegung erzeugt die Faktoren F.Q und F.H.

Beispiele

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}

Generisch dimensionierter einheitlicher Skalierungsoperator, definiert als ein Skalar mal den Identitätsoperator, λ*I. Obwohl ohne eine explizite size, verhält er sich in vielen Fällen ähnlich wie eine Matrix und unterstützt einige Indizierungen. Siehe auch I.

Beispiele

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

Ein Objekt vom Typ UniformScaling, das eine Einheitsmatrix beliebiger Größe darstellt.

Beispiele

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)

Konstruiere eine Diagonal-Matrix aus einer UniformScaling.

Beispiele

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

Abstrakte Typ für Matrixfaktorisierungen, auch bekannt als Matrixzerlegungen. Siehe Online-Dokumentation für eine Liste der verfügbaren Matrixfaktorisierungen.

LU <: Faktorisierung

Matrixfaktorisierungstyp der LU-Faktorisierung einer quadratischen Matrix A. Dies ist der Rückgabetyp von lu, der entsprechenden Matrixfaktorisierungsfunktion.

Die einzelnen Komponenten der Faktorisierung F::LU können über getproperty zugegriffen werden:

Das Iterieren über die Faktorisierung erzeugt die Komponenten F.L, F.U und F.p.

Beispiele

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-Faktor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U-Faktor:
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); # Destrukturierung über Iteration

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

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

Berechnen Sie die LU-Zerlegung einer spärlichen Matrix A.

Für spärliche A mit reellem oder komplexem Elementtyp ist der Rückgabewert von F UmfpackLU{Tv, Ti}, wobei Tv = Float64 oder ComplexF64 entsprechend und Ti ein ganzzahliger Typ (Int32 oder Int64) ist.

Wenn check = true, wird ein Fehler ausgelöst, wenn die Zerlegung fehlschlägt. Wenn check = false, liegt die Verantwortung für die Überprüfung der Gültigkeit der Zerlegung (über issuccess) beim Benutzer.

Der Permutationsvektor q kann entweder ein Permutationsvektor oder nothing sein. Wenn kein Permutationsvektor bereitgestellt wird oder q nothing ist, wird das Standardverhalten von UMFPACK verwendet. Wenn die Permutation nicht nullbasiert ist, wird eine nullbasierte Kopie erstellt.

Der control-Vektor hat standardmäßig die Standardkonfiguration des Julia SparseArrays-Pakets für UMFPACK (NB: dies wurde von den UMFPACK-Standardeinstellungen geändert, um die iterative Verfeinerung zu deaktivieren), kann jedoch geändert werden, indem ein Vektor der Länge UMFPACK_CONTROL übergeben wird. Siehe das UMFPACK-Handbuch für mögliche Konfigurationen. Um beispielsweise die iterative Verfeinerung wieder zu aktivieren:

umfpack_control = SparseArrays.UMFPACK.get_umfpack_control(Float64, Int64) # Julia-Standardkonfiguration für eine Float64-spärliche Matrix lesen
SparseArrays.UMFPACK.show_umf_ctrl(umfpack_control) # optional - Werte anzeigen
umfpack_control[SparseArrays.UMFPACK.JL_UMFPACK_IRSTEP] = 2.0 # iterative Verfeinerung wieder aktivieren (2 ist UMFPACK-Standard für maximale Schritte der iterativen Verfeinerung)

Alu = lu(A; control = umfpack_control)
x = Alu \ b   # löse Ax = b, einschließlich der iterativen Verfeinerung von UMFPACK

Die einzelnen Komponenten der Zerlegung F können durch Indizierung zugegriffen werden:

Die Beziehung zwischen F und A ist

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

F unterstützt außerdem die folgenden Funktionen:

• \
• det

Siehe auch lu!

!!! Hinweis lu(A::AbstractSparseMatrixCSC) verwendet die UMFPACK^[ACM832] Bibliothek, die Teil von SuiteSparse ist. Da diese Bibliothek nur spärliche Matrizen mit Float64 oder ComplexF64-Elementen unterstützt, konvertiert lu A in eine Kopie, die vom Typ SparseMatrixCSC{Float64} oder SparseMatrixCSC{ComplexF64} ist, je nach Bedarf.

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

Berechnen Sie die LU-Zerlegung von A.

Wenn check = true ist, wird ein Fehler ausgelöst, wenn die Zerlegung fehlschlägt. Wenn check = false ist, liegt die Verantwortung für die Überprüfung der Gültigkeit der Zerlegung (über issuccess) beim Benutzer.

Standardmäßig wird mit check = true auch ein Fehler ausgelöst, wenn die Zerlegung gültige Faktoren produziert, aber der obere dreieckige Faktor U rangdefizient ist. Dies kann geändert werden, indem allowsingular = true übergeben wird.

In den meisten Fällen, wenn A ein Subtyp S von AbstractMatrix{T} mit einem Elementtyp T ist, der +, -, * und / unterstützt, ist der Rückgabetyp LU{T,S{T}}.

Im Allgemeinen umfasst die LU-Zerlegung eine Permutation der Zeilen der Matrix (entsprechend der F.p Ausgabe, die unten beschrieben ist), bekannt als "Pivotierung" (weil sie entspricht, welche Zeile den "Pivot" enthält, den diagonalen Eintrag von F.U). Eine der folgenden Pivotierungsstrategien kann über das optionale Argument pivot ausgewählt werden:

• RowMaximum() (Standard): die Standard-Pivotierungsstrategie; der Pivot entspricht dem Element mit dem maximalen Absolutwert unter den verbleibenden, zu zerlegenden Zeilen. Diese Pivotierungsstrategie erfordert, dass der Elementtyp auch abs und < unterstützt. (Dies ist im Allgemeinen die einzige numerisch stabile Option für Gleitkommatrizen.)
• RowNonZero(): der Pivot entspricht dem ersten nicht-null Element unter den verbleibenden, zu zerlegenden Zeilen. (Dies entspricht der typischen Wahl in Handberechnungen und ist auch nützlich für allgemeinere algebraische Zahlentypen, die iszero unterstützen, aber nicht abs oder <.)
• NoPivot(): Pivotierung deaktiviert (schlägt fehl, wenn ein Null-Eintrag in einer Pivot-Position auftritt, selbst wenn allowsingular = true).

Die einzelnen Komponenten der Zerlegung F können über getproperty abgerufen werden:

Die Iteration über die Zerlegung produziert die Komponenten F.L, F.U und F.p.

Die Beziehung zwischen F und A ist

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

F unterstützt außerdem die folgenden Funktionen:

Beispiele

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-Faktor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U-Faktor:
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); # Destrukturierung über Iteration

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

julia> lu([1 2; 1 2], allowsingular = true)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L-Faktor:
2×2 Matrix{Float64}:
 1.0  0.0
 1.0  1.0
U-Faktor (rangdefizient):
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

Berechnet die LU-Zerlegung einer spärlichen Matrix A, wobei die symbolische Zerlegung einer bereits vorhandenen LU-Zerlegung, die in F gespeichert ist, wiederverwendet wird. Sofern reuse_symbolic nicht auf false gesetzt ist, muss die spärliche Matrix A ein identisches Nicht-Null-Muster wie die Matrix haben, die zur Erstellung der LU-Zerlegung F verwendet wurde, andernfalls wird ein Fehler ausgelöst. Wenn die Größe von A und F unterschiedlich ist, werden alle Vektoren entsprechend angepasst.

Wenn check = true ist, wird ein Fehler ausgelöst, wenn die Zerlegung fehlschlägt. Wenn check = false ist, liegt die Verantwortung für die Überprüfung der Gültigkeit der Zerlegung (über issuccess) beim Benutzer.

Die Permutation q kann entweder ein Permutationsvektor oder nothing sein. Wenn kein Permutationsvektor bereitgestellt wird oder q nothing ist, wird das Standardverfahren von UMFPACK verwendet. Wenn die Permutation nicht nullbasiert ist, wird eine nullbasierte Kopie erstellt.

Siehe auch lu

Beispiele

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! ist dasselbe wie lu, speichert jedoch Platz, indem es die Eingabe A überschreibt, anstatt eine Kopie zu erstellen. Eine InexactError Ausnahme wird ausgelöst, wenn die Faktorisierung eine Zahl produziert, die vom Elementtyp von A nicht darstellbar ist, z. B. für Ganzzahltypen.

Beispiele

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

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

julia> lu!(iA)
ERROR: InexactError: Int64(0.6666666666666666)
Stacktrace:
[...]

Cholesky <: Faktorisierung

Matrixfaktorisierungstyp der Cholesky-Faktorisierung einer dichten symmetrischen/Hermiteschen positiv definiten Matrix A. Dies ist der Rückgabetyp von cholesky, der entsprechenden Matrixfaktorisierungsfunktion.

Der dreieckige Cholesky-Faktor kann aus der Faktorisierung F::Cholesky über F.L und F.U erhalten werden, wobei A ≈ F.U' * F.U ≈ F.L * F.L'.

Die folgenden Funktionen sind für Cholesky-Objekte verfügbar: size, \, inv, det, logdet und isposdef.

Das Iterieren über die Zerlegung erzeugt die Komponenten L und U.

Beispiele

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-Faktor:
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; # Destrukturierung über Iteration

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

CholeskyPivoted

Matrixfaktorisierungstyp der pivotierten Cholesky-Faktorisation einer dichten symmetrischen/Hermiteschen positiv semi-definiten Matrix A. Dies ist der Rückgabetyp von cholesky(_, ::RowMaximum), der entsprechenden Matrixfaktorierungsfunktion.

Der triangulierte Cholesky-Faktor kann aus der Faktorisierung F::CholeskyPivoted über F.L und F.U sowie die Permutation über F.p erhalten werden, wobei A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' mit Ur = F.U[1:F.rank, :] und Lr = F.L[:, 1:F.rank] oder alternativ A ≈ Up' * Up ≈ Lp * Lp' mit Up = F.U[1:F.rank, invperm(F.p)] und Lp = F.L[invperm(F.p), 1:F.rank].

Die folgenden Funktionen sind für CholeskyPivoted-Objekte verfügbar: size, \, inv, det und rank.

Die Iteration der Zerlegung erzeugt die Komponenten L und U.

Beispiele

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-Faktor mit Rang 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
Permutation:
4-element Vector{Int64}:
 4
 2
 3
 1

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

julia> l, u = C; # Destrukturierung über Iteration

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

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

Berechnen Sie die Cholesky-Zerlegung einer dichten symmetrischen positiv definiten Matrix A und geben Sie eine Cholesky Zerlegung zurück. Die Matrix A kann entweder eine Symmetric oder Hermitian AbstractMatrix oder eine perfekt symmetrische oder hermitische AbstractMatrix sein.

Der dreieckige Cholesky-Faktor kann aus der Zerlegung F über F.L und F.U erhalten werden, wobei A ≈ F.U' * F.U ≈ F.L * F.L'.

Die folgenden Funktionen sind für Cholesky-Objekte verfügbar: size, \, inv, det, logdet und isposdef.

Wenn Sie eine Matrix A haben, die aufgrund von Rundungsfehlern bei ihrer Konstruktion leicht nicht-hermitisch ist, wickeln Sie sie in Hermitian(A) ein, bevor Sie sie an cholesky übergeben, um sie als perfekt hermitisch zu behandeln.

Wenn check = true, wird ein Fehler ausgelöst, wenn die Zerlegung fehlschlägt. Wenn check = false, liegt die Verantwortung für die Überprüfung der Gültigkeit der Zerlegung (über issuccess) beim Benutzer.

Beispiele

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-Faktor:
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

Berechnen Sie die pivotierte Cholesky-Zerlegung einer dichten symmetrischen positiv semi-definierten Matrix A und geben Sie eine CholeskyPivoted Zerlegung zurück. Die Matrix A kann entweder eine Symmetric oder Hermitian AbstractMatrix oder eine perfekt symmetrische oder hermitische AbstractMatrix sein.

Der dreieckige Cholesky-Faktor kann aus der Zerlegung F über F.L und F.U sowie die Permutation über F.p erhalten werden, wobei A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' mit Ur = F.U[1:F.rank, :] und Lr = F.L[:, 1:F.rank], oder alternativ A ≈ Up' * Up ≈ Lp * Lp' mit Up = F.U[1:F.rank, invperm(F.p)] und Lp = F.L[invperm(F.p), 1:F.rank].

Die folgenden Funktionen sind für CholeskyPivoted-Objekte verfügbar: size, \, inv, det und rank.

Das Argument tol bestimmt die Toleranz zur Bestimmung des Rangs. Bei negativen Werten ist die Toleranz die Maschinenpräzision.

Wenn Sie eine Matrix A haben, die aufgrund von Rundungsfehlern bei ihrer Konstruktion leicht nicht-hermitisch ist, wickeln Sie sie in Hermitian(A) ein, bevor Sie sie an cholesky übergeben, um sie als perfekt hermitisch zu behandeln.

Wenn check = true, wird ein Fehler ausgelöst, wenn die Zerlegung fehlschlägt. Wenn check = false, liegt die Verantwortung für die Überprüfung der Gültigkeit der Zerlegung (über issuccess) beim Benutzer.

Beispiele

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-Faktor mit Rang 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
Permutation:
4-element Vector{Int64}:
 4
 2
 3
 1

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

julia> l, u = C; # Destrukturierung über Iteration

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

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

Berechnen Sie die Cholesky-Zerlegung einer spärlichen positiv definiten Matrix A. A muss eine SparseMatrixCSC oder eine Symmetric/Hermitian Ansicht einer SparseMatrixCSC sein. Beachten Sie, dass A, auch wenn es nicht den Typ-Tag hat, dennoch symmetrisch oder hermitisch sein muss. Wenn perm nicht angegeben ist, wird eine füllreduzierende Permutation verwendet. F = cholesky(A) wird am häufigsten verwendet, um Gleichungssysteme mit F\b zu lösen, aber auch die Methoden diag, det und logdet sind für F definiert. Sie können auch einzelne Faktoren aus F extrahieren, indem Sie F.L verwenden. Da das Pivotieren standardmäßig aktiviert ist, wird die Zerlegung intern als A == P'*L*L'*P mit einer Permutationsmatrix P dargestellt; die Verwendung von nur L ohne Berücksichtigung von P führt zu falschen Ergebnissen. Um die Auswirkungen der Permutation einzubeziehen, ist es typischerweise vorzuziehen, "kombinierte" Faktoren wie PtL = F.PtL (das Äquivalent von P'*L) und LtP = F.UP (das Äquivalent von L'*P) zu extrahieren.

Wenn check = true, wird ein Fehler ausgelöst, wenn die Zerlegung fehlschlägt. Wenn check = false, liegt die Verantwortung für die Überprüfung der Gültigkeit der Zerlegung (über issuccess) beim Benutzer.

Durch Setzen des optionalen Schlüsselwortarguments shift wird die Zerlegung von A+shift*I anstelle von A berechnet. Wenn das Argument perm angegeben ist, sollte es eine Permutation von 1:size(A,1) sein, die die zu verwendende Reihenfolge angibt (anstatt der standardmäßigen AMD-Reihenfolge von CHOLMOD).

Beispiele

Im folgenden Beispiel wird die füllreduzierende Permutation verwendet: [3, 2, 1]. Wenn perm auf 1:3 gesetzt wird, um keine Permutation zu erzwingen, beträgt die Anzahl der Nicht-Null-Elemente im Faktor 6.

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

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

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

julia> L = sparse(C.L);

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

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

julia> P = sparse(1:3, C.p, ones(3))
3×3 SparseMatrixCSC{Float64, Int64} mit 3 gespeicherten Einträgen:
  ⋅    ⋅   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

Das gleiche wie cholesky, aber spart Speicher, indem es die Eingabe A überschreibt, anstatt eine Kopie zu erstellen. Eine InexactError Ausnahme wird ausgelöst, wenn die Faktorisierung eine Zahl produziert, die vom Elementtyp von A nicht darstellbar ist, z. B. für Ganzzahltypen.

Beispiele

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

julia> cholesky!(A)
ERROR: InexactError: Int64(6.782329983125268)
Stacktrace:
[...]

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

Das gleiche wie cholesky, aber spart Speicherplatz, indem es die Eingabe A überschreibt, anstatt eine Kopie zu erstellen. Eine InexactError Ausnahme wird ausgelöst, wenn die Faktorisierung eine Zahl produziert, die vom Elementtyp von A nicht darstellbar ist, z. B. für Ganzzahltypen.

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

Berechne die Cholesky ($LL'$) Faktorisierung von A, indem die symbolische Faktorisierung F wiederverwendet wird. A muss eine SparseMatrixCSC oder eine Symmetric/ Hermitian Ansicht einer SparseMatrixCSC sein. Beachte, dass A, auch wenn es nicht den Typ-Tag hat, dennoch symmetrisch oder hermitesch sein muss.

Siehe auch cholesky.

!!! Hinweis Diese Methode verwendet die CHOLMOD-Bibliothek von SuiteSparse, die nur reale oder komplexe Typen in einfacher oder doppelter Präzision unterstützt. Eingabematrizen, die nicht diesen Elementtypen entsprechen, werden bei Bedarf in diese Typen umgewandelt.

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

Aktualisiert eine Cholesky-Faktorisierung C mit dem Vektor v. Wenn A = C.U'C.U dann ist CC = cholesky(C.U'C.U + v*v'), aber die Berechnung von CC verwendet nur O(n^2) Operationen.

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

Erhalten Sie eine LDLt-Faktorisierung von A + C*C', gegeben eine LDLt- oder LLt-Faktorisierung F von A.

Der zurückgegebene Faktor ist immer eine LDLt-Faktorisierung.

Siehe auch lowrankupdate!, lowrankdowndate, lowrankdowndate!.

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

Führen Sie eine Downdate einer Cholesky-Faktorisierung C mit dem Vektor v durch. Wenn A = C.U'C.U dann ist CC = cholesky(C.U'C.U - v*v'), aber die Berechnung von CC verwendet nur O(n^2) Operationen.

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

Erhalte eine LDLt-Faktorisierung von A + C*C', gegeben eine LDLt- oder LLt-Faktorisierung F von A.

Der zurückgegebene Faktor ist immer eine LDLt-Faktorisierung.

Siehe auch lowrankdowndate!, lowrankupdate, lowrankupdate!.

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

Aktualisiert eine Cholesky-Faktorisierung C mit dem Vektor v. Wenn A = C.U'C.U dann ist CC = cholesky(C.U'C.U + v*v'), aber die Berechnung von CC verwendet nur O(n^2) Operationen. Die Eingabefaktorisierung C wird vor Ort aktualisiert, sodass beim Verlassen C == CC gilt. Der Vektor v wird während der Berechnung zerstört.

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

Aktualisiert eine LDLt- oder LLt-Faktorisierung F von A zu einer Faktorisierung von A + C*C'.

LLt-Faktorisierungen werden in LDLt umgewandelt.

Siehe auch lowrankupdate, lowrankdowndate, lowrankdowndate!.

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

Aktualisieren Sie eine Cholesky-Faktorisierung C mit dem Vektor v. Wenn A = C.U'C.U dann ist CC = cholesky(C.U'C.U - v*v'), aber die Berechnung von CC verwendet nur O(n^2) Operationen. Die Eingabefaktorisierung C wird vor Ort aktualisiert, sodass beim Verlassen C == CC gilt. Der Vektor v wird während der Berechnung zerstört.

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

Aktualisiert eine LDLt- oder LLt-Faktorisierung F von A zu einer Faktorisierung von A - C*C'.

LLt-Faktorisierungen werden in LDLt umgewandelt.

Siehe auch lowrankdowndate, lowrankupdate, lowrankupdate!.

LDLt <: Faktorisierung

Matrixfaktorisierungstyp der LDLt-Faktorisierung einer reellen SymTridiagonal Matrix S, sodass S = L*Diagonal(d)*L', wobei L eine UnitLowerTriangular Matrix und d ein Vektor ist. Der Hauptzweck einer LDLt-Faktorisierung F = ldlt(S) besteht darin, das lineare Gleichungssystem Sx = b mit F\b zu lösen. Dies ist der Rückgabetyp von ldlt, der entsprechenden Matrixfaktorisierungsfunktion.

Die einzelnen Komponenten der Faktorisierung F::LDLt können über getproperty zugegriffen werden:

Beispiele

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

ldlt(S::SymTridiagonal) -> LDLt

Berechne eine LDLt (d.h. $LDL^T$) Faktorisierung der reellen symmetrischen tridiagonalen Matrix S, sodass S = L*Diagonal(d)*L', wobei L eine einheitsuntere Dreiecksmatrix und d ein Vektor ist. Der Hauptzweck einer LDLt-Faktorisierung F = ldlt(S) besteht darin, das lineare Gleichungssystem Sx = b mit F\b zu lösen.

Siehe auch bunchkaufman für eine ähnliche, aber pivotierte Faktorisierung beliebiger symmetrischer oder hermitescher Matrizen.

Beispiele

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

Berechnen Sie die $LDL'$-Faktorisierung einer spärlichen Matrix A. A muss eine SparseMatrixCSC oder eine Symmetric/Hermitian Ansicht einer SparseMatrixCSC sein. Beachten Sie, dass A, auch wenn es nicht den Typ-Tag hat, dennoch symmetrisch oder hermitesch sein muss. Eine füllreduzierende Permutation wird verwendet. F = ldlt(A) wird am häufigsten verwendet, um Gleichungssysteme A*x = b mit F\b zu lösen. Das zurückgegebene Faktorisierungsobjekt F unterstützt auch die Methoden diag, det, logdet und inv. Sie können einzelne Faktoren aus F mit F.L extrahieren. Da jedoch das Pivoting standardmäßig aktiviert ist, wird die Faktorisierung intern als A == P'*L*D*L'*P mit einer Permutationsmatrix P dargestellt; die Verwendung von nur L ohne Berücksichtigung von P führt zu falschen Ergebnissen. Um die Auswirkungen der Permutation einzubeziehen, ist es typischerweise vorzuziehen, "kombinierte" Faktoren wie PtL = F.PtL (das Äquivalent von P'*L) und LtP = F.UP (das Äquivalent von L'*P) zu extrahieren. Die vollständige Liste der unterstützten Faktoren ist :L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP.

Wenn check = true, wird ein Fehler ausgelöst, wenn die Zerlegung fehlschlägt. Wenn check = false, liegt die Verantwortung für die Überprüfung der Gültigkeit der Zerlegung (über issuccess) beim Benutzer.

Durch Setzen des optionalen Schlüsselwortarguments shift wird die Faktorisierung von A+shift*I anstelle von A berechnet. Wenn das Argument perm bereitgestellt wird, sollte es eine Permutation von 1:size(A,1) sein, die die zu verwendende Reihenfolge angibt (anstatt der standardmäßigen AMD-Reihenfolge von CHOLMOD).

!!! Hinweis Diese Methode verwendet die CHOLMOD^{[ACM887][DavisHager2009]} Bibliothek von SuiteSparse. CHOLMOD unterstützt nur reale oder komplexe Typen in einfacher oder doppelter Präzision. Eingabematrizen, die nicht diesen Elementtypen entsprechen, werden bei Bedarf in diese Typen konvertiert.

Viele andere Funktionen von CHOLMOD sind verpackt, aber nicht aus dem Modul `Base.SparseArrays.CHOLMOD` exportiert.

ldlt!(S::SymTridiagonal) -> LDLt

Dasselbe wie ldlt, aber spart Speicher, indem es die Eingabe S überschreibt, anstatt eine Kopie zu erstellen.

Beispiele

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

Berechne die $LDL'$-Faktorisierung von A, indem die symbolische Faktorisierung F wiederverwendet wird. A muss eine SparseMatrixCSC oder eine Symmetric/Hermitian Ansicht einer SparseMatrixCSC sein. Beachte, dass A, auch wenn es nicht den Typ-Tag hat, dennoch symmetrisch oder hermitesch sein muss.

Siehe auch ldlt.

!!! Hinweis Diese Methode verwendet die CHOLMOD-Bibliothek von SuiteSparse, die nur reale oder komplexe Typen in einfacher oder doppelter Präzision unterstützt. Eingabematrizen, die nicht diesen Elementtypen entsprechen, werden bei Bedarf in diese Typen umgewandelt.

QR <: Faktorisierung

Eine QR-Matrixfaktorisierung, die in einem kompakten Format gespeichert ist, typischerweise erhalten von qr. Wenn $A$ eine m×n Matrix ist, dann

\[A = Q R\]

wobei $Q$ eine orthogonale/einheitliche Matrix und $R$ oberes Dreieck ist. Die Matrix $Q$ wird als eine Folge von Householder-Reflektoren $v_i$ und Koeffizienten $\tau_i$ gespeichert, wobei:

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

Das Iterieren der Zerlegung erzeugt die Komponenten Q und R.

Das Objekt hat zwei Felder:

• factors ist eine m×n Matrix.

  • Der obere Dreiecksteil enthält die Elemente von $R$, das heißt R = triu(F.factors) für ein QR Objekt F.
  • Der subdiagonale Teil enthält die Reflektoren $v_i$, die in einem kompakten Format gespeichert sind, wobei $v_i$ die $i$-te Spalte der Matrix V = I + tril(F.factors, -1) ist.

• τ ist ein Vektor der Länge min(m,n), der die Koeffizienten $au_i$ enthält.

QRCompactWY <: Factorization

Eine QR-Matrixfaktorisierung, die in einem kompakten Blockformat gespeichert ist, typischerweise erhalten von qr. Wenn $A$ eine m×n Matrix ist, dann

\[A = Q R\]

wobei $Q$ eine orthogonale/einheitliche Matrix und $R$ oberes Dreieck ist. Es ist ähnlich zum QR Format, mit dem Unterschied, dass die orthogonale/einheitliche Matrix $Q$ im Compact WY Format gespeichert ist ^{[Schreiber1989]}. Für die Blockgröße $n_b$ wird es als eine m×n untere trapezförmige Matrix $V$ und eine Matrix $T = (T_1 \; T_2 \; ... \; T_{b-1} \; T_b')$ gespeichert, die aus $b = \lceil \min(m,n) / n_b \rceil$ oberen Dreiecksmatrizen $T_j$ der Größe $n_b$×$n_b$ ($j = 1, ..., b-1$) und einer oberen trapezförmigen $n_b$×$\min(m,n) - (b-1) n_b$ Matrix $T_b'$ ($j=b$) besteht, deren oberer quadratischer Teil mit $T_b$ bezeichnet wird und die erfüllt

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

so dass $v_i$ die $i$-te Spalte von $V$ ist, $\tau_i$ das $i$-te Element von [diag(T_1); diag(T_2); …; diag(T_b)] ist, und $(V_1 \; V_2 \; ... \; V_b)$ der linke m×min(m, n) Block von $V$ ist. Wenn es mit qr konstruiert wird, wird die Blockgröße durch $n_b = \min(m, n, 36)$ gegeben.

Das Iterieren der Zerlegung erzeugt die Komponenten Q und R.

Das Objekt hat zwei Felder:

• factors, wie im QR Typ, ist eine m×n Matrix.

  • Der obere Dreiecksteil enthält die Elemente von $R$, das heißt R = triu(F.factors) für ein QR Objekt F.
  • Der subdiagonale Teil enthält die Reflektoren $v_i$, die in einem gepackten Format gespeichert sind, so dass V = I + tril(F.factors, -1).

• T ist eine $n_b$-by-$\min(m,n)$ Matrix, wie oben beschrieben. Die subdiagonalen Elemente für jede Dreiecksmatrix $T_j$ werden ignoriert.

QRPivoted <: Factorization

Eine QR-Matrixfaktorisierung mit Spaltenpivotierung in einem kompakten Format, typischerweise erhalten von qr. Wenn $A$ eine m×n Matrix ist, dann

\[A P = Q R\]

wobei $P$ eine Permutationsmatrix ist, $Q$ eine orthogonale/einheitliche Matrix und $R$ oberhalb dreieckig ist. Die Matrix $Q$ wird als eine Folge von Householder-Reflektoren gespeichert:

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

Das Iterieren der Zerlegung produziert die Komponenten Q, R und p.

Das Objekt hat drei Felder:

• factors ist eine m×n Matrix.

  • Der obere dreieckige Teil enthält die Elemente von $R$, das heißt R = triu(F.factors) für ein QR Objekt F.
  • Der subdiagonale Teil enthält die Reflektoren $v_i$, die in einem kompakten Format gespeichert sind, wobei $v_i$ die $i$-te Spalte der Matrix V = I + tril(F.factors, -1) ist.

• τ ist ein Vektor der Länge min(m,n), der die Koeffizienten $au_i$ enthält.

• jpvt ist ein ganzzahliger Vektor der Länge n, der der Permutation $P$ entspricht.

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

Berechnen Sie die QR-Faktorisierung einer spärlichen Matrix A. Es werden zeilen- und spaltenreduzierende Permutationen verwendet, sodass F.R = F.Q'*A[F.prow,F.pcol]. Die Hauptanwendung dieses Typs besteht darin, kleinste Quadrate oder unterbestimmte Probleme mit \ zu lösen. Die Funktion ruft die C-Bibliothek SPQR^[ACM933] auf.

!!! Hinweis qr(A::SparseMatrixCSC) verwendet die SPQR-Bibliothek, die Teil von SuiteSparse ist. Da diese Bibliothek nur spärliche Matrizen mit Float64 oder ComplexF64-Elementen unterstützt, konvertiert qr ab Julia v1.4 A in eine Kopie, die vom Typ SparseMatrixCSC{Float64} oder SparseMatrixCSC{ComplexF64} ist, je nach Bedarf.

Beispiele

julia> A = sparse([1,2,3,4], [1,1,2,2], [1.0,1.0,1.0,1.0])
4×2 SparseMatrixCSC{Float64, Int64} mit 4 gespeicherten Einträgen:
 1.0   ⋅
 1.0   ⋅
  ⋅   1.0
  ⋅   1.0

julia> qr(A)
SparseArrays.SPQR.QRSparse{Float64, Int64}
Q-Faktor:
4×4 SparseArrays.SPQR.QRSparseQ{Float64, Int64}
R-Faktor:
2×2 SparseMatrixCSC{Float64, Int64} mit 2 gespeicherten Einträgen:
 -1.41421    ⋅
   ⋅       -1.41421
Zeilenpermutation:
4-element Vector{Int64}:
 1
 3
 4
 2
Spaltenpermutation:
2-element Vector{Int64}:
 1
 2

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

Berechne die QR-Zerlegung der Matrix A: eine orthogonale (oder unitäre, wenn A komplexwertig ist) Matrix Q und eine obere Dreiecksmatrix R, sodass

\[A = Q R\]

Das zurückgegebene Objekt F speichert die Zerlegung in einem kompakten Format:

• wenn pivot == ColumnNorm() dann ist F ein QRPivoted Objekt,
• andernfalls, wenn der Elementtyp von A ein BLAS-Typ ist (Float32, Float64, ComplexF32 oder ComplexF64), dann ist F ein QRCompactWY Objekt,
• andernfalls ist F ein QR Objekt.

Die einzelnen Komponenten der Zerlegung F können über Eigenschaftsaccessoren abgerufen werden:

• F.Q: die orthogonale/unitäre Matrix Q
• F.R: die obere Dreiecksmatrix R
• F.p: der Permutationsvektor des Pivots (QRPivoted nur)
• F.P: die Permutationsmatrix des Pivots (QRPivoted nur)

!!! Hinweis Jeder Zugriff auf den oberen Dreifaktor über F.R allokiert ein neues Array. Es ist daher ratsam, dieses Array zu cachen, z.B. durch R = F.R und weiter mit R zu arbeiten.

Die Iteration der Zerlegung erzeugt die Komponenten Q, R und, falls vorhanden, p.

Die folgenden Funktionen sind für die QR-Objekte verfügbar: inv, size und \. Wenn A rechteckig ist, gibt \ eine Lösung der kleinsten Quadrate zurück, und wenn die Lösung nicht eindeutig ist, wird die mit der kleinsten Norm zurückgegeben. Wenn A nicht vollen Rang hat, ist eine Zerlegung mit (Spalten-)Pivotierung erforderlich, um eine Lösung mit minimaler Norm zu erhalten.

Die Multiplikation in Bezug auf entweder volle/quadratische oder nicht volle/quadratische Q ist erlaubt, d.h. sowohl F.Q*F.R als auch F.Q*A werden unterstützt. Eine Q-Matrix kann mit Matrix in eine reguläre Matrix umgewandelt werden. Diese Operation gibt den "dünnen" Q-Faktor zurück, d.h., wenn A m×n mit m>=n ist, dann ergibt Matrix(F.Q) eine m×n Matrix mit orthonormalen Spalten. Um den "vollen" Q-Faktor, eine m×m orthogonale Matrix, abzurufen, verwenden Sie F.Q*I oder collect(F.Q). Wenn m<=n, dann ergibt Matrix(F.Q) eine m×m orthogonale Matrix.

Die Blockgröße für die QR-Zerlegung kann durch das Schlüsselwort-Argument blocksize :: Integer angegeben werden, wenn pivot == NoPivot() und A isa StridedMatrix{<:BlasFloat}. Es wird ignoriert, wenn blocksize > minimum(size(A)). Siehe QRCompactWY.

!!! Kompatibilität "Julia 1.4" Das Schlüsselwort-Argument blocksize erfordert Julia 1.4 oder höher.

Beispiele

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

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

!!! Hinweis qr gibt mehrere Typen zurück, da LAPACK mehrere Darstellungen verwendet, die die Speicheranforderungen für Produkte von Householder-Elementarreflektoren minimieren, sodass die Q- und R-Matrizen kompakt gespeichert werden können, anstatt als zwei separate dichte Matrizen.

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

qr! ist dasselbe wie qr, wenn A ein Subtyp von AbstractMatrix ist, speichert jedoch Platz, indem es die Eingabe A überschreibt, anstatt eine Kopie zu erstellen. Eine InexactError Ausnahme wird ausgelöst, wenn die Faktorisierung eine Zahl produziert, die vom Elementtyp von A nicht darstellbar ist, z. B. für Ganzzahltypen.

Beispiele

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

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

julia> qr!(a)
ERROR: InexactError: Int64(3.1622776601683795)
Stacktrace:
[...]

LQ <: Faktorisierung

Matrixfaktorisierungstyp der LQ-Faktorisierung einer Matrix A. Die LQ-Zerlegung ist die QR Zerlegung von transpose(A). Dies ist der Rückgabetyp von lq, der entsprechenden Matrixfaktorisierungsfunktion.

Wenn S::LQ das Faktorisierungsobjekt ist, kann die untere dreieckige Komponente über S.L und die orthogonale/einheitliche Komponente über S.Q abgerufen werden, sodass A ≈ S.L*S.Q.

Das Iterieren über die Zerlegung erzeugt die Komponenten S.L und S.Q.

Beispiele

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-Faktor:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q-Faktor: 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; # Destrukturierung über Iteration

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

lq(A) -> S::LQ

Berechnen Sie die LQ-Zerlegung von A. Die untere dreieckige Komponente der Zerlegung kann aus dem LQ Objekt S über S.L abgerufen werden, und die orthogonale/einheitliche Komponente über S.Q, sodass A ≈ S.L*S.Q.

Durch Iteration der Zerlegung werden die Komponenten S.L und S.Q erzeugt.

Die LQ-Zerlegung ist die QR-Zerlegung von transpose(A), und sie ist nützlich, um die Lösung mit minimaler Norm lq(A) \ b für ein unterbestimmtes Gleichungssystem zu berechnen (A hat mehr Spalten als Zeilen, hat aber vollen Zeilenrang).

Beispiele

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-Faktor:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q-Faktor: 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; # Destrukturierung über Iteration

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

lq!(A) -> LQ

Berechnen Sie die LQ Faktorisierung von A, indem Sie die Eingabematrix als Arbeitsbereich verwenden. Siehe auch lq.

BunchKaufman <: Faktorisierung

Matrixfaktorisierungstyp der Bunch-Kaufman-Faktorisierung einer symmetrischen oder hermiteschen Matrix A als P'UDU'P oder P'LDL'P, abhängig davon, ob das obere (der Standard) oder das untere Dreieck in A gespeichert ist. Wenn A komplex symmetrisch ist, dann bezeichnen U' und L' die unkonjugierten Transponierten, d.h. transpose(U) und transpose(L), jeweils. Dies ist der Rückgabetyp von bunchkaufman, der entsprechenden Matrixfaktorisierungsfunktion.

Wenn S::BunchKaufman das Faktorisierungsobjekt ist, können die Komponenten über S.D, S.U oder S.L je nach S.uplo und S.p abgerufen werden.

Das Iterieren über die Zerlegung erzeugt die Komponenten S.D, S.U oder S.L je nach S.uplo und S.p.

Beispiele

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

julia> S = bunchkaufman(A) # A wird intern von Symmetric(A) umschlossen
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D-Faktor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U-Faktor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
Permutation:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # Destrukturierung über Iteration

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

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

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

Berechne die Bunch-Kaufman ^[Bunch1977] Faktorisierung einer symmetrischen oder hermiteschen Matrix A als P'*U*D*U'*P oder P'*L*D*L'*P, abhängig davon, welches Dreieck in A gespeichert ist, und gebe ein BunchKaufman Objekt zurück. Beachte, dass wenn A komplex symmetrisch ist, dann U' und L' die unkonjugierten Transponierten bezeichnen, d.h. transpose(U) und transpose(L).

Das Iterieren über die Zerlegung erzeugt die Komponenten S.D, S.U oder S.L je nach dem, was S.uplo angibt, und S.p.

Wenn rook true ist, wird Rook-Pivoting verwendet. Wenn rook false ist, wird kein Rook-Pivoting verwendet.

Wenn check = true ist, wird ein Fehler ausgelöst, wenn die Zerlegung fehlschlägt. Wenn check = false ist, liegt die Verantwortung für die Überprüfung der Gültigkeit der Zerlegung (über issuccess) beim Benutzer.

Die folgenden Funktionen sind für BunchKaufman Objekte verfügbar: size, \, inv, issymmetric, ishermitian, getindex.

Beispiele

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

julia> S = bunchkaufman(A) # A wird intern von Symmetric(A) umschlossen
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D-Faktor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U-Faktor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
Permutation:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # Destrukturierung durch Iteration

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-Faktor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L-Faktor:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
Permutation:
2-element Vector{Int64}:
 2
 1

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

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

bunchkaufman! ist dasselbe wie bunchkaufman, speichert jedoch Platz, indem es die Eingabe A überschreibt, anstatt eine Kopie zu erstellen.

Eigen <: Factorization

Matrixfaktorisierungstyp der Eigenwert-/Spektralzerlegung einer quadratischen Matrix A. Dies ist der Rückgabetyp von eigen, der entsprechenden Matrixfaktorierungsfunktion.

Wenn F::Eigen das Faktorisierungsobjekt ist, können die Eigenwerte über F.values und die Eigenvektoren als Spalten der Matrix F.vectors abgerufen werden. (Der k-te Eigenvektor kann aus dem Slice F.vectors[:, k] abgerufen werden.)

Das Iterieren über die Zerlegung erzeugt die Komponenten F.values und F.vectors.

Beispiele

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

GeneralizedEigen <: Factorization

Matrixfaktorisierungstyp der verallgemeinerten Eigenwert-/Spektralzerlegung von A und B. Dies ist der Rückgabetyp von eigen, der entsprechenden Matrixfaktorierungsfunktion, wenn sie mit zwei Matrixargumenten aufgerufen wird.

Wenn F::GeneralizedEigen das Faktorisierungsobjekt ist, können die Eigenwerte über F.values und die Eigenvektoren als Spalten der Matrix F.vectors abgerufen werden. (Der k-te Eigenvektor kann aus dem Slice F.vectors[:, k] abgerufen werden.)

Das Iterieren über die Zerlegung erzeugt die Komponenten F.values und F.vectors.

Beispiele

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

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

julia> F = eigen(A, B)
GeneralizedEigen{ComplexF64, ComplexF64, Matrix{ComplexF64}, Vector{ComplexF64}}
values:
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im
vectors:
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

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

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

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

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

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

Gibt die Eigenwerte von A zurück.

Für allgemeine nicht-symmetrische Matrizen ist es möglich, anzugeben, wie die Matrix vor der Berechnung der Eigenwerte ausgewogen werden soll. Die Schlüsselwörter permute, scale und sortby sind dieselben wie für eigen.

Beispiele

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

Für einen skalaren Eingabewert gibt eigvals einen Skalar zurück.

Beispiele

julia> eigvals(-2)
-2

eigvals(A, B) -> Werte

Berechnen Sie die verallgemeinerten Eigenwerte von A und B.

Beispiele

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

Gibt die Eigenwerte von A zurück. Es ist möglich, nur eine Teilmenge der Eigenwerte zu berechnen, indem man einen UnitRange irange angibt, der Indizes der sortierten Eigenwerte abdeckt, z.B. die 2. bis 8. Eigenwerte.

Beispiele

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

Gibt die Eigenwerte von A zurück. Es ist möglich, nur eine Teilmenge der Eigenwerte zu berechnen, indem man ein Paar vl und vu für die unteren und oberen Grenzen der Eigenwerte angibt.

Beispiele

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

Dasselbe wie eigvals, aber spart Speicherplatz, indem es die Eingabe A überschreibt, anstatt eine Kopie zu erstellen. Die Schlüsselwörter permute, scale und sortby sind dieselben wie für eigen.

!!! Hinweis Die Eingabematrix A enthält nach dem Aufruf von eigvals! keine Eigenwerte mehr - A wird als Arbeitsbereich verwendet.

Beispiele

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

Gleich wie eigvals, aber spart Speicherplatz, indem die Eingabe A (und B) überschrieben wird, anstatt Kopien zu erstellen.

!!! Hinweis Die Eingabematrizen A und B enthalten nach dem Aufruf von eigvals! ihre Eigenwerte nicht mehr. Sie werden als Arbeitsräume verwendet.

Beispiele

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

Gleich wie eigvals, aber spart Speicherplatz, indem es die Eingabe A überschreibt, anstatt eine Kopie zu erstellen. irange ist ein Bereich von Eigenwert Indizes, nach denen gesucht werden soll - zum Beispiel die 2. bis 8. Eigenwerte.

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

Dasselbe wie eigvals, aber spart Speicherplatz, indem es die Eingabe A überschreibt, anstatt eine Kopie zu erstellen. vl ist die Untergrenze des Intervalls, in dem nach Eigenwerten gesucht wird, und vu ist die Obergrenze.

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

Gibt den größten Eigenwert von A zurück. Die Option permute=true permutiert die Matrix, um näher an eine obere Dreiecksmatrix zu gelangen, und scale=true skaliert die Matrix nach ihren Diagonalelementen, um die Zeilen und Spalten normgleichmäßiger zu machen. Beachten Sie, dass diese Methode fehlschlägt, wenn die Eigenwerte von A komplex sind, da komplexe Zahlen nicht sortiert werden können.

Beispiele

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

julia> eigmax(A)
1.0

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

julia> eigmax(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` kann keine komplexen Eigenwerte haben.
Stacktrace:
[...]

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

Gibt den kleinsten Eigenwert von A zurück. Die Option permute=true permutiert die Matrix, um näher an eine obere Dreiecksmatrix zu gelangen, und scale=true skaliert die Matrix nach ihren Diagonalelementen, um Zeilen und Spalten normgleichmäßiger zu machen. Beachten Sie, dass diese Methode fehlschlägt, wenn die Eigenwerte von A komplex sind, da komplexe Zahlen nicht sortiert werden können.

Beispiele

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

julia> eigmin(A)
-1.0

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

julia> eigmin(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` kann keine komplexen Eigenwerte haben.
Stacktrace:
[...]

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

Gibt eine Matrix M zurück, deren Spalten die Eigenvektoren von A sind. (Der kte Eigenvektor kann aus dem Slice M[:, k] abgerufen werden.)

Wenn der optionale Vektor von Eigenwerten eigvals angegeben ist, gibt eigvecs die entsprechenden spezifischen Eigenvektoren zurück.

Beispiele

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

Gibt eine Matrix M zurück, deren Spalten die Eigenvektoren von A sind. (Der k-te Eigenvektor kann aus dem Slice M[:, k] abgerufen werden.) Die Schlüsselwörter permute, scale und sortby sind die gleichen wie für eigen.

Beispiele

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

Gibt eine Matrix M zurück, deren Spalten die verallgemeinerten Eigenvektoren von A und B sind. (Der kte Eigenvektor kann aus dem Slice M[:, k] abgerufen werden.)

Beispiele

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

Berechnen Sie die Eigenwertzerlegung von A, wobei ein Eigen Faktorisierungsobjekt F zurückgegeben wird, das die Eigenwerte in F.values und die Eigenvektoren in den Spalten der Matrix F.vectors enthält. Dies entspricht der Lösung eines Eigenwertproblems der Form Ax = λx, wobei A eine Matrix ist, x ein Eigenvektor und λ ein Eigenwert. (Der k-te Eigenvektor kann aus dem Slice F.vectors[:, k] abgerufen werden.)

Das Iterieren über die Zerlegung produziert die Komponenten F.values und F.vectors.

Die folgenden Funktionen sind für Eigen-Objekte verfügbar: inv, det und isposdef.

Für allgemeine unsymmetrische Matrizen ist es möglich, anzugeben, wie die Matrix vor der Berechnung der Eigenvektoren balanciert werden soll. Die Option permute=true permutiert die Matrix, um näher an eine obere Dreiecksmatrix zu gelangen, und scale=true skaliert die Matrix durch ihre Diagonalelemente, um Zeilen und Spalten in der Norm gleichmäßiger zu machen. Der Standardwert ist true für beide Optionen.

Standardmäßig werden die Eigenwerte und -vektoren lexikografisch nach (real(λ),imag(λ)) sortiert. Eine andere Vergleichsfunktion by(λ) kann an sortby übergeben werden, oder Sie können sortby=nothing übergeben, um die Eigenwerte in einer beliebigen Reihenfolge zu belassen. Einige spezielle Matrizenarten (z. B. Diagonal oder SymTridiagonal) können ihre eigene Sortierkonvention implementieren und akzeptieren möglicherweise kein sortby-Schlüsselwort.

Beispiele

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; # destrukturieren über Iteration

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

eigen(A, B; sortby) -> GeneralizedEigen

Berechnen Sie die verallgemeinerte Eigenwertzerlegung von A und B, wobei ein GeneralizedEigen Faktorisierungsobjekt F zurückgegeben wird, das die verallgemeinerten Eigenwerte in F.values und die verallgemeinerten Eigenvektoren in den Spalten der Matrix F.vectors enthält. Dies entspricht der Lösung eines verallgemeinerten Eigenwertproblems der Form Ax = λBx, wobei A, B Matrizen sind, x ein Eigenvektor ist und λ ein Eigenwert ist. (Der k-te verallgemeinerte Eigenvektor kann aus dem Slice F.vectors[:, k] abgerufen werden.)

Das Iterieren über die Zerlegung erzeugt die Komponenten F.values und F.vectors.

Standardmäßig sind die Eigenwerte und -vektoren lexikografisch nach (real(λ),imag(λ)) sortiert. Eine andere Vergleichsfunktion by(λ) kann an sortby übergeben werden, oder Sie können sortby=nothing übergeben, um die Eigenwerte in einer beliebigen Reihenfolge zu belassen.

Beispiele

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; # Destrukturierung durch Iteration

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

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

Berechnet die Eigenwertzerlegung von A und gibt ein Eigen Faktorisierungsobjekt F zurück, das die Eigenwerte in F.values und die Eigenvektoren in den Spalten der Matrix F.vectors enthält. (Der k-te Eigenvektor kann aus dem Slice F.vectors[:, k] abgerufen werden.)

Das Iterieren über die Zerlegung erzeugt die Komponenten F.values und F.vectors.

Die folgenden Funktionen sind für Eigen-Objekte verfügbar: inv, det und isposdef.

Der UnitRange irange gibt die Indizes der sortierten Eigenwerte an, nach denen gesucht werden soll.

!!! Hinweis Wenn irange nicht 1:n ist, wobei n die Dimension von A ist, wird die zurückgegebene Faktorisierung eine trunkierte Faktorisierung sein.

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

Berechnet die Eigenwertzerlegung von A und gibt ein Eigen Faktorisierungsobjekt F zurück, das die Eigenwerte in F.values und die Eigenvektoren in den Spalten der Matrix F.vectors enthält. (Der k-te Eigenvektor kann aus dem Slice F.vectors[:, k] abgerufen werden.)

Das Iterieren über die Zerlegung produziert die Komponenten F.values und F.vectors.

Die folgenden Funktionen sind für Eigen-Objekte verfügbar: inv, det und isposdef.

vl ist die untere Grenze des Fensters von Eigenwerten, nach denen gesucht werden soll, und vu ist die obere Grenze.

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

Dasselbe wie eigen, aber spart Speicherplatz, indem es die Eingabe A (und B) überschreibt, anstatt eine Kopie zu erstellen.

Hessenberg <: Faktorisierung

Ein Hessenberg-Objekt repräsentiert die Hessenberg-Faktorisierung QHQ' einer quadratischen Matrix oder eine Verschiebung Q(H+μI)Q' davon, die durch die hessenberg Funktion erzeugt wird.

hessenberg(A) -> Hessenberg

Berechnen Sie die Hessenberg-Zerlegung von A und geben Sie ein Hessenberg-Objekt zurück. Wenn F das Faktorisierungsobjekt ist, kann die unitäre Matrix mit F.Q (vom Typ LinearAlgebra.HessenbergQ) und die Hessenberg-Matrix mit F.H (vom Typ UpperHessenberg) zugegriffen werden, von denen jede in eine reguläre Matrix mit Matrix(F.H) oder Matrix(F.Q) umgewandelt werden kann.

Wenn A Hermitian oder reell-Symmetric ist, produziert die Hessenberg-Zerlegung eine reell-symmetrische tridiagonale Matrix und F.H ist vom Typ SymTridiagonal.

Beachten Sie, dass die verschobene Faktorisierung A+μI = Q (H+μI) Q' effizient durch F + μ*I unter Verwendung des UniformScaling Objekts I konstruiert werden kann, das ein neues Hessenberg-Objekt mit gemeinsamem Speicher und einer modifizierten Verschiebung erstellt. Die Verschiebung eines gegebenen F wird durch F.μ erhalten. Dies ist nützlich, da mehrere verschobene Lösungen (F + μ*I) \ b (für unterschiedliche μ und/oder b) effizient durchgeführt werden können, sobald F erstellt ist.

Die Iteration der Zerlegung produziert die Faktoren F.Q, F.H, F.μ.

Beispiele

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-Faktor: 3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}
H-Faktor:
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; # Destrukturierung durch Iteration

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

hessenberg!(A) -> Hessenberg

hessenberg! ist dasselbe wie hessenberg, speichert jedoch Platz, indem es die Eingabe A überschreibt, anstatt eine Kopie zu erstellen.

Schur <: Faktorisierung

Matrixfaktorisierungstyp der Schur-Faktorisierung einer Matrix A. Dies ist der Rückgabetyp von schur(_), der entsprechenden Matrixfaktorisierungsfunktion.

Wenn F::Schur das Faktorisierungsobjekt ist, kann der (quasi) dreieckige Schur-Faktor entweder über F.Schur oder F.T und die orthogonalen/einheitlichen Schur-Vektoren über F.vectors oder F.Z erhalten werden, sodass A = F.vectors * F.Schur * F.vectors'. Die Eigenwerte von A können mit F.values erhalten werden.

Das Iterieren über die Zerlegung produziert die Komponenten F.T, F.Z und F.values.

Beispiele

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-Faktor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z-Faktor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
Eigenwerte:
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; # Destrukturierung über Iteration

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

GeneralizedSchur <: Faktorisierung

Matrixfaktorisierungstyp der verallgemeinerten Schur-Faktorisierung von zwei Matrizen A und B. Dies ist der Rückgabetyp von schur(_, _), der entsprechenden Matrixfaktorisierungsfunktion.

Wenn F::GeneralizedSchur das Faktorisierungsobjekt ist, können die (quasi) dreieckigen Schur-Faktoren über F.S und F.T erhalten werden, die linken unitären/orthogonalen Schur-Vektoren über F.left oder F.Q, und die rechten unitären/orthogonalen Schur-Vektoren können mit F.right oder F.Z erhalten werden, sodass A=F.left*F.S*F.right' und B=F.left*F.T*F.right'. Die verallgemeinerten Eigenwerte von A und B können mit F.α./F.β erhalten werden.

Das Iterieren der Zerlegung produziert die Komponenten F.S, F.T, F.Q, F.Z, F.α und F.β.

schur(A) -> F::Schur

Berechnet die Schur-Faktorisierung der Matrix A. Der (quasi) dreieckige Schur-Faktor kann aus dem Schur-Objekt F entweder mit F.Schur oder F.T abgerufen werden, und die orthogonalen/einheitlichen Schur-Vektoren können mit F.vectors oder F.Z abgerufen werden, sodass A = F.vectors * F.Schur * F.vectors'. Die Eigenwerte von A können mit F.values abgerufen werden.

Für reelles A ist die Schur-Faktorisierung "quasitriangular", was bedeutet, dass sie oberdreieckig ist, außer mit 2×2-Diagonalblöcken für jedes konjugierte Paar komplexer Eigenwerte; dies ermöglicht es, die Faktorisierung rein reell zu halten, selbst wenn komplexe Eigenwerte vorhanden sind. Um die (komplexe) rein oberdreieckige Schur-Faktorisierung aus einer reellen quasitriangularen Faktorisierung zu erhalten, können Sie Schur{Complex}(schur(A)) verwenden.

Die Iteration der Zerlegung produziert die Komponenten F.T, F.Z und F.values.

Beispiele

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-Faktor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z-Faktor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
Eigenwerte:
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; # Destrukturierung durch Iteration

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

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

Berechnet die verallgemeinerte Schur- (oder QZ-) Faktorisierung der Matrizen A und B. Die (quasi) dreieckigen Schur-Faktoren können aus dem Schur-Objekt F mit F.S und F.T erhalten werden, die linken unitären/orthogonalen Schur-Vektoren können mit F.left oder F.Q und die rechten unitären/orthogonalen Schur-Vektoren können mit F.right oder F.Z erhalten werden, sodass A=F.left*F.S*F.right' und B=F.left*F.T*F.right'. Die verallgemeinerten Eigenwerte von A und B können mit F.α./F.β erhalten werden.

Das Iterieren der Zerlegung produziert die Komponenten F.S, F.T, F.Q, F.Z, F.α und F.β.

schur!(A) -> F::Schur

Dasselbe wie schur, verwendet jedoch das Eingabeargument A als Arbeitsbereich.

Beispiele

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-Faktor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z-Faktor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
Eigenwerte:
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

Dasselbe wie schur, verwendet jedoch die Eingabematrizen A und B als Arbeitsbereich.

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

Ordnet die Schur-Zerlegung F einer Matrix A = Z*T*Z' gemäß dem logischen Array select neu und gibt das neu angeordnete Zerlegungsobjekt F zurück. Die ausgewählten Eigenwerte erscheinen in der Hauptdiagonalen von F.Schur und die entsprechenden führenden Spalten von F.vectors bilden eine orthogonale/einheitliche Basis des entsprechenden rechtsinvarianten Unterraums. Im reellen Fall muss ein komplex konjugiertes Eigenwertpaar entweder vollständig einbezogen oder vollständig ausgeschlossen werden über select.

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

Ordnet die verallgemeinerte Schur-Faktorisierung F eines Matrixpaars (A, B) = (Q*S*Z', Q*T*Z') gemäß dem logischen Array select neu und gibt ein GeneralizedSchur-Objekt F zurück. Die ausgewählten Eigenwerte erscheinen in der Hauptdiagonalen von sowohl F.S als auch F.T, und die linken und rechten orthogonalen/einheitlichen Schur-Vektoren werden ebenfalls so umgeordnet, dass (A, B) = F.Q*(F.S, F.T)*F.Z' weiterhin gilt und die verallgemeinerten Eigenwerte von A und B weiterhin mit F.α./F.β erhalten werden können.

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

Dasselbe wie ordschur, aber überschreibt die Faktorisierung F.

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

Gleich wie ordschur, aber überschreibt die Faktorisierung F.

SVD <: Faktorisierung

Matrixfaktorisierungstyp der singulären Wertzerlegung (SVD) einer Matrix A. Dies ist der Rückgabetyp von svd(_), der entsprechenden Matrixfaktorisierungsfunktion.

Wenn F::SVD das Faktorisierungsobjekt ist, können U, S, V und Vt über F.U, F.S, F.V und F.Vt abgerufen werden, sodass A = U * Diagonal(S) * Vt. Die singulären Werte in S sind in absteigender Reihenfolge sortiert.

Das Iterieren über die Zerlegung erzeugt die Komponenten U, S und V.

Beispiele

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-Faktor:
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
singuläre Werte:
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0
Vt-Faktor:
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; # Destrukturierung über Iteration

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

GeneralizedSVD <: Factorization

Matrixfaktorisierungstyp der verallgemeinerten singulären Wertzerlegung (SVD) von zwei Matrizen A und B, sodass A = F.U*F.D1*F.R0*F.Q' und B = F.V*F.D2*F.R0*F.Q'. Dies ist der Rückgabetyp von svd(_, _), der entsprechenden Matrixfaktorierungsfunktion.

Für eine M-by-N-Matrix A und eine P-by-N-Matrix B gilt:

• U ist eine M-by-M orthogonale Matrix,
• V ist eine P-by-P orthogonale Matrix,
• Q ist eine N-by-N orthogonale Matrix,
• D1 ist eine M-by-(K+L) diagonale Matrix mit 1en in den ersten K Einträgen,
• D2 ist eine P-by-(K+L) Matrix, deren oberes rechtes L-by-L Block diagonal ist,
• R0 ist eine (K+L)-by-N Matrix, deren rechtester (K+L)-by-(K+L) Block nicht singulär oberblocktriangular ist,

K+L ist der effektive numerische Rang der Matrix [A; B].

Die Iteration der Zerlegung erzeugt die Komponenten U, V, Q, D1, D2 und R0.

Die Einträge von F.D1 und F.D2 sind miteinander verbunden, wie in der LAPACK-Dokumentation für die verallgemeinerte SVD und die xGGSVD3 Routine, die darunter aufgerufen wird (in LAPACK 3.6.0 und neuer).

Beispiele

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

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

julia> F = svd(A, B)
GeneralizedSVD{Float64, Matrix{Float64}, Float64, Vector{Float64}}
U factor:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
V factor:
2×2 Matrix{Float64}:
 -0.0  -1.0
  1.0   0.0
Q factor:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
D1 factor:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
D2 factor:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
R0 factor:
2×2 Matrix{Float64}:
 1.41421   0.0
 0.0      -1.41421

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

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

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

Berechnet die singuläre Wertzerlegung (SVD) von A und gibt ein SVD-Objekt zurück.

U, S, V und Vt können aus der Faktorisierung F mit F.U, F.S, F.V und F.Vt abgerufen werden, sodass A = U * Diagonal(S) * Vt. Der Algorithmus erzeugt Vt, und daher ist es effizienter, Vt zu extrahieren als V. Die singulären Werte in S sind in absteigender Reihenfolge sortiert.

Das Iterieren über die Zerlegung erzeugt die Komponenten U, S und V.

Wenn full = false (Standard), wird eine "dünne" SVD zurückgegeben. Für eine $M \times N$-Matrix A ist in der vollen Faktorisierung U $M \times M$ und V $N \times N$, während in der dünnen Faktorisierung U $M \times K$ und V $N \times K$ ist, wobei $K = \min(M,N)$ die Anzahl der singulären Werte ist.

Wenn alg = DivideAndConquer() ein Divide-and-Conquer-Algorithmus verwendet wird, um die SVD zu berechnen. Eine andere (typischerweise langsamere, aber genauere) Option ist alg = QRIteration().

Beispiele

julia> A = rand(4,3);

julia> F = svd(A); # Speichern Sie das Faktorisierungsobjekt

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

julia> U, S, V = F; # Destrukturierung über Iteration

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

julia> Uonly, = svd(A); # Speichern Sie nur U

julia> Uonly == U
true

svd(A, B) -> GeneralizedSVD

Berechnen Sie die verallgemeinerte SVD von A und B, die ein GeneralizedSVD-Faktorisierungsobjekt F zurückgibt, sodass [A;B] = [F.U * F.D1; F.V * F.D2] * F.R0 * F.Q'

• U ist eine M-by-M orthogonale Matrix,
• V ist eine P-by-P orthogonale Matrix,
• Q ist eine N-by-N orthogonale Matrix,
• D1 ist eine M-by-(K+L) diagonale Matrix mit 1en in den ersten K Einträgen,
• D2 ist eine P-by-(K+L) Matrix, deren oberer rechter L-by-L Block diagonal ist,
• R0 ist eine (K+L)-by-N Matrix, deren rechtester (K+L)-by-(K+L) Block nicht-singulär oberblocktriangular ist,

K+L ist der effektive numerische Rang der Matrix [A; B].

Das Iterieren der Zerlegung produziert die Komponenten U, V, Q, D1, D2 und R0.

Die verallgemeinerte SVD wird in Anwendungen verwendet, wie z.B. wenn man vergleichen möchte, wie viel zu A vs. wie viel zu B gehört, wie im menschlichen vs. Hefegenom, oder Signal vs. Rauschen, oder zwischen Clustern vs. innerhalb von Clustern. (Siehe Edelman und Wang für eine Diskussion: https://arxiv.org/abs/1901.00485)

Sie zerlegt [A; B] in [UC; VS]H, wobei [UC; VS] eine natürliche orthogonale Basis für den Spaltenraum von [A; B] ist, und H = RQ' eine natürliche nicht-orthogonale Basis für den Zeilenraum von [A;B], wobei die obersten Zeilen am engsten dem A-Matrix zugeordnet sind und die unteren der B-Matrix. Die Multi-Cosinus/Sinus-Matrizen C und S bieten eine Multi-Messung dafür, wie viel A vs wie viel B, und U und V bieten Richtungen, in denen diese gemessen werden.

Beispiele

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! ist dasselbe wie svd, speichert jedoch Platz, indem es die Eingabe A überschreibt, anstatt eine Kopie zu erstellen. Siehe Dokumentation von svd für Details.

svd!(A, B) -> GeneralizedSVD

svd! ist dasselbe wie svd, ändert jedoch die Argumente A und B in-place, anstatt Kopien zu erstellen. Siehe Dokumentation von svd für Details.

svdvals(A)

Gibt die singulären Werte von A in absteigender Reihenfolge zurück.

Beispiele

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)

Gibt die verallgemeinerten singulären Werte aus der verallgemeinerten singulären Wertzerlegung von A und B zurück. Siehe auch svd.

Beispiele

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)

Gibt die singulären Werte von A zurück und spart Speicherplatz, indem die Eingabe überschrieben wird. Siehe auch svdvals und svd.

svdvals!(A, B)

Gibt die verallgemeinerten singulären Werte aus der verallgemeinerten singulären Wertzerlegung von A und B zurück und spart Speicherplatz, indem A und B überschrieben werden. Siehe auch svd und svdvals.

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

Ein Givens-Rotationslinearoperator. Die Felder c und s repräsentieren den Kosinus und den Sinus des Rotationswinkels. Der Givens-Typ unterstützt die linke Multiplikation G*A und die konjugiert-transponierte rechte Multiplikation A*G'. Der Typ hat keine size und kann daher mit Matrizen beliebiger Größe multipliziert werden, solange i2<=size(A,2) für G*A oder i2<=size(A,1) für A*G'.

Siehe auch givens.

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

Berechnet die Givens-Rotation G und den Skalar r, so dass für jeden Vektor x, bei dem

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

das Ergebnis der Multiplikation

y = G*x

die Eigenschaft hat, dass

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

Siehe auch LinearAlgebra.Givens.

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

Berechnet die Givens-Rotation G und den Skalar r, so dass das Ergebnis der Multiplikation

B = G*A

die Eigenschaft hat, dass

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

Siehe auch LinearAlgebra.Givens. ```

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

Berechnet die Givens-Rotation G und den Skalar r, so dass das Ergebnis der Multiplikation

B = G*x

die Eigenschaft hat, dass

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

Siehe auch LinearAlgebra.Givens. ```

triu(M)

Obere Dreiecksmatrix einer Matrix.

Beispiele

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)

Gibt das obere Dreieck von M zurück, beginnend von der k-ten Superdiagonale.

Beispiele

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)

Obere Dreiecksmatrix einer Matrix, wobei M dabei überschrieben wird. Siehe auch triu.

triu!(M, k::Integer)

Gibt das obere Dreieck von M zurück, beginnend von der k-ten Superdiagonale, und überschreibt dabei M.

Beispiele

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)

Untere Dreiecksmatrix einer Matrix.

Beispiele

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)

Gibt das untere Dreieck von M zurück, beginnend von der k-ten Superdiagonale.

Beispiele

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)

Untere Dreiecksmatrix einer Matrix, wobei M dabei überschrieben wird. Siehe auch tril.

tril!(M, k::Integer)

Gibt das untere Dreieck von M zurück, beginnend von der k-ten Superdiagonale, und überschreibt dabei M.

Beispiele

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())

Ein AbstractRange, der die Indizes der k-ten Diagonale der Matrix M angibt. Optional kann ein Indexstil angegeben werden, der den Typ des zurückgegebenen Bereichs bestimmt. Wenn indstyle isa IndexLinear (Standard), gibt dies einen AbstractRange{Integer} zurück. Andererseits, wenn indstyle isa IndexCartesian, gibt dies einen AbstractRange{CartesianIndex{2}} zurück.

Wenn k nicht angegeben ist, wird angenommen, dass es 0 ist (entsprechend der Hauptdiagonale).

Siehe auch: diag, diagm, Diagonal.

Beispiele

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)

Die k-te Diagonale einer Matrix, als Vektor.

Siehe auch diagm, diagind, Diagonal, isdiag.

Beispiele

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}...)

Konstruiere eine Matrix aus `Pair`s von Diagonalen und Vektoren. Der Vektor `kv.second` wird auf der `kv.first` Diagonale platziert. Standardmäßig ist die Matrix quadratisch und ihre Größe wird aus `kv` abgeleitet, aber eine nicht-quadratische Größe `m`×`n` (mit Nullen aufgefüllt, falls nötig) kann angegeben werden, indem `m,n` als erste Argumente übergeben werden. Bei wiederholten diagonalen Indizes `kv.first` werden die Werte in den entsprechenden Vektoren `kv.second` addiert.

`diagm` konstruiert eine vollständige Matrix; wenn Sie speichereffiziente Versionen mit schneller Arithmetik wünschen, sehen Sie sich [`Diagonal`](@ref), [`Bidiagonal`](@ref), [`Tridiagonal`](@ref) und [`SymTridiagonal`](@ref) an.

# Beispiele

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)

Konstruiere eine Matrix mit den Elementen des Vektors als Diagonalelemente. Standardmäßig ist die Matrix quadratisch und ihre Größe wird durch length(v) angegeben, aber eine nicht-quadratische Größe m×n kann angegeben werden, indem m,n als die ersten Argumente übergeben werden.

Beispiele

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

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

Gibt den Rang der QR-Zerlegung zurück

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

Berechne den Rang von S, indem du seine QR-Zerlegung berechnest. Werte kleiner als tol werden als null betrachtet. Siehe das Handbuch von SPQR.

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

Berechnen Sie den numerischen Rang einer Matrix, indem Sie zählen, wie viele Ausgaben von svdvals(A) größer sind als max(atol, rtol*σ₁), wobei σ₁ der größte berechnete Singularwert von A ist. atol und rtol sind die absoluten und relativen Toleranzen, respectively. Die standardmäßige relative Toleranz ist n*ϵ, wobei n die Größe der kleinsten Dimension von A ist und ϵ die eps des Elementtyps von A.

Beispiele

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)

Für jeden iterierbaren Container A (einschließlich Arrays beliebiger Dimension) von Zahlen (oder jedem Elementtyp, für den norm definiert ist), berechne die p-Norm (standardmäßig p=2), als ob A ein Vektor der entsprechenden Länge wäre.

Die p-Norm ist definiert als

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

wobei $a_i$ die Einträge von A sind, $| a_i |$ die norm von $a_i$ ist und $n$ die Länge von A ist. Da die p-Norm unter Verwendung der norms der Einträge von A berechnet wird, ist die p-Norm eines Vektors von Vektoren im Allgemeinen nicht mit der Interpretation als Blockvektor kompatibel, wenn p != 2.

p kann jeden numerischen Wert annehmen (auch wenn nicht alle Werte eine mathematisch gültige Vektornorm erzeugen). Insbesondere gibt norm(A, Inf) den größten Wert in abs.(A) zurück, während norm(A, -Inf) den kleinsten zurückgibt. Wenn A eine Matrix ist und p=2, dann entspricht dies der Frobenius-Norm.

Das zweite Argument p ist nicht unbedingt Teil der Schnittstelle für norm, d.h. ein benutzerdefinierter Typ kann nur norm(A) ohne zweites Argument implementieren.

Verwende opnorm, um die Operatornorm einer Matrix zu berechnen.

Beispiele

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)

Für Zahlen, geben Sie $\left( |x|^p \right)^{1/p}$ zurück.

Beispiele

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)

Berechne die Operatornorm (oder Matrizenorm), die durch die Vektor p-Norm induziert wird, wobei gültige Werte für p 1, 2 oder Inf sind. (Beachte, dass für spärliche Matrizen p=2 derzeit nicht implementiert ist.) Verwende norm, um die Frobeniusnorm zu berechnen.

Wenn p=1, ist die Operatornorm die maximale absolute Spaltensumme von A:

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

mit $a_{ij}$ den Einträgen von A, und $m$ und $n$ seinen Dimensionen.

Wenn p=2, ist die Operatornorm die spektrale Norm, die dem größten singulären Wert von A entspricht.

Wenn p=Inf, ist die Operatornorm die maximale absolute Zeilensumme von A:

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

Beispiele

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)

Für Zahlen, geben Sie $\left( |x|^p \right)^{1/p}$ zurück. Dies ist äquivalent zu norm.

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

Für Adjoint/Transpose-umwickelte Vektoren gibt die Funktion die Operator-$q$-Norm von A zurück, die äquivalent zur p-Norm mit dem Wert p = q/(q-1) ist. Sie stimmen bei p = q = 2 überein. Verwenden Sie norm, um die p-Norm von A als Vektor zu berechnen.

Der Unterschied in der Norm zwischen einem Vektorraum und seinem Dualraum entsteht, um die Beziehung zwischen Dualität und dem Skalarprodukt zu bewahren, und das Ergebnis ist konsistent mit der Operator p-Norm einer 1 × n-Matrix.

Beispiele

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)

Normalisieren Sie das Array a in-place, sodass seine p-Norm gleich eins ist, d.h. norm(a, p) == 1. Siehe auch normalize und norm.

normalize(a, p::Real=2)

Normalisiere a, sodass seine p-Norm gleich Eins ist, d.h. norm(a, p) == 1. Für Skalare ist dies ähnlich wie sign(a), außer dass normalize(0) = NaN ist. Siehe auch normalize!, norm und sign.

Beispiele

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

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

julia> norm(b)
1.0

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

julia> norm(c, 1)
1.0

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

julia> norm(a)
6.48074069840786

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

julia> normalize(3, 1)
1.0

julia> normalize(-8, 1)
-1.0

julia> normalize(0, 1)
NaN

cond(M, p::Real=2)

Bedingungszahl der Matrix M, berechnet mit der Operator p-Norm. Gültige Werte für p sind 1, 2 (Standard) oder Inf.

condskeel(M, [x, p::Real=Inf])

\[\kappa_S(M, p) = \left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \right\Vert_p \\ \kappa_S(M, x, p) = \frac{\left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \left\vert x \right\vert \right\Vert_p}{\left \Vert x \right \Vert_p}\]

Skeel-Bedingungszahl $\kappa_S$ der Matrix M, optional in Bezug auf den Vektor x, wie mit der Operator p-Norm berechnet. $\left\vert M \right\vert$ bezeichnet die Matrix der (einträgeweise) absoluten Werte von $M$; $\left\vert M \right\vert_{ij} = \left\vert M_{ij} \right\vert$. Gültige Werte für p sind 1, 2 und Inf (Standard).

Diese Größe ist auch in der Literatur als Bauer-Bedingungszahl, relative Bedingungszahl oder komponentenweise relative Bedingungszahl bekannt.

tr(M)

Matrix-Spur. Summiert die Diagonalelemente von M.

Beispiele

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

julia> tr(A)
5

det(M)

Matrix-Determinante.

Siehe auch: logdet und logabsdet.

Beispiele

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

julia> det(M)
2.0

logdet(M)

Logarithmus der Determinante einer Matrix. Entspricht log(det(M)), kann jedoch eine höhere Genauigkeit bieten und Überlauf/Unterlauf vermeiden.

Beispiele

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)

Logarithmus des Absolutwerts der Determinante einer Matrix. Entspricht (log(abs(det(M))), sign(det(M))), kann jedoch erhöhte Genauigkeit und/oder Geschwindigkeit bieten.

Beispiele

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)

Matrixinversion. Berechnet die Matrix N, sodass M * N = I, wobei I die Einheitsmatrix ist. Berechnet durch Lösen der Linksdivision N = M \ I.

Beispiele

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) # wird in Julia 2.0 veraltet sein

Berechnet die Moore-Penrose-Pseudoinverse.

Für Matrizen M mit Gleitkommaelementen ist es praktisch, die Pseudoinverse zu berechnen, indem nur singuläre Werte größer als max(atol, rtol*σ₁) invertiert werden, wobei σ₁ der größte singuläre Wert von M ist.

Die optimale Wahl der absoluten (atol) und relativen Toleranz (rtol) variiert sowohl mit dem Wert von M als auch mit der beabsichtigten Anwendung der Pseudoinverse. Die standardmäßige relative Toleranz ist n*ϵ, wobei n die Größe der kleinsten Dimension von M ist und ϵ die eps des Elementtyps von M ist.

Für die Inversion dichter, schlecht konditionierter Matrizen im Sinne der kleinsten Quadrate wird rtol = sqrt(eps(real(float(oneunit(eltype(M)))))) empfohlen.

Für weitere Informationen siehe ^[issue8859], ^[B96], ^[S84], ^[KY88].

Beispiele

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) # wird in Julia 2.0 veraltet sein

Berechnet eine Basis für den Nullraum von `M`, indem die singulären Vektoren von `M` einbezogen werden, deren singulären Werte Beträge kleiner als `max(atol, rtol*σ₁)` haben, wobei `σ₁` der größte singuläre Wert von `M` ist.

Standardmäßig ist die relative Toleranz `rtol` `n*ϵ`, wobei `n` die Größe der kleinsten Dimension von `M` ist und `ϵ` die [`eps`](@ref) des Elementtyps von `M`.

# Beispiele

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)

Berechnet das Kronecker-Produkt von zwei Vektoren, Matrizen oder Zahlen.

Für reelle Vektoren v und w steht das Kronecker-Produkt in Beziehung zum äußeren Produkt durch kron(v,w) == vec(w * transpose(v)) oder w * transpose(v) == reshape(kron(v,w), (length(w), length(v))). Beachten Sie, wie die Anordnung von v und w links und rechts dieser Ausdrücke unterschiedlich ist (aufgrund der spaltenweisen Speicherung). Bei komplexen Vektoren unterscheidet sich das äußere Produkt w * v' ebenfalls durch die Konjugation von v.

Beispiele

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)

Berechnet das Kronecker-Produkt von A und B und speichert das Ergebnis in C, wobei der vorhandene Inhalt von C überschrieben wird. Dies ist die In-Place-Version von kron.

exp(A::AbstractMatrix)

Berechne die Matrixexponentialfunktion von A, definiert durch

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

Für symmetrisches oder hermitesches A wird eine Eigenzerlegung (eigen) verwendet, andernfalls wird der Skalierungs- und Quadraturalgorithmus gewählt (siehe ^[H05]).

Beispiele

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)

Effizientere Methode für exp(im*A) einer quadratischen Matrix A (insbesondere wenn A Hermitesch oder reell-symmetrisch ist).

Siehe auch cispi, sincos, exp.

Beispiele

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

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

Matrix-Potenz, äquivalent zu $\exp(p\log(A))$

Beispiele

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

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

Matrix-Exponential, äquivalent zu $\exp(\log(b)A)$.

Beispiele

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)

Wenn A keinen negativen reellen Eigenwert hat, berechne den Hauptmatrixlogarithmus von A, d.h. die eindeutige Matrix $X$, so dass $e^X = A$ und $-\pi < Im(\lambda) < \pi$ für alle Eigenwerte $\lambda$ von $X$. Wenn A nichtpositive Eigenwerte hat, wird wann immer möglich eine nicht-hauptsächliche Matrixfunktion zurückgegeben.

Wenn A symmetrisch oder hermitesch ist, wird die Eigenzerlegung (eigen) verwendet, wenn A dreieckig ist, wird eine verbesserte Version der inversen Skalierungs- und Quadraturmethode angewendet (siehe ^[AH12] und ^[AHR13]). Wenn A reell ist und keine negativen Eigenwerte hat, wird die reelle Schur-Form berechnet. Andernfalls wird die komplexe Schur-Form berechnet. Dann wird der obere (quasi-)dreieckige Algorithmus in ^[AHR13] auf den oberen (quasi-)dreieckigen Faktor angewendet.

Beispiele

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

julia> log(A)
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

sqrt(x)

Gibt $\sqrt{x}$ zurück.

Wirft DomainError für negative Real Argumente. Verwenden Sie stattdessen komplexe negative Argumente. Beachten Sie, dass sqrt einen Zweigschnitt entlang der negativen reellen Achse hat.

Der Präfixoperator √ ist äquivalent zu sqrt.

Siehe auch: hypot.

Beispiele

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError mit -81.0:
NaN-Ergebnis für nicht-NaN-Eingabe.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

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

julia> sqrt(-81 - 0.0im)  # -0.0im liegt unter dem Zweigschnitt
0.0 - 9.0im

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

sqrt(A::AbstractMatrix)

Wenn A keine negativen reellen Eigenwerte hat, berechne die Hauptmatrixwurzel von A, das heißt die eindeutige Matrix $X$ mit Eigenwerten, die einen positiven Realteil haben, sodass $X^2 = A$. Andernfalls wird eine nicht-hauptsächliche Wurzel zurückgegeben.

Wenn A reell-symmetrisch oder hermitesch ist, wird die Eigenzerlegung (eigen) verwendet, um die Wurzel zu berechnen. Für solche Matrizen werden Eigenwerte λ, die aufgrund von Rundungsfehlern leicht negativ erscheinen, so behandelt, als wären sie null. Genauer gesagt, werden Matrizen mit allen Eigenwerten ≥ -rtol*(max |λ|) als semidefinit betrachtet (was eine hermitesche Wurzel ergibt), wobei negative Eigenwerte als null betrachtet werden. rtol ist ein Schlüsselwort-Argument für sqrt (nur im hermitesch/reell-symmetrischen Fall), das standardmäßig auf die Maschinenpräzision skaliert mit size(A,1) gesetzt ist.

Andernfalls wird die Wurzel mittels der Björck-Hammarling-Methode ^[BH83] bestimmt, die die komplexe Schur-Form (schur) berechnet und dann die komplexe Wurzel des dreieckigen Faktors. Wenn eine reelle Wurzel existiert, wird stattdessen eine Erweiterung dieser Methode ^[H87] verwendet, die die reelle Schur-Form berechnet und dann die reelle Wurzel des quasi-dreieckigen Faktors.

Beispiele

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})

Berechnet die reellwertige Kubikwurzel einer reellwertigen Matrix A. Wenn T = cbrt(A), dann gilt T*T*T ≈ A, siehe das unten gegebene Beispiel.

Wenn A symmetrisch ist, d.h. vom Typ HermOrSym{<:Real}, dann wird (eigen) verwendet, um die Kubikwurzel zu finden. Andernfalls wird eine spezialisierte Version des p-ten Wurzelalgorithmus ^[S03] verwendet, die die reellwertige Schur-Zerlegung (schur) nutzt, um die Kubikwurzel zu berechnen.

Beispiele

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)

Berechne den Matrix-Cosinus einer quadratischen Matrix A.

Wenn A symmetrisch oder hermitesch ist, wird ihre Eigenzerlegung (eigen) verwendet, um den Cosinus zu berechnen. Andernfalls wird der Cosinus durch den Aufruf von exp bestimmt.

Beispiele

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

sin(A::AbstractMatrix)

Berechne den Matrizensinus einer quadratischen Matrix A.

Wenn A symmetrisch oder hermitesch ist, wird ihre Eigenzerlegung (eigen) verwendet, um den Sinus zu berechnen. Andernfalls wird der Sinus durch den Aufruf von exp bestimmt.

Beispiele

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

sincos(A::AbstractMatrix)

Berechne den Matrix-Sinus und -Kosinus einer quadratischen Matrix A.

Beispiele

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)

Berechne den Matrizen-Tangens einer quadratischen Matrix A.

Wenn A symmetrisch oder hermitesch ist, wird ihre Eigenzerlegung (eigen) verwendet, um den Tangens zu berechnen. Andernfalls wird der Tangens durch den Aufruf von exp bestimmt.

Beispiele

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

sec(A::AbstractMatrix)

Berechne die Sekantenmatrix einer quadratischen Matrix A.

csc(A::AbstractMatrix)

Berechne die Kosekante einer quadratischen Matrix A.

cot(A::AbstractMatrix)

Berechne den Matrix-Cotangens einer quadratischen Matrix A.

cosh(A::AbstractMatrix)

Berechne den hyperbolischen Kosinus einer Matrix für eine quadratische Matrix A.

sinh(A::AbstractMatrix)

Berechne den hyperbolischen Sinus einer Matrix für eine quadratische Matrix A.

tanh(A::AbstractMatrix)

Berechne den hyperbolischen Tangens der Matrix einer quadratischen Matrix A.

sech(A::AbstractMatrix)

Berechne die hyperbolische Sekante der Matrix der quadratischen Matrix A.

csch(A::AbstractMatrix)

Berechne die hyperbolische Kosekans der Matrix des quadratischen Matrix A.

coth(A::AbstractMatrix)

Berechne den hyperbolischen Kotangens der Matrix der quadratischen Matrix A.

acos(A::AbstractMatrix)

Berechne den inversen Matrix-Cosinus einer quadratischen Matrix A.

Wenn A symmetrisch oder hermitesch ist, wird ihre Eigenzerlegung (eigen) verwendet, um den inversen Cosinus zu berechnen. Andernfalls wird der inverse Cosinus unter Verwendung von log und sqrt bestimmt. Für die Theorie und die logarithmischen Formeln, die zur Berechnung dieser Funktion verwendet werden, siehe ^[AH16_1].

Beispiele

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)

Berechne den inversen Matrixsinus einer quadratischen Matrix A.

Wenn A symmetrisch oder hermitesch ist, wird ihre Eigenzerlegung (eigen) verwendet, um den inversen Sinus zu berechnen. Andernfalls wird der inverse Sinus unter Verwendung von log und sqrt bestimmt. Für die Theorie und die logarithmischen Formeln, die zur Berechnung dieser Funktion verwendet werden, siehe ^[AH16_2].

Beispiele

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)

Berechne den inversen Matrixtangens einer quadratischen Matrix A.

Wenn A symmetrisch oder hermitesch ist, wird ihre Eigenzerlegung (eigen) verwendet, um den inversen Tangens zu berechnen. Andernfalls wird der inverse Tangens unter Verwendung von log bestimmt. Für die Theorie und die logarithmischen Formeln, die zur Berechnung dieser Funktion verwendet werden, siehe ^[AH16_3].

Beispiele

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)

Berechne die inverse Matrix der Sekante von A.

acsc(A::AbstractMatrix)

Berechne die inverse Matrix-Kosecans von A.

acot(A::AbstractMatrix)

Berechne die inverse Matrix-Kotangente von A.

acosh(A::AbstractMatrix)

Berechne den inversen hyperbolischen Matrix-Cosinus einer quadratischen Matrix A. Für die Theorie und logarithmischen Formeln, die zur Berechnung dieser Funktion verwendet werden, siehe ^[AH16_4].

asinh(A::AbstractMatrix)

Berechne den inversen hyperbolischen Sinus einer quadratischen Matrix A. Für die Theorie und logarithmischen Formeln, die zur Berechnung dieser Funktion verwendet werden, siehe ^[AH16_5].

atanh(A::AbstractMatrix)

Berechne den inversen hyperbolischen Matrixtangens einer quadratischen Matrix A. Für die Theorie und logarithmischen Formeln, die zur Berechnung dieser Funktion verwendet werden, siehe ^[AH16_6].

asech(A::AbstractMatrix)

Berechne die inverse Matrix hyperbolischer Sekante von A.

acsch(A::AbstractMatrix)

Berechne die inverse Matrix hyperbolischer Kosekanten von A.

acoth(A::AbstractMatrix)

Berechne den inversen Matrix-Hyperbelcotangens von A.

lyap(A, C)

Berechnet die Lösung X der kontinuierlichen Lyapunov-Gleichung AX + XA' + C = 0, wobei kein Eigenwert von A einen reellen Teil von null hat und keine zwei Eigenwerte negative komplexe Konjugierte voneinander sind.

Beispiele

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)

Berechnet die Lösung X der Sylvester-Gleichung AX + XB + C = 0, wobei A, B und C kompatible Dimensionen haben und A und -B keine Eigenwerte mit gleichem Realteil besitzen.

Beispiele

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::Faktorisierung)

Überprüfen, ob eine Faktorisierung einer Matrix erfolgreich war.

Beispiele

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

julia> issuccess(F)
true

issuccess(F::LU; allowsingular = false)

Überprüfen Sie, ob die LU-Zerlegung einer Matrix erfolgreich war. Standardmäßig wird eine Zerlegung, die einen gültigen, aber rangdefizienten U-Faktor produziert, als Fehlschlag betrachtet. Dies kann geändert werden, indem allowsingular = true übergeben wird.

Beispiele

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

julia> issuccess(F)
false

julia> issuccess(F, allowsingular = true)
true

issymmetric(A) -> Bool

Überprüfen, ob eine Matrix symmetrisch ist.

Beispiele

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

Überprüfen, ob eine Matrix positiv definit (und hermitesch) ist, indem versucht wird, eine Cholesky-Zerlegung von A durchzuführen.

Siehe auch isposdef!, cholesky.

Beispiele

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

julia> isposdef(A)
true

isposdef!(A) -> Bool

Testen Sie, ob eine Matrix positiv definit (und hermitesch) ist, indem Sie versuchen, eine Cholesky-Zerlegung von A durchzuführen, wobei A im Prozess überschrieben wird. Siehe auch isposdef.

Beispiele

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

Überprüfen, ob A untere Dreiecksmatrix ist, beginnend von der k-ten Superdiagonale.

Beispiele

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

Überprüfen, ob A oberhalb der Diagonale ist, beginnend von der k-ten Überdiagonale.

Beispiele

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

Überprüfen, ob eine Matrix diagonal ist, im Sinne von iszero(A[i,j]), was wahr ist, es sei denn, i == j. Beachten Sie, dass es nicht notwendig ist, dass A quadratisch ist; wenn Sie das auch überprüfen möchten, müssen Sie sicherstellen, dass size(A, 1) == size(A, 2).

Beispiele

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

Überprüfen, ob eine Matrix hermitesch ist.

Beispiele

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)

Fauler Transponieren. Das Mutieren des zurückgegebenen Objekts sollte A entsprechend mutieren. Oft, aber nicht immer, ergibt sich Transpose(A), wobei Transpose ein Wrapper für das faule Transponieren ist. Beachten Sie, dass diese Operation rekursiv ist.

Diese Operation ist für die Verwendung in der linearen Algebra gedacht - für allgemeine Datenmanipulation siehe permutedims, die nicht rekursiv ist.

Beispiele

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 # das Transponieren eines Transponierten entpackt den Elternteil
true

julia> Transpose(B) # jedoch umschließt der Konstruktor immer sein Argument
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
 3  2
 0  0

julia> B[1,2] = 4; # das Modifizieren von B wird A automatisch ändern

julia> A
2×2 Matrix{Int64}:
 3  2
 4  0

Für komplexe Matrizen ist die adjoint-Operation äquivalent zu einer konjugierten Transponierung.

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

Das transpose eines AbstractVector ist ein Zeilenvektor:

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

julia> transpose(v) # gibt einen Zeilenvektor zurück
1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> transpose(v) * v # berechnet das Skalarprodukt
14

Für eine Matrix von Matrizen werden die einzelnen Blöcke rekursiv bearbeitet:

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

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

julia> transpose(D) # Blöcke werden rekursiv transponiert
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::Faktorisierung)

Faulheitstransposition der Faktorisierung F. Gibt standardmäßig eine TransposeFactorization zurück, es sei denn, es handelt sich um Faktorisierungen mit reellem eltype, in diesem Fall wird eine AdjointFactorization zurückgegeben.

transpose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

Transponiere die Matrix A und speichere sie in der Matrix X. size(X) muss gleich size(transpose(A)) sein. Es wird kein zusätzlicher Speicher zugewiesen, außer wenn die rowval und nzval von X bei Bedarf angepasst werden.

Siehe halfperm!

transpose!(dest,src)

Transponiere das Array src und speichere das Ergebnis im vorab allokierten Array dest, das eine Größe entsprechend (size(src,2),size(src,1)) haben sollte. Es wird keine In-Place-Transposition unterstützt, und unerwartete Ergebnisse treten auf, wenn src und dest überlappende Speicherbereiche haben.

Beispiele

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

Transponieren

Fauler Wrapper-Typ für eine Transponierungsansicht des zugrunde liegenden linearen Algebraobjekts, normalerweise ein AbstractVector/AbstractMatrix. Normalerweise sollte der Transpose-Konstruktor nicht direkt aufgerufen werden, verwenden Sie stattdessen transpose. Um die Ansicht zu materialisieren, verwenden Sie copy.

Dieser Typ ist für die Verwendung in der linearen Algebra gedacht - für allgemeine Datenmanipulation siehe permutedims.

Beispiele

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

Fauler Wrapper-Typ für die Transponierte des zugrunde liegenden Factorization-Objekts. Normalerweise sollte der Konstruktor TransposeFactorization nicht direkt aufgerufen werden, verwenden Sie stattdessen transpose(:: Factorization).

A'
adjoint(A)

Fauler Adjungierte (konjugierte Transposition). Beachten Sie, dass adjoint rekursiv auf Elemente angewendet wird.

Für Zahlentypen gibt adjoint das komplexe Konjugat zurück und ist daher für reelle Zahlen äquivalent zur Identitätsfunktion.

Dieser Vorgang ist für die Verwendung in der linearen Algebra gedacht - für allgemeine Datenmanipulation siehe permutedims.

Beispiele

julia> A = [3+2im 9+2im; 0  0]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 0+0im  0+0im

julia> B = A' # äquivalent zu adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) mit eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

julia> B isa Adjoint
true

julia> adjoint(B) === A # die Adjungierte einer Adjungierten entfaltet den Elternteil
true

julia> Adjoint(B) # jedoch umschließt der Konstruktor immer sein Argument
2×2 adjoint(adjoint(::Matrix{Complex{Int64}})) mit eltype Complex{Int64}:
 3+2im  9+2im
 0+0im  0+0im

julia> B[1,2] = 4 + 5im; # das Ändern von B ändert automatisch A

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 4-5im  0+0im

Für reelle Matrizen ist die adjoint-Operation äquivalent zu einer transpose.

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

julia> A'
2×2 adjoint(::Matrix{Int64}) mit eltype Int64:
 1  2
 3  4

julia> adjoint(A) == transpose(A)
true

Die Adjungierte eines AbstractVector ist ein Zeilenvektor:

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

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

julia> x'x # berechne das Skalarprodukt, äquivalent zu x' * x
25 + 0im

Für eine Matrix von Matrizen werden die einzelnen Blöcke rekursiv bearbeitet:

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}}}) mit 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::Faktorisierung)

Fauler adjoint der Faktorisierung F. Gibt standardmäßig einen AdjointFactorization Wrapper zurück.

adjoint!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

Transponiere die Matrix A und speichere den Adjungierten der Elemente in der Matrix X. size(X) muss gleich size(transpose(A)) sein. Es wird kein zusätzlicher Speicher zugewiesen, außer wenn die Zeilenwerte und nzval von X bei Bedarf angepasst werden.

Siehe halfperm!

adjoint!(dest,src)

Konjugiert die Transponierte des Arrays src und speichert das Ergebnis im vorab allokierten Array dest, das eine Größe entsprechend (size(src,2),size(src,1)) haben sollte. Es wird keine In-Place-Transposition unterstützt, und unerwartete Ergebnisse können auftreten, wenn src und dest überlappende Speicherbereiche haben.

Beispiele

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

Fauler Wrapper-Typ für eine adjungierte Ansicht des zugrunde liegenden linearen Algebraobjekts, normalerweise ein AbstractVector/AbstractMatrix. Normalerweise sollte der Adjoint-Konstruktor nicht direkt aufgerufen werden, verwenden Sie stattdessen adjoint. Um die Ansicht zu materialisieren, verwenden Sie copy.

Dieser Typ ist für die Verwendung in der linearen Algebra gedacht - für allgemeine Datenmanipulation siehe permutedims.

Beispiele

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}}) mit eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

AdjointFaktorisierung

Fauler Wrapper-Typ für die Adjungierte des zugrunde liegenden Faktorisierungs-Objekts. Normalerweise sollte der Konstruktor AdjointFaktorisierung nicht direkt aufgerufen werden, verwenden Sie stattdessen adjoint(:: Faktorisierung).

copy(A::Transpose)
copy(A::Adjoint)

Bewerten Sie die faule Matrixtransposition/-adjungierung eifrig. Beachten Sie, dass die Transposition rekursiv auf die Elemente angewendet wird.

Dieser Vorgang ist für die Verwendung in der linearen Algebra gedacht - für allgemeine Datenmanipulation siehe permutedims, das nicht rekursiv ist.

Beispiele

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

Gibt die Entfernung zwischen aufeinanderfolgenden Array-Elementen in Dimension 1 in Einheiten der Elementgröße zurück.

Beispiele

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)

Überprüfen Sie, ob eine Matrix quadratisch ist, und geben Sie dann ihre gemeinsame Dimension zurück. Bei mehreren Argumenten geben Sie einen Vektor zurück.

Beispiele

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 berechnet die maximale Flop-Rate des Computers, indem es die doppelte Genauigkeit gemm! verwendet. Standardmäßig multipliziert es, wenn keine Argumente angegeben sind, zwei Float64-Matrizen der Größe n x n, wobei n = 4096. Wenn das zugrunde liegende BLAS mehrere Threads verwendet, werden höhere Flop-Raten erreicht. Die Anzahl der BLAS-Threads kann mit BLAS.set_num_threads(n) festgelegt werden.

Wenn das Schlüsselwort-Argument eltype angegeben ist, wird peakflops Matrizen mit Elementen des Typs eltype konstruieren, um die maximale Flop-Rate zu berechnen.

Standardmäßig verwendet peakflops die beste Zeit aus 3 Versuchen. Wenn das Schlüsselwort-Argument ntrials angegeben ist, verwendet peakflops so viele Versuche, um die beste Zeit auszuwählen.

Wenn das Schlüsselwort-Argument parallel auf true gesetzt ist, wird peakflops parallel auf allen Arbeitsprozessoren ausgeführt. Die Flop-Rate des gesamten parallelen Computers wird zurückgegeben. Bei der Ausführung in parallel wird nur 1 BLAS-Thread verwendet. Das Argument n bezieht sich weiterhin auf die Größe des Problems, das auf jedem Prozessor gelöst wird.

hermitianpart(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

Gibt den hermiteschen Teil der quadratischen Matrix A zurück, definiert als (A + A') / 2, als Hermitian Matrix. Für reelle Matrizen A ist dies auch als der symmetrische Teil von A bekannt; es wird auch manchmal als der "operatorielle reale Teil" bezeichnet. Das optionale Argument uplo steuert das entsprechende Argument der Hermitian Ansicht. Für reelle Matrizen ist letzteres äquivalent zu einer Symmetric Ansicht.

Siehe auch hermitianpart! für die entsprechende In-Place-Operation.

hermitianpart!(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

Überschreibe die quadratische Matrix A in-place mit ihrem hermiteschen Teil (A + A') / 2 und gib Hermitian(A, uplo) zurück. Für reelle Matrizen A ist dies auch als der symmetrische Teil von A bekannt.

Siehe auch hermitianpart für die entsprechende Operation außerhalb des Platzes.

copy_adjoint!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

Effizient Elemente der Matrix A nach B mit Adjunktion wie folgt kopieren:

B[ir_dest, jr_dest] = adjoint(A)[jr_src, ir_src]

Die Elemente B[ir_dest, jr_dest] werden überschrieben. Darüber hinaus müssen die Indexbereichsparameter length(ir_dest) == length(jr_src) und length(jr_dest) == length(ir_src) erfüllen.

copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

Effizient Elemente der Matrix A nach B mit Transposition wie folgt kopieren:

B[ir_dest, jr_dest] = transpose(A)[jr_src, ir_src]

Die Elemente B[ir_dest, jr_dest] werden überschrieben. Darüber hinaus müssen die Indexbereichsparameter die Bedingungen length(ir_dest) == length(jr_src) und length(jr_dest) == length(ir_src) erfüllen.

copy_transpose!(B::AbstractMatrix, ir_dest::AbstractUnitRange, jr_dest::AbstractUnitRange,
                tM::AbstractChar,
                M::AbstractVecOrMat, ir_src::AbstractUnitRange, jr_src::AbstractUnitRange) -> B

Effizient Elemente der Matrix M nach B kopieren, bedingt durch den Zeichenparameter tM, wie folgt:

Die Elemente B[ir_dest, jr_dest] werden überschrieben. Darüber hinaus müssen die Indexbereichsparameter die Bedingung length(ir_dest) == length(jr_src) und length(jr_dest) == length(ir_src) erfüllen.

Siehe auch copyto! und copy_adjoint!.

mul!(Y, A, B) -> Y

Berechnet das Matrix-Matrix- oder Matrix-Vektor-Produkt $A B$ und speichert das Ergebnis in Y, wobei der vorhandene Wert von Y überschrieben wird. Beachten Sie, dass Y nicht mit A oder B aliasiert sein darf.

Beispiele

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

Implementierung

Für benutzerdefinierte Matrix- und Vektortypen wird empfohlen, die 5-Argumente mul! zu implementieren, anstatt direkt die 3-Argumente mul! zu implementieren, wenn möglich.

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

Kombinierte In-Place-Matrix-Matrix- oder Matrix-Vektor-Multiplikation und Addition $A B α + C β$. Das Ergebnis wird in C gespeichert, indem es überschrieben wird. Beachten Sie, dass C nicht mit A oder B aliasiert sein darf.

Beispiele

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]; # Eine Kopie des ursprünglichen Wertes von C

julia> C == A * B * α + C_original * β
true

lmul!(a::Number, B::AbstractArray)

Skaliere ein Array B mit einem Skalar a, indem B vor Ort überschrieben wird. Verwende rmul!, um den Skalar von rechts zu multiplizieren. Die Skalierungsoperation respektiert die Semantik der Multiplikation * zwischen a und einem Element von B. Insbesondere gilt dies auch für Multiplikationen, die nicht-finite Zahlen wie NaN und ±Inf betreffen.

Beispiele

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)

Berechnen Sie das Matrix-Matrix-Produkt $AB$, überschreiben Sie B und geben Sie das Ergebnis zurück. Hier muss A von einem speziellen Matrizen-Typ sein, wie z.B. Diagonal, UpperTriangular oder LowerTriangular, oder von einem orthogonalen Typ, siehe QR.

Beispiele

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)

Skaliere ein Array A mit einem Skalar b, indem A vor Ort überschrieben wird. Verwende lmul!, um den Skalar von links zu multiplizieren. Die Skalierungsoperation respektiert die Semantik der Multiplikation * zwischen einem Element von A und b. Insbesondere gilt dies auch für Multiplikationen, die nicht-finite Zahlen wie NaN und ±Inf betreffen.

Beispiele

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)

Berechne das Matrix-Matrix-Produkt $AB$, überschreibe A und gib das Ergebnis zurück. Hier muss B von einem speziellen Matrizen-Typ sein, wie z.B. Diagonal, UpperTriangular oder LowerTriangular, oder von einem orthogonalen Typ, siehe QR.

Beispiele

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

Berechne A \ B in-place und speichere das Ergebnis in Y, wobei das Ergebnis zurückgegeben wird.

Das Argument A sollte keine Matrix sein. Stattdessen sollte es ein Faktorisierungsobjekt sein (z. B. erzeugt durch factorize oder cholesky). Der Grund dafür ist, dass die Faktorisierung selbst sowohl teuer ist als auch typischerweise Speicher allokiert (obwohl sie auch in-place durchgeführt werden kann, z. B. durch lu!), und leistungs-kritische Situationen, die ldiv! erfordern, normalerweise auch eine feinkörnige Kontrolle über die Faktorisierung von A benötigen.

!!! Hinweis Bestimmte strukturierte Matrizenarten, wie Diagonal und UpperTriangular, sind erlaubt, da diese bereits in einer faktorisierte Form vorliegen.

Beispiele

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)

Berechne A \ B in-place und überschreibe B, um das Ergebnis zu speichern.

Das Argument A sollte keine Matrix sein. Stattdessen sollte es ein Faktorisierungsobjekt sein (z. B. erzeugt durch factorize oder cholesky). Der Grund dafür ist, dass die Faktorisierung selbst sowohl teuer ist als auch typischerweise Speicher allokiert (obwohl sie auch in-place durchgeführt werden kann, z. B. durch lu!), und leistungs-kritische Situationen, die ldiv! erfordern, in der Regel auch eine feinkörnige Kontrolle über die Faktorisierung von A benötigen.

!!! Hinweis Bestimmte strukturierte Matrizenarten, wie Diagonal und UpperTriangular, sind erlaubt, da diese bereits in einer faktorisierte Form vorliegen.

Beispiele

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)

Teile jeden Eintrag in einem Array B durch einen Skalar a und überschreibe B im Platz. Verwende rdiv!, um den Skalar von rechts zu teilen.

Beispiele

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

Berechne A \ B in-place durch Gaußsche Eliminierung mit partieller Pivotierung und speichere das Ergebnis in B, wobei das Ergebnis zurückgegeben wird. Dabei werden auch die Diagonalen von A überschrieben.

rdiv!(A, B)

Berechnet A / B im Platz und überschreibt A, um das Ergebnis zu speichern.

Das Argument B sollte kein Matrix sein. Stattdessen sollte es ein Faktorisierungsobjekt sein (z. B. erzeugt durch factorize oder cholesky). Der Grund dafür ist, dass die Faktorisierung selbst sowohl teuer ist als auch typischerweise Speicher allokiert (obwohl sie auch im Platz durchgeführt werden kann, z. B. durch lu!), und leistungs-kritische Situationen, die rdiv! erfordern, normalerweise auch eine feinkörnige Kontrolle über die Faktorisierung von B erfordern.

rdiv!(A::AbstractArray, b::Number)

Teile jeden Eintrag in einem Array A durch einen Skalar b, wobei A vor Ort überschrieben wird. Verwende ldiv!, um den Skalar von links zu teilen.

Beispiele

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

Schnittstelle zu BLAS-Unterprogrammen.

set_num_threads(n::Integer)
set_num_threads(::Nothing)

Setzen Sie die Anzahl der Threads, die die BLAS-Bibliothek verwenden soll, gleich n::Integer.

Akzeptiert auch nothing, in diesem Fall versucht Julia, die Standardanzahl der Threads zu erraten. Das Übergeben von nothing wird nicht empfohlen und existiert hauptsächlich aus historischen Gründen.

get_num_threads()

Holen Sie sich die Anzahl der Threads, die die BLAS-Bibliothek verwendet.

rot!(n, X, incx, Y, incy, c, s)

Überschreibt X mit c*X + s*Y und Y mit -conj(s)*X + c*Y für die ersten n Elemente des Arrays X mit Schrittweite incx und die ersten n Elemente des Arrays Y mit Schrittweite incy. Gibt X und Y zurück.

scal!(n, a, X, incx)
scal!(a, X)

Überschreibt X mit a*X für die ersten n Elemente des Arrays X mit Schrittweite incx. Gibt X zurück.

Wenn n und incx nicht angegeben sind, werden length(X) und stride(X,1) verwendet.

scal(n, a, X, incx)
scal(a, X)

Gibt X zurück, skaliert mit a für die ersten n Elemente des Arrays X mit Schrittweite incx.

Wenn n und incx nicht angegeben sind, werden length(X) und stride(X,1) verwendet.

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

Kopiere n Elemente des Arrays X mit Schrittweite incx in das Array Y mit Schrittweite incy. Gibt Y zurück.

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

Skalarprodukt von zwei Vektoren, die aus n Elementen des Arrays X mit Schrittweite incx und n Elementen des Arrays Y mit Schrittweite incy bestehen.

Beispiele

julia> BLAS.dot(10, fill(1.0, 10), 1, fill(1.0, 20), 2)
10.0

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

Dot-Funktion für zwei komplexe Vektoren, die aus n Elementen des Arrays X mit Schrittweite incx und n Elementen des Arrays Y mit Schrittweite incy bestehen.

Beispiele

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)

Dot-Funktion für zwei komplexe Vektoren, bestehend aus n Elementen des Arrays X mit Schrittweite incx und n Elementen des Arrays U mit Schrittweite incy, wobei der erste Vektor konjugiert wird.

Beispiele

julia> BLAS.dotc(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
10.0 - 10.0im

nrm2(n, X, incx)

2-Norm eines Vektors, der aus n Elementen des Arrays X mit Schrittweite incx besteht.

Beispiele

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)

Summe der Beträge der ersten n Elemente des Arrays X mit Schrittweite incx.

Für ein reelles Array ist der Betrag der absolute Wert. Für ein komplexes Array ist der Betrag die Summe des absoluten Wertes des Realteils und des absoluten Wertes des Imaginärteils.

Beispiele

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)

Finde den Index des Elements von dx mit dem maximalen Absolutwert. n ist die Länge von dx, und incx ist der Schritt. Wenn n und incx nicht angegeben sind, nehmen sie die Standardwerte n=length(dx) und incx=stride1(dx) an.

gemv!(tA, alpha, A, x, beta, y)

Aktualisiere den Vektor y als alpha*A*x + beta*y oder alpha*A'x + beta*y gemäß tA. alpha und beta sind Skalare. Gib das aktualisierte y zurück.

gemv(tA, alpha, A, x)

Gibt alpha*A*x oder alpha*A'x zurück, je nach tA. alpha ist ein Skalar.

gemv(tA, A, x)

Gibt A*x oder A'x zurück, je nach tA.

gbmv!(trans, m, kl, ku, alpha, A, x, beta, y)

Aktualisiere den Vektor y als alpha*A*x + beta*y oder alpha*A'*x + beta*y gemäß trans. Die Matrix A ist eine allgemeine Bandmatrix der Dimension m mal size(A,2) mit kl Unterdiagonalen und ku Oberdiagonalen. alpha und beta sind Skalare. Gib das aktualisierte y zurück.

gbmv(trans, m, kl, ku, alpha, A, x)

Gibt alpha*A*x oder alpha*A'*x zurück, je nach trans. Die Matrix A ist eine allgemeine Bandmatrix der Dimension m mal size(A,2) mit kl Unterdiagonalen und ku Oberdiagonalen, und alpha ist ein Skalar.

hemv!(ul, alpha, A, x, beta, y)

Aktualisiere den Vektor y als alpha*A*x + beta*y. A wird als hermitesch angenommen. Nur das ul Dreieck von A wird verwendet. alpha und beta sind Skalare. Gib das aktualisierte y zurück.

hemv(ul, alpha, A, x)

Gibt alpha*A*x zurück. A wird als hermitesch angenommen. Nur das ul Dreieck von A wird verwendet. alpha ist ein Skalar.

hemv(ul, A, x)

Gibt A*x zurück. A wird als hermitesch angenommen. Nur das ul Dreieck von A wird verwendet.

hpmv!(uplo, α, AP, x, β, y)

Aktualisiere den Vektor y als α*A*x + β*y, wobei A eine hermitesche Matrix ist, die im gepackten Format AP bereitgestellt wird.

Mit uplo = 'U' muss das Array AP den oberen Dreiecksteil der hermiteschen Matrix sequenziell, spaltenweise enthalten, sodass AP[1] A[1, 1] enthält, AP[2] und AP[3] A[1, 2] und A[2, 2] enthalten, und so weiter.

Mit uplo = 'L' muss das Array AP den unteren Dreiecksteil der hermiteschen Matrix sequenziell, spaltenweise enthalten, sodass AP[1] A[1, 1] enthält, AP[2] und AP[3] A[2, 1] und A[3, 1] enthalten, und so weiter.

Die skalaren Eingaben α und β müssen komplexe oder reelle Zahlen sein.

Die Array-Eingaben x, y und AP müssen alle vom Typ ComplexF32 oder ComplexF64 sein.

Gib das aktualisierte y zurück.

symv!(ul, alpha, A, x, beta, y)

Aktualisiere den Vektor y als alpha*A*x + beta*y. A wird als symmetrisch angenommen. Nur das ul Dreieck von A wird verwendet. alpha und beta sind Skalare. Gib das aktualisierte y zurück.

symv(ul, alpha, A, x)

Gibt alpha*A*x zurück. A wird als symmetrisch angenommen. Nur das ul Dreieck von A wird verwendet. alpha ist ein Skalar.

symv(ul, A, x)

Gibt A*x zurück. A wird als symmetrisch angenommen. Nur das ul Dreieck von A wird verwendet.

sbmv!(uplo, k, alpha, A, x, beta, y)

Aktualisiere den Vektor y als alpha*A*x + beta*y, wobei A eine symmetrische Bandmatrix der Ordnung size(A,2) mit k Überdiagonalen ist, die im Argument A gespeichert sind. Das Speicherlayout für A wird im Referenz-BLAS-Modul, Level-2 BLAS unter https://www.netlib.org/lapack/explore-html/ beschrieben. Nur das uplo Dreieck von A wird verwendet.

Gib das aktualisierte y zurück.

sbmv(uplo, k, alpha, A, x)

Gibt alpha*A*x zurück, wobei A eine symmetrische Bandmatrix der Ordnung size(A,2) mit k Superdiagonalen ist, die im Argument A gespeichert sind. Nur das uplo Dreieck von A wird verwendet.

sbmv(uplo, k, A, x)

Gibt A*x zurück, wobei A eine symmetrische Bandmatrix der Ordnung size(A,2) mit k Superdiagonalen ist, die im Argument A gespeichert sind. Nur das uplo Dreieck von A wird verwendet.

spmv!(uplo, α, AP, x, β, y)

Aktualisiere den Vektor y als α*A*x + β*y, wobei A eine symmetrische Matrix ist, die im gepackten Format AP bereitgestellt wird.

Mit uplo = 'U' muss das Array AP den oberen Dreiecksteil der symmetrischen Matrix sequenziell, spaltenweise enthalten, sodass AP[1] A[1, 1] enthält, AP[2] und AP[3] A[1, 2] und A[2, 2] enthalten, und so weiter.

Mit uplo = 'L' muss das Array AP den unteren Dreiecksteil der symmetrischen Matrix sequenziell, spaltenweise enthalten, sodass AP[1] A[1, 1] enthält, AP[2] und AP[3] A[2, 1] und A[3, 1] enthalten, und so weiter.

Die skalaren Eingaben α und β müssen reell sein.

Die Array-Eingaben x, y und AP müssen alle vom Typ Float32 oder Float64 sein.

Gib das aktualisierte y zurück.

trmv!(ul, tA, dA, A, b)

Gibt op(A)*b zurück, wobei op durch tA bestimmt wird. Nur das ul Dreieck von A wird verwendet. dA bestimmt, ob die Diagonalwerte gelesen oder als alle Einsen angenommen werden. Die Multiplikation erfolgt in-place auf b.

trmv(ul, tA, dA, A, b)

Gibt op(A)*b zurück, wobei op durch tA bestimmt wird. Nur das ul Dreieck von A wird verwendet. dA bestimmt, ob die Diagonalwerte gelesen oder als alle Einsen angenommen werden.

trsv!(ul, tA, dA, A, b)

Überschreibe b mit der Lösung von A*x = b oder einer der anderen beiden Varianten, die durch tA und ul bestimmt werden. dA bestimmt, ob die Diagonalwerte gelesen oder als alle Einsen angenommen werden. Gib das aktualisierte b zurück.

trsv(ul, tA, dA, A, b)

Geben Sie die Lösung für A*x = b oder eine der anderen beiden Varianten zurück, die durch tA und ul bestimmt werden. dA bestimmt, ob die Diagonalwerte gelesen oder als alle Einsen angenommen werden.

ger!(alpha, x, y, A)

Rank-1-Aktualisierung der Matrix A mit den Vektoren x und y als alpha*x*y' + A.

her!(uplo, alpha, x, A)

Methoden nur für komplexe Arrays. Rang-1-Aktualisierung der hermiteschen Matrix A mit dem Vektor x als alpha*x*x' + A. uplo steuert, welches Dreieck von A aktualisiert wird. Gibt A zurück.

syr!(uplo, alpha, x, A)

Rank-1-Aktualisierung der symmetrischen Matrix A mit dem Vektor x als alpha*x*transpose(x) + A. uplo steuert, welches Dreieck von A aktualisiert wird. Gibt A zurück.

spr!(uplo, α, x, AP)

Aktualisiere die Matrix A als A+α*x*x', wobei A eine symmetrische Matrix ist, die im gepackten Format AP bereitgestellt wird und x ein Vektor ist.

Mit uplo = 'U' muss das Array AP den oberen Dreiecksteil der symmetrischen Matrix sequenziell, spaltenweise enthalten, sodass AP[1] A[1, 1] enthält, AP[2] und AP[3] A[1, 2] und A[2, 2] enthalten, und so weiter.

Mit uplo = 'L' muss das Array AP den unteren Dreiecksteil der symmetrischen Matrix sequenziell, spaltenweise enthalten, sodass AP[1] A[1, 1] enthält, AP[2] und AP[3] A[2, 1] und A[3, 1] enthalten, und so weiter.

Der skalare Eingabewert α muss reell sein.

Die Array-Eingaben x und AP müssen alle vom Typ Float32 oder Float64 sein. Gib das aktualisierte AP zurück.

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

Aktualisiert den unteren oder oberen dreieckigen Teil, der durch uplo von C angegeben ist, als alpha*A*B + beta*C oder die anderen Varianten gemäß tA und tB. Gibt das aktualisierte C zurück.

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

Gibt den unteren oder oberen dreieckigen Teil an, der durch uplo von A*B oder den anderen drei Varianten gemäß tA und tB angegeben ist.

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

Gibt den unteren oder oberen dreieckigen Teil an, der durch uplo von A*B oder den anderen drei Varianten gemäß tA und tB angegeben ist.

gemm!(tA, tB, alpha, A, B, beta, C)

Aktualisiere C als alpha*A*B + beta*C oder die anderen drei Varianten gemäß tA und tB. Gib das aktualisierte C zurück.

gemm(tA, tB, alpha, A, B)

Gibt alpha*A*B oder die anderen drei Varianten gemäß tA und tB zurück.

gemm(tA, tB, A, B)

Gibt A*B oder die anderen drei Varianten gemäß tA und tB zurück.

symm!(seite, ul, alpha, A, B, beta, C)

Aktualisiere C als alpha*A*B + beta*C oder alpha*B*A + beta*C gemäß seite. A wird als symmetrisch angenommen. Nur das ul Dreieck von A wird verwendet. Gib das aktualisierte C zurück.

symm(seite, ul, alpha, A, B)

Gibt alpha*A*B oder alpha*B*A zurück, je nach seite. A wird als symmetrisch angenommen. Nur das ul Dreieck von A wird verwendet.