Linear Algebra

NoPivot

Le pivotement n'est pas effectué. Les factorisations de matrices telles que la factorisation LU peuvent échouer sans pivotement et peuvent également être numériquement instables pour les matrices à virgule flottante face à l'erreur d'arrondi. Cette stratégie de pivotement est principalement utile à des fins pédagogiques.

RowNonZero

Le premier élément non nul dans les lignes restantes est choisi comme élément pivot.

Attention, pour les matrices à virgule flottante, l'algorithme LU résultant est numériquement instable — cette stratégie est principalement utile pour la comparaison avec des calculs manuels (qui utilisent généralement cette stratégie) ou pour d'autres types algébriques (par exemple, les nombres rationnels) non susceptibles d'erreurs d'arrondi. Sinon, la stratégie de pivotement par défaut RowMaximum devrait généralement être préférée dans l'élimination de Gauss.

Notez que le type d'élément de la matrice doit admettre une méthode iszero.

RowMaximum

L'élément de plus grande magnitude dans les lignes restantes est choisi comme élément pivot. C'est la stratégie par défaut pour la factorisation LU des matrices à virgule flottante, et est parfois appelée l'algorithme de "pivotage partiel".

Notez que le type d'élément de la matrice doit admettre une méthode abs, dont le type de résultat doit admettre une méthode <.

ColumnNorm

La colonne avec la norme maximale est utilisée pour les calculs ultérieurs. Cela est utilisé pour la factorisation QR pivotée.

Notez que le type d'élément de la matrice doit admettre les méthodes norm et abs, dont les types de résultats respectifs doivent admettre une méthode <.

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

Multiplication de matrices.

Exemples

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

La multiplication en chaîne de 3 ou 4 matrices est effectuée dans la séquence la plus efficace, en fonction des tailles des tableaux. C'est-à-dire que le nombre de multiplications scalaires nécessaires pour (A * B) * C (avec 3 matrices denses) est comparé à celui pour A * (B * C) afin de choisir laquelle de ces opérations exécuter.

Si le dernier facteur est un vecteur, ou le premier un vecteur transposé, il est efficace de traiter ces cas en premier. En particulier, x' * B * y signifie (x' * B) * y pour une matrice ordinaire en colonne B::Matrix. Contrairement à dot(x, B, y), cela alloue un tableau intermédiaire.

Si le premier ou le dernier facteur est un nombre, cela sera fusionné avec la multiplication matricielle, en utilisant mul! à 5 arguments.

Voir aussi muladd, dot.

\(A, B)

Division de matrices utilisant un polyalgorithme. Pour les matrices d'entrée A et B, le résultat X est tel que A*X == B lorsque A est carrée. Le solveur utilisé dépend de la structure de A. Si A est triangulaire supérieure ou inférieure (ou diagonale), aucune factorisation de A n'est requise et le système est résolu par substitution avant ou arrière. Pour les matrices carrées non triangulaires, une factorisation LU est utilisée.

Pour A rectangulaire, le résultat est la solution des moindres carrés à norme minimale calculée par une factorisation QR pivotée de A et une estimation du rang de A basée sur le facteur R.

Lorsque A est sparse, un polyalgorithme similaire est utilisé. Pour les matrices indéfinies, la factorisation LDLt n'utilise pas de pivotement pendant la factorisation numérique et par conséquent, la procédure peut échouer même pour des matrices inversibles.

Voir aussi : factorize, pinv.

Exemples

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

La division à droite des matrices : A / B est équivalente à (B' \ A')' où \ est l'opérateur de division à gauche. Pour les matrices carrées, le résultat X est tel que A == X*B.

Voir aussi : rdiv!.

Exemples

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

Exception levée lorsque la matrice d'entrée a une ou plusieurs valeurs propres nulles et n'est pas inversible. Une résolution linéaire impliquant une telle matrice ne peut pas être calculée. Le champ info indique l'emplacement de (l'une des) valeurs singulières.

PosDefException

Exception levée lorsque la matrice d'entrée n'était pas définie positive. Certaines fonctions d'algèbre linéaire et factorizations ne sont applicables qu'aux matrices définies positives. Le champ info indique l'emplacement de (l'un des) valeurs propres qui est (sont) inférieure(s) ou égale(s) à 0.

ZeroPivotException <: Exception

Exception levée lorsqu'une factorisation/résolution de matrice rencontre un zéro dans une position de pivot (diagonale) et ne peut pas continuer. Cela ne signifie pas que la matrice est singulière : il peut être utile de passer à une autre factorisation telle que LU avec pivot qui peut réorganiser les variables pour éliminer les pivots nuls spuriques. Le champ info indique l'emplacement de (l'un des) pivots nuls.

RankDeficientException

Exception levée lorsque la matrice d'entrée est déficiente en rang. Certaines fonctions d'algèbre linéaire, telles que la décomposition de Cholesky, ne s'appliquent qu'aux matrices qui ne sont pas déficientes en rang. Le champ info indique le rang calculé de la matrice.

LAPACKException

Exception générique LAPACK lancée soit lors d'appels directs aux fonctions LAPACK, soit lors d'appels à d'autres fonctions qui utilisent les fonctions LAPACK en interne mais qui manquent de gestion d'erreurs spécialisée. Le champ info contient des informations supplémentaires sur l'erreur sous-jacente et dépend de la fonction LAPACK qui a été invoquée.

dot(x, y)
x ⋅ y

Calculez le produit scalaire entre deux vecteurs. Pour les vecteurs complexes, le premier vecteur est conjugué.

dot fonctionne également sur des objets itérables arbitraires, y compris des tableaux de n'importe quelle dimension, tant que dot est défini sur les éléments.

dot est sémantiquement équivalent à sum(dot(vx,vy) for (vx,vy) in zip(x, y)), avec la restriction supplémentaire que les arguments doivent avoir des longueurs égales.

x ⋅ y (où ⋅ peut être tapé en complétant par tabulation \cdot dans le REPL) est un synonyme de dot(x, y).

Exemples

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)

Calcule le produit scalaire généralisé dot(x, A*y) entre deux vecteurs x et y, sans stocker le résultat intermédiaire de A*y. Comme pour la fonction à deux arguments dot(_,_), cela agit de manière récursive. De plus, pour les vecteurs complexes, le premier vecteur est conjugué.

Exemples

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)

Calculez le produit vectoriel de deux vecteurs à 3 dimensions.

Exemples

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)

Écrase y avec x * α + y et retourne y. Si x et y ont les mêmes axes, c'est équivalent à y .+= x .* a.

Exemples

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)

Écrase y avec x * α + y * β et retourne y. Si x et y ont les mêmes axes, c'est équivalent à y .= x .* a .+ y .* β.

Exemples

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)

Écrase x avec c*x + s*y et y avec -conj(s)*x + c*y. Renvoie x et y.

reflect!(x, y, c, s)

Écrase x avec c*x + s*y et y avec conj(s)*x - c*y. Renvoie x et y.

factoriser(A)

Calcule une factorisation pratique de A, basée sur le type de la matrice d'entrée. factoriser vérifie A pour voir si elle est symétrique/triangulaire/etc. si A est passée comme une matrice générique. factoriser vérifie chaque élément de A pour vérifier/réfuter chaque propriété. Elle s'arrêtera dès qu'elle pourra exclure la symétrie/la structure triangulaire. La valeur de retour peut être réutilisée pour résoudre efficacement plusieurs systèmes. Par exemple : A=factoriser(A); x=A\b; y=A\C.

Si factoriser est appelé sur une matrice hermitienne positive définie, par exemple, alors factoriser renverra une factorisation de Cholesky.

Exemples

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> factoriser(A) # factoriser vérifiera si A est déjà factorisée
5×5 Bidiagonal{Float64, Vector{Float64}}:
 1.0  1.0   ⋅    ⋅    ⋅
  ⋅   1.0  1.0   ⋅    ⋅
  ⋅    ⋅   1.0  1.0   ⋅
  ⋅    ⋅    ⋅   1.0  1.0
  ⋅    ⋅    ⋅    ⋅   1.0

Cela renvoie un 5×5 Bidiagonal{Float64}, qui peut maintenant être passé à d'autres fonctions d'algèbre linéaire (par exemple, des solveurs d'autovalues) qui utiliseront des méthodes spécialisées pour les types Bidiagonal.

Diagonal(V::AbstractVector)

Construit une matrice paresseuse avec V comme sa diagonale.

Voir aussi UniformScaling pour la matrice identité paresseuse I, diagm pour créer une matrice dense, et diag pour extraire les éléments diagonaux.

Exemples

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

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

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

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

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

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

Diagonal(A::AbstractMatrix)

Construit une matrice à partir de la diagonale principale de A. La matrice d'entrée A peut être rectangulaire, mais la sortie sera carrée.

Exemples

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)

Construit un Diagonal{T} non initialisé de longueur n. Voir undef.

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

Construit une matrice bidiagonale supérieure (uplo=:U) ou inférieure (uplo=:L) en utilisant les vecteurs diagonaux (dv) et hors-diagonaux (ev) donnés. Le résultat est de type Bidiagonal et fournit des solveurs linéaires spécialisés efficaces, mais peut être converti en une matrice régulière avec convert(Array, _) (ou Array(_) pour faire court). La longueur de ev doit être inférieure d'un à la longueur de dv.

Exemples

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 est sur la première superdiagonale
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 ⋅  2  8  ⋅
 ⋅  ⋅  3  9
 ⋅  ⋅  ⋅  4

julia> Bl = Bidiagonal(dv, ev, :L) # ev est sur la première sous-diagonale
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 7  2  ⋅  ⋅
 ⋅  8  3  ⋅
 ⋅  ⋅  9  4

Bidiagonal(A, uplo::Symbol)

Construit une matrice Bidiagonal à partir de la diagonale principale de A et de sa première super-diagonale (si uplo=:U) ou sous-diagonale (si uplo=:L).

Exemples

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) # contient la diagonale principale et la première superdiagonale de A
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  1  ⋅  ⋅
 ⋅  2  2  ⋅
 ⋅  ⋅  3  3
 ⋅  ⋅  ⋅  4

julia> Bidiagonal(A, :L) # contient la diagonale principale et la première sous-diagonale de A
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 2  2  ⋅  ⋅
 ⋅  3  3  ⋅
 ⋅  ⋅  4  4

SymTridiagonal(dv::V, ev::V) où V <: AbstractVector

Construit une matrice tridiagonale symétrique à partir de la diagonale (dv) et de la première sous/super-diagonale (ev), respectivement. Le résultat est de type SymTridiagonal et fournit des solveurs propres spécialisés efficaces, mais peut être converti en une matrice régulière avec convert(Array, _) (ou Array(_) pour faire court).

Pour les matrices de blocs SymTridiagonal, les éléments de dv sont symétrisés. L'argument ev est interprété comme la superdiagonale. Les blocs de la sous-diagonale sont (matérialisés) transposés des blocs de la superdiagonale correspondante.

Exemples

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

julia> ev = [7, 8, 9]
3-élément 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)

Construit une matrice tridiagonale symétrique à partir de la diagonale et de la première superdiagonale de la matrice symétrique A.

Exemples

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) où V <: AbstractVector

Construit une matrice tridiagonale à partir de la première sous-diagonale, de la diagonale et de la première super-diagonale, respectivement. Le résultat est de type Tridiagonal et fournit des solveurs linéaires spécialisés efficaces, mais peut être converti en une matrice régulière avec convert(Array, _) (ou Array(_) pour faire court). Les longueurs de dl et du doivent être inférieures d'une unité à la longueur de d.

Exemples

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)

Construit une matrice tridiagonale à partir de la première sous-diagonale, de la diagonale et de la première super-diagonale de la matrice A.

Exemples

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

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

Construit une vue Symmetric du triangle supérieur (si uplo = :U) ou inférieur (si uplo = :L) de la matrice A.

Les vues Symmetric sont principalement utiles pour les matrices réelles symétriques, pour lesquelles des algorithmes spécialisés (par exemple pour les problèmes propres) sont activés pour les types Symmetric. Plus généralement, voir aussi Hermitian(A) pour les matrices hermitiennes A == A', qui est effectivement équivalent à Symmetric pour les matrices réelles mais est également utile pour les matrices complexes. (Alors que les matrices Symmetric complexes sont prises en charge mais ont peu, voire aucun, algorithme spécialisé.)

Pour calculer la partie symétrique d'une matrice réelle, ou plus généralement la partie hermitienne (A + A') / 2 d'une matrice réelle ou complexe A, utilisez hermitianpart.

Exemples

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

julia> Supper = Symmetric(A)
3×3 Symmetric{Int64, Matrix{Int64}}:
 1  2  3
 2  5  6
 3  6  9

julia> Slower = Symmetric(A, :L)
3×3 Symmetric{Int64, Matrix{Int64}}:
 1  4  7
 4  5  8
 7  8  9

julia> hermitianpart(A)
3×3 Hermitian{Float64, Matrix{Float64}}:
 1.0  3.0  5.0
 3.0  5.0  7.0
 5.0  7.0  9.0

Notez que Supper ne sera pas égal à Slower à moins que A ne soit elle-même symétrique (par exemple si A == transpose(A)).

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

Construit une vue Hermitian du triangle supérieur (si uplo = :U) ou inférieur (si uplo = :L) de la matrice A.

Pour calculer la partie hermitienne de A, utilisez hermitianpart.

Exemples

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

Notez que Hupper ne sera pas égal à Hlower à moins que A ne soit lui-même hermitien (par exemple, si A == adjoint(A)).

Toutes les parties non réelles de la diagonale seront ignorées.

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

LowerTriangular(A::AbstractMatrix)

Construit une vue LowerTriangular de la matrice A.

Exemples

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)

Construit une vue UpperTriangular de la matrice A.

Exemples

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)

Construit une vue UnitLowerTriangular de la matrice A. Une telle vue a le oneunit du eltype de A sur sa diagonale.

Exemples

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)

Construit une vue UnitUpperTriangular de la matrice A. Une telle vue a le oneunit du eltype de A sur sa diagonale.

Exemples

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)

Construit une vue UpperHessenberg de la matrice A. Les entrées de A en dessous de la première sous-diagonale sont ignorées.

Des algorithmes efficaces sont implémentés pour H \ b, det(H), et similaires.

Voir aussi la fonction hessenberg pour factoriser n'importe quelle matrice en une matrice supérieure de Hessenberg similaire.

Si F::Hessenberg est l'objet de factorisation, la matrice unitaire peut être accédée avec F.Q et la matrice de Hessenberg avec F.H. Lorsque Q est extrait, le type résultant est l'objet HessenbergQ, et peut être converti en une matrice régulière avec convert(Array, _) (ou Array(_) pour faire court).

L'itération de la décomposition produit les facteurs F.Q et F.H.

Exemples

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}

Opérateur de mise à l'échelle uniforme de taille générique défini comme un scalaire multiplié par l'opérateur d'identité, λ*I. Bien qu'il n'ait pas de size explicite, il agit de manière similaire à une matrice dans de nombreux cas et inclut le support pour certains indexages. Voir aussi I.

Exemples

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

Un objet de type UniformScaling, représentant une matrice identité de n'importe quelle taille.

Exemples

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)

Construit une matrice Diagonal à partir d'un UniformScaling.

Exemples

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

Type abstrait pour factorisations de matrices c'est-à-dire décompositions de matrices. Voir documentation en ligne pour une liste des factorisations de matrices disponibles.

LU <: Factorization

Type de factorisation matricielle de la factorisation LU d'une matrice carrée A. C'est le type de retour de lu, la fonction de factorisation matricielle correspondante.

Les composants individuels de la factorisation F::LU peuvent être accédés via getproperty:

L'itération sur la factorisation produit les composants F.L, F.U et F.p.

Exemples

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 facteur:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U facteur:
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); # déstructuration via itération

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

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

Calculez la factorisation LU d'une matrice creuse A.

Pour une matrice creuse A avec un type d'élément réel ou complexe, le type de retour de F est UmfpackLU{Tv, Ti}, avec Tv = Float64 ou ComplexF64 respectivement et Ti est un type entier (Int32 ou Int64).

Lorsque check = true, une erreur est levée si la décomposition échoue. Lorsque check = false, la responsabilité de vérifier la validité de la décomposition (via issuccess) incombe à l'utilisateur.

Le permutation q peut être soit un vecteur de permutation soit nothing. Si aucun vecteur de permutation n'est fourni ou si q est nothing, le défaut d'UMFPACK est utilisé. Si la permutation n'est pas basée sur zéro, une copie basée sur zéro est faite.

Le vecteur control par défaut correspond à la configuration par défaut du package Julia SparseArrays pour UMFPACK (NB : cela est modifié par rapport aux défauts d'UMFPACK pour désactiver le raffinement itératif), mais peut être changé en passant un vecteur de longueur UMFPACK_CONTROL, voir le manuel d'UMFPACK pour les configurations possibles. Par exemple, pour réactiver le raffinement itératif :

umfpack_control = SparseArrays.UMFPACK.get_umfpack_control(Float64, Int64) # lire la configuration par défaut de Julia pour une matrice creuse Float64
SparseArrays.UMFPACK.show_umf_ctrl(umfpack_control) # optionnel - afficher les valeurs
umfpack_control[SparseArrays.UMFPACK.JL_UMFPACK_IRSTEP] = 2.0 # réactiver le raffinement itératif (2 est le maximum par défaut d'UMFPACK)

Alu = lu(A; control = umfpack_control)
x = Alu \ b   # résoudre Ax = b, y compris le raffinement itératif d'UMFPACK

Les composants individuels de la factorisation F peuvent être accessibles par indexation :

La relation entre F et A est

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

F prend également en charge les fonctions suivantes :

• \
• det

Voir aussi lu!

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

Calculez la factorisation LU de A.

Lorsque check = true, une erreur est levée si la décomposition échoue. Lorsque check = false, la responsabilité de vérifier la validité de la décomposition (via issuccess) incombe à l'utilisateur.

Par défaut, avec check = true, une erreur est également levée lorsque la décomposition produit des facteurs valides, mais que le facteur triangulaire supérieur U est de rang déficient. Cela peut être modifié en passant allowsingular = true.

Dans la plupart des cas, si A est un sous-type S de AbstractMatrix{T} avec un type d'élément T supportant +, -, * et /, le type de retour est LU{T,S{T}}.

En général, la factorisation LU implique une permutation des lignes de la matrice (correspondant à la sortie F.p décrite ci-dessous), connue sous le nom de "pivotement" (car elle correspond à choisir quelle ligne contient le "pivot", l'entrée diagonale de F.U). L'une des stratégies de pivotement suivantes peut être sélectionnée via l'argument optionnel pivot :

• RowMaximum() (par défaut) : la stratégie de pivotement standard ; le pivot correspond à l'élément de valeur absolue maximale parmi les lignes restantes à factoriser. Cette stratégie de pivotement nécessite que le type d'élément supporte également abs et <. (C'est généralement la seule option numériquement stable pour les matrices à virgule flottante.)
• RowNonZero() : le pivot correspond au premier élément non nul parmi les lignes restantes à factoriser. (Cela correspond au choix typique dans les calculs manuels, et est également utile pour des types de nombres algébriques plus généraux qui supportent iszero mais pas abs ou <.)
• NoPivot() : pivotement désactivé (échouera si une entrée nulle est rencontrée dans une position de pivot, même lorsque allowsingular = true).

Les composants individuels de la factorisation F peuvent être accessibles via getproperty :

L'itération de la factorisation produit les composants F.L, F.U et F.p.

La relation entre F et A est

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

F prend également en charge les fonctions suivantes :

Exemples

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

julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
Facteur L :
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
Facteur U :
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); # déstructuration via itération

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}}
Facteur L :
2×2 Matrix{Float64}:
 1.0  0.0
 1.0  1.0
Facteur U (déficient en rang) :
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

Calcule la factorisation LU d'une matrice creuse A, réutilisant la factorisation symbolique d'une factorisation LU déjà existante stockée dans F. À moins que reuse_symbolic ne soit défini sur false, la matrice creuse A doit avoir un motif de non-zéros identique à la matrice utilisée pour créer la factorisation LU F, sinon une erreur est levée. Si la taille de A et F diffère, tous les vecteurs seront redimensionnés en conséquence.

Lorsque check = true, une erreur est levée si la décomposition échoue. Lorsque check = false, la responsabilité de vérifier la validité de la décomposition (via issuccess) incombe à l'utilisateur.

La permutation q peut être soit un vecteur de permutation, soit nothing. Si aucun vecteur de permutation n'est fourni ou si q est nothing, le défaut d'UMFPACK est utilisé. Si la permutation n'est pas basée sur zéro, une copie basée sur zéro est faite.

Voir aussi lu

Exemples

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! est identique à lu, mais économise de l'espace en écrasant l'entrée A, au lieu de créer une copie. Une exception InexactError est levée si la factorisation produit un nombre non représentable par le type d'élément de A, par exemple pour les types entiers.

Exemples

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

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

julia> lu!(iA)
ERREUR: InexactError: Int64(0.6666666666666666)
Trace de la pile :
[...]

Cholesky <: Factorisation

Type de factorisation matricielle de la factorisation de Cholesky d'une matrice dense symétrique/Hermite positive définie A. C'est le type de retour de cholesky, la fonction de factorisation matricielle correspondante.

Le facteur triangulaire de Cholesky peut être obtenu à partir de la factorisation F::Cholesky via F.L et F.U, où A ≈ F.U' * F.U ≈ F.L * F.L'.

Les fonctions suivantes sont disponibles pour les objets Cholesky : size, \, inv, det, logdet et isposdef.

L'itération de la décomposition produit les composants L et U.

Exemples

julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
3×3 Matrix{Float64}:
   4.0   12.0  -16.0
  12.0   37.0  -43.0
 -16.0  -43.0   98.0

julia> C = cholesky(A)
Cholesky{Float64, Matrix{Float64}}
U factor:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

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

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

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

julia> l, u = C; # destructuration via itération

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

CholeskyPivoted

Type de factorisation matricielle de la factorisation de Cholesky pivotée d'une matrice dense symétrique/Hermétique positive semi-définie A. C'est le type de retour de cholesky(_, ::RowMaximum), la fonction de factorisation matricielle correspondante.

Le facteur triangulaire de Cholesky peut être obtenu à partir de la factorisation F::CholeskyPivoted via F.L et F.U, et la permutation via F.p, où A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' avec Ur = F.U[1:F.rank, :] et Lr = F.L[:, 1:F.rank], ou alternativement A ≈ Up' * Up ≈ Lp * Lp' avec Up = F.U[1:F.rank, invperm(F.p)] et Lp = F.L[invperm(F.p), 1:F.rank].

Les fonctions suivantes sont disponibles pour les objets CholeskyPivoted : size, \, inv, det, et rank.

L'itération de la décomposition produit les composants L et U.

Exemples

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 facteur avec 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; # déstructuration via itération

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

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

Calculez la factorisation de Cholesky d'une matrice dense symétrique définie positive A et renvoyez une Cholesky factorisation. La matrice A peut être soit une Symmetric ou Hermitian AbstractMatrix ou une AbstractMatrix parfaitement symétrique ou hermitienne.

Le facteur triangulaire de Cholesky peut être obtenu à partir de la factorisation F via F.L et F.U, où A ≈ F.U' * F.U ≈ F.L * F.L'.

Les fonctions suivantes sont disponibles pour les objets Cholesky : size, \, inv, det, logdet et isposdef.

Si vous avez une matrice A qui est légèrement non hermitienne en raison d'erreurs d'arrondi dans sa construction, enveloppez-la dans Hermitian(A) avant de la passer à cholesky afin de la traiter comme parfaitement hermitienne.

Lorsque check = true, une erreur est levée si la décomposition échoue. Lorsque check = false, la responsabilité de vérifier la validité de la décomposition (via issuccess) incombe à l'utilisateur.

Exemples

julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
3×3 Matrix{Float64}:
   4.0   12.0  -16.0
  12.0   37.0  -43.0
 -16.0  -43.0   98.0

julia> C = cholesky(A)
Cholesky{Float64, Matrix{Float64}}
U factor:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

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

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

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

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

Calcule la factorisation de Cholesky pivotée d'une matrice dense symétrique semi-définit positive A et renvoie une factorisation CholeskyPivoted. La matrice A peut être soit une Symmetric soit une Hermitian AbstractMatrix ou une AbstractMatrix parfaitement symétrique ou hermitienne.

Le facteur triangulaire de Cholesky peut être obtenu à partir de la factorisation F via F.L et F.U, et la permutation via F.p, où A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' avec Ur = F.U[1:F.rank, :] et Lr = F.L[:, 1:F.rank], ou alternativement A ≈ Up' * Up ≈ Lp * Lp' avec Up = F.U[1:F.rank, invperm(F.p)] et Lp = F.L[invperm(F.p), 1:F.rank].

Les fonctions suivantes sont disponibles pour les objets CholeskyPivoted : size, \, inv, det, et rank.

L'argument tol détermine la tolérance pour déterminer le rang. Pour les valeurs négatives, la tolérance est la précision machine.

Si vous avez une matrice A qui est légèrement non hermitienne en raison d'erreurs d'arrondi dans sa construction, enveloppez-la dans Hermitian(A) avant de la passer à cholesky afin de la traiter comme parfaitement hermitienne.

Lorsque check = true, une erreur est levée si la décomposition échoue. Lorsque check = false, la responsabilité de vérifier la validité de la décomposition (via issuccess) incombe à l'utilisateur.

Exemples

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 facteur avec 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; # déstructuration via itération

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

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

Calcule la factorisation de Cholesky d'une matrice creuse définie positive A. A doit être une SparseMatrixCSC ou une vue Symmetric/Hermitian d'une SparseMatrixCSC. Notez que même si A n'a pas l'étiquette de type, elle doit toujours être symétrique ou hermitienne. Si perm n'est pas donné, une permutation réduisant le remplissage est utilisée. F = cholesky(A) est le plus souvent utilisé pour résoudre des systèmes d'équations avec F\b, mais les méthodes diag, det et logdet sont également définies pour F. Vous pouvez également extraire des facteurs individuels de F, en utilisant F.L. Cependant, comme le pivotement est activé par défaut, la factorisation est représentée en interne comme A == P'*L*L'*P avec une matrice de permutation P ; utiliser simplement L sans tenir compte de P donnera des réponses incorrectes. Pour inclure les effets de la permutation, il est généralement préférable d'extraire des facteurs "combinés" comme PtL = F.PtL (l'équivalent de P'*L) et LtP = F.UP (l'équivalent de L'*P).

Lorsque check = true, une erreur est levée si la décomposition échoue. Lorsque check = false, la responsabilité de vérifier la validité de la décomposition (via issuccess) incombe à l'utilisateur.

Définir l'argument clé optionnel shift calcule la factorisation de A+shift*I au lieu de A. Si l'argument perm est fourni, il doit être une permutation de 1:size(A,1) donnant l'ordre à utiliser (au lieu de l'ordre AMD par défaut de CHOLMOD).

Exemples

Dans l'exemple suivant, la permutation réduisant le remplissage utilisée est [3, 2, 1]. Si perm est défini sur 1:3 pour imposer aucune permutation, le nombre d'éléments non nuls dans le facteur est de 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} avec 3 entrées stockées:
  ⋅    ⋅   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

Le même que cholesky, mais économise de l'espace en écrasant l'entrée A, au lieu de créer une copie. Une exception InexactError est levée si la factorisation produit un nombre non représentable par le type d'élément de A, par exemple pour les types entiers.

Exemples

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

Le même que cholesky, mais économise de l'espace en écrasant l'entrée A, au lieu de créer une copie. Une exception InexactError est levée si la factorisation produit un nombre non représentable par le type d'élément de A, par exemple pour les types entiers.

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

Calcule la factorisation de Cholesky ($LL'$) de A, en réutilisant la factorisation symbolique F. A doit être une SparseMatrixCSC ou une vue Symmetric/ Hermitian d'une SparseMatrixCSC. Notez que même si A n'a pas l'étiquette de type, elle doit toujours être symétrique ou hermétique.

Voir aussi cholesky.

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

Met à jour une factorisation de Cholesky C avec le vecteur v. Si A = C.U'C.U alors CC = cholesky(C.U'C.U + v*v') mais le calcul de CC n'utilise que O(n^2) opérations.

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

Obtenez une factorisation LDLt de A + C*C' donnée une factorisation LDLt ou LLt F de A.

Le facteur retourné est toujours une factorisation LDLt.

Voir aussi lowrankupdate!, lowrankdowndate, lowrankdowndate!.

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

Met à jour une factorisation de Cholesky C avec le vecteur v. Si A = C.U'C.U alors CC = cholesky(C.U'C.U - v*v') mais le calcul de CC n'utilise que O(n^2) opérations.

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

Obtenez une factorisation LDLt de A + C*C' donnée une factorisation LDLt ou LLt F de A.

Le facteur retourné est toujours une factorisation LDLt.

Voir aussi lowrankdowndate!, lowrankupdate, lowrankupdate!.

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

Met à jour une factorisation de Cholesky C avec le vecteur v. Si A = C.U'C.U alors CC = cholesky(C.U'C.U + v*v') mais le calcul de CC n'utilise que O(n^2) opérations. La factorisation d'entrée C est mise à jour sur place de sorte qu'à la sortie C == CC. Le vecteur v est détruit pendant le calcul.

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

Met à jour une factorisation LDLt ou LLt F de A à une factorisation de A + C*C'.

Les factorizations LLt sont converties en LDLt.

Voir aussi lowrankupdate, lowrankdowndate, lowrankdowndate!.

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

Met à jour une factorisation de Cholesky C avec le vecteur v. Si A = C.U'C.U alors CC = cholesky(C.U'C.U - v*v') mais le calcul de CC n'utilise que O(n^2) opérations. La factorisation d'entrée C est mise à jour sur place de sorte qu'à la sortie C == CC. Le vecteur v est détruit pendant le calcul.

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

Met à jour une factorisation LDLt ou LLt F de A à une factorisation de A - C*C'.

Les factorizations LLt sont converties en LDLt.

Voir aussi lowrankdowndate, lowrankupdate, lowrankupdate!.

LDLt <: Factorisation

Type de factorisation matricielle de la factorisation LDLt d'une matrice réelle SymTridiagonal S telle que S = L*Diagonal(d)*L', où L est une matrice UnitLowerTriangular et d est un vecteur. L'utilisation principale d'une factorisation LDLt F = ldlt(S) est de résoudre le système d'équations linéaires Sx = b avec F\b. C'est le type de retour de ldlt, la fonction de factorisation matricielle correspondante.

Les composants individuels de la factorisation F::LDLt peuvent être accédés via getproperty :

Exemples

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

ldlt(S::SymTridiagonal) -> LDLt

Calcule une factorisation LDLt (c'est-à-dire, $LDL^T$) de la matrice tridiagonale symétrique réelle S telle que S = L*Diagonal(d)*L' où L est une matrice triangulaire inférieure unitaire et d est un vecteur. L'utilisation principale d'une factorisation LDLt F = ldlt(S) est de résoudre le système d'équations linéaires Sx = b avec F\b.

Voir aussi bunchkaufman pour une factorisation similaire, mais pivotée, de matrices symétriques ou hermitiennes arbitraires.

Exemples

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

Calcule la factorisation $LDL'$ d'une matrice creuse A. A doit être une SparseMatrixCSC ou une vue Symmetric/Hermitian d'une SparseMatrixCSC. Notez que même si A n'a pas l'étiquette de type, elle doit toujours être symétrique ou hermitienne. Une permutation réduisant le remplissage est utilisée. F = ldlt(A) est le plus souvent utilisé pour résoudre des systèmes d'équations A*x = b avec F\b. L'objet de factorisation retourné F prend également en charge les méthodes diag, det, logdet et inv. Vous pouvez extraire des facteurs individuels de F en utilisant F.L. Cependant, comme le pivotement est activé par défaut, la factorisation est représentée en interne comme A == P'*L*D*L'*P avec une matrice de permutation P ; utiliser simplement L sans tenir compte de P donnera des réponses incorrectes. Pour inclure les effets de la permutation, il est généralement préférable d'extraire des facteurs "combinés" comme PtL = F.PtL (l'équivalent de P'*L) et LtP = F.UP (l'équivalent de L'*P). La liste complète des facteurs pris en charge est :L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP.

Lorsque check = true, une erreur est levée si la décomposition échoue. Lorsque check = false, la responsabilité de vérifier la validité de la décomposition (via issuccess) incombe à l'utilisateur.

Le paramètre optionnel shift calcule la factorisation de A+shift*I au lieu de A. Si l'argument perm est fourni, il doit être une permutation de 1:size(A,1) donnant l'ordre à utiliser (au lieu de l'ordre AMD par défaut de CHOLMOD).

ldlt!(S::SymTridiagonal) -> LDLt

Identique à ldlt, mais économise de l'espace en écrasant l'entrée S, au lieu de créer une copie.

Exemples

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

Calcule la factorisation $LDL'$ de A, en réutilisant la factorisation symbolique F. A doit être un SparseMatrixCSC ou une vue Symmetric/Hermitian d'un SparseMatrixCSC. Notez que même si A n'a pas l'étiquette de type, elle doit toujours être symétrique ou hermitienne.

Voir aussi ldlt.

QR <: Factorization

Une factorisation matricielle QR stockée dans un format compact, généralement obtenue à partir de qr. Si $A$ est une matrice m×n, alors

\[A = Q R\]

où $Q$ est une matrice orthogonale/unitaire et $R$ est triangulaire supérieure. La matrice $Q$ est stockée sous la forme d'une séquence de réflecteurs de Householder $v_i$ et de coefficients $\tau_i$ où :

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

L'itération de la décomposition produit les composants Q et R.

L'objet a deux champs :

• factors est une matrice m×n.

  • La partie triangulaire supérieure contient les éléments de $R$, c'est-à-dire R = triu(F.factors) pour un objet QR F.
  • La partie subdiagonale contient les réflecteurs $v_i$ stockés dans un format compact où $v_i$ est la $i$-ème colonne de la matrice V = I + tril(F.factors, -1).

• τ est un vecteur de longueur min(m,n) contenant les coefficients $au_i$.

QRCompactWY <: Factorization

Une factorisation matricielle QR stockée dans un format compact bloqué, généralement obtenue à partir de qr. Si $A$ est une matrice m×n, alors

\[A = Q R\]

où $Q$ est une matrice orthogonale/unitaire et $R$ est triangulaire supérieure. C'est similaire au format QR sauf que la matrice orthogonale/unitaire $Q$ est stockée au format Compact WY ^{[Schreiber1989]}. Pour la taille de bloc $n_b$, elle est stockée sous la forme d'une matrice trapézoïdale inférieure m×n $V$ et d'une matrice $T = (T_1 \; T_2 \; ... \; T_{b-1} \; T_b')$ composée de $b = \lceil \min(m,n) / n_b \rceil$ matrices triangulaires supérieures $T_j$ de taille $n_b$×$n_b$ ($j = 1, ..., b-1$) et d'une matrice trapézoïdale supérieure $n_b$×$\min(m,n) - (b-1) n_b$ $T_b'$ ($j=b$) dont la partie carrée supérieure est notée avec $T_b$ satisfaisant

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

tel que $v_i$ est la $i$-ème colonne de $V$, $\tau_i$ est le $i$-ème élément de [diag(T_1); diag(T_2); …; diag(T_b)], et $(V_1 \; V_2 \; ... \; V_b)$ est le bloc gauche m×min(m, n) de $V$. Lorsqu'il est construit à l'aide de qr, la taille de bloc est donnée par $n_b = \min(m, n, 36)$.

L'itération de la décomposition produit les composants Q et R.

L'objet a deux champs :

• factors, comme dans le type QR, est une matrice m×n.

  • La partie triangulaire supérieure contient les éléments de $R$, c'est-à-dire R = triu(F.factors) pour un objet QR F.
  • La partie subdiagonale contient les réflecteurs $v_i$ stockés dans un format compact tel que V = I + tril(F.factors, -1).

• T est une matrice $n_b$-par-$\min(m,n)$ comme décrit ci-dessus. Les éléments subdiagonaux pour chaque matrice triangulaire $T_j$ sont ignorés.

QRPivoted <: Factorization

Une factorisation matricielle QR avec pivotement de colonnes dans un format compact, généralement obtenue à partir de qr. Si $A$ est une matrice m×n, alors

\[A P = Q R\]

où $P$ est une matrice de permutation, $Q$ est une matrice orthogonale/unitaire et $R$ est triangulaire supérieure. La matrice $Q$ est stockée sous forme d'une séquence de réflecteurs de Householder :

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

L'itération de la décomposition produit les composants Q, R et p.

L'objet a trois champs :

• factors est une matrice m×n.

  • La partie triangulaire supérieure contient les éléments de $R$, c'est-à-dire R = triu(F.factors) pour un objet QR F.
  • La partie sous-diagonale contient les réflecteurs $v_i$ stockés dans un format compact où $v_i$ est la $i$-ème colonne de la matrice V = I + tril(F.factors, -1).

• τ est un vecteur de longueur min(m,n) contenant les coefficients $au_i$.

• jpvt est un vecteur entier de longueur n correspondant à la permutation $P$.

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

Calcule la factorisation QR d'une matrice creuse A. Des permutations de lignes et de colonnes réduisant le remplissage sont utilisées de sorte que F.R = F.Q'*A[F.prow,F.pcol]. L'application principale de ce type est de résoudre des problèmes de moindres carrés ou sous-déterminés avec \. La fonction appelle la bibliothèque C SPQR^[ACM933].

Exemples

julia> A = sparse([1,2,3,4], [1,1,2,2], [1.0,1.0,1.0,1.0])
4×2 SparseMatrixCSC{Float64, Int64} avec 4 entrées stockées :
 1.0   ⋅
 1.0   ⋅
  ⋅   1.0
  ⋅   1.0

julia> qr(A)
SparseArrays.SPQR.QRSparse{Float64, Int64}
Facteur Q :
4×4 SparseArrays.SPQR.QRSparseQ{Float64, Int64}
Facteur R :
2×2 SparseMatrixCSC{Float64, Int64} avec 2 entrées stockées :
 -1.41421    ⋅
   ⋅       -1.41421
Permutation de lignes :
Vecteur de 4 éléments Int64 :
 1
 3
 4
 2
Permutation de colonnes :
Vecteur de 2 éléments Int64 :
 1
 2

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

Calcule la factorisation QR de la matrice A : une matrice orthogonale (ou unitaire si A est à valeurs complexes) Q, et une matrice triangulaire supérieure R telle que

\[A = Q R\]

L'objet retourné F stocke la factorisation dans un format compact :

• si pivot == ColumnNorm() alors F est un objet QRPivoted,
• sinon, si le type d'élément de A est un type BLAS (Float32, Float64, ComplexF32 ou ComplexF64), alors F est un objet QRCompactWY,
• sinon F est un objet QR.

Les composants individuels de la décomposition F peuvent être récupérés via des accesseurs de propriété :

• F.Q : la matrice orthogonale/unitaire Q
• F.R : la matrice triangulaire supérieure R
• F.p : le vecteur de permutation du pivot (QRPivoted uniquement)
• F.P : la matrice de permutation du pivot (QRPivoted uniquement)

L'itération de la décomposition produit les composants Q, R, et si présent p.

Les fonctions suivantes sont disponibles pour les objets QR : inv, size, et \. Lorsque A est rectangulaire, \ renverra une solution des moindres carrés et si la solution n'est pas unique, celle avec la plus petite norme est retournée. Lorsque A n'est pas de rang complet, une factorisation avec (colonne) pivot est requise pour obtenir une solution de norme minimale.

La multiplication par rapport à Q complet/carré ou non complet/carré est autorisée, c'est-à-dire que F.Q*F.R et F.Q*A sont pris en charge. Une matrice Q peut être convertie en une matrice régulière avec Matrix. Cette opération renvoie le facteur Q "mince", c'est-à-dire que si A est m×n avec m>=n, alors Matrix(F.Q) produit une matrice m×n avec des colonnes orthonormales. Pour récupérer le facteur Q "complet", une matrice orthogonale m×m, utilisez F.Q*I ou collect(F.Q). Si m<=n, alors Matrix(F.Q) produit une matrice orthogonale m×m.

La taille de bloc pour la décomposition QR peut être spécifiée par l'argument clé blocksize :: Integer lorsque pivot == NoPivot() et A isa StridedMatrix{<:BlasFloat}. Elle est ignorée lorsque blocksize > minimum(size(A)). Voir QRCompactWY.

Exemples

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

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

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

qr! est identique à qr lorsque A est un sous-type de AbstractMatrix, mais économise de l'espace en écrasant l'entrée A, au lieu de créer une copie. Une exception InexactError est levée si la factorisation produit un nombre non représentable par le type d'élément de A, par exemple pour les types entiers.

Exemples

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

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

julia> qr!(a)
ERREUR : InexactError: Int64(3.1622776601683795)
Trace de la pile :
[...]

LQ <: Factorization

Type de factorisation matricielle de la factorisation LQ d'une matrice A. La décomposition LQ est la décomposition QR de transpose(A). C'est le type de retour de lq, la fonction de factorisation matricielle correspondante.

Si S::LQ est l'objet de factorisation, le composant triangulaire inférieur peut être obtenu via S.L, et le composant orthogonal/unitaire via S.Q, tel que A ≈ S.L*S.Q.

L'itération de la décomposition produit les composants S.L et S.Q.

Exemples

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 facteur:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q facteur: 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; # déstructuration via itération

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

lq(A) -> S::LQ

Calculez la décomposition LQ de A. Le composant triangulaire inférieur de la décomposition peut être obtenu à partir de l'objet LQ S via S.L, et le composant orthogonal/unitaire via S.Q, de sorte que A ≈ S.L*S.Q.

L'itération de la décomposition produit les composants S.L et S.Q.

La décomposition LQ est la décomposition QR de transpose(A), et elle est utile pour calculer la solution à norme minimale lq(A) \ b à un système d'équations sous-déterminé (A a plus de colonnes que de lignes, mais a un rang de ligne complet).

Exemples

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 facteur :
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q facteur : 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; # déstructuration via itération

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

lq!(A) -> LQ

Calculez la factorisation LQ de A, en utilisant la matrice d'entrée comme espace de travail. Voir aussi lq.

BunchKaufman <: Factorization

Type de factorisation matricielle de la factorisation de Bunch-Kaufman d'une matrice symétrique ou hermitienne A sous la forme P'UDU'P ou P'LDL'P, selon que le triangle supérieur (par défaut) ou le triangle inférieur est stocké dans A. Si A est symétrique complexe, alors U' et L' désignent les transposées non conjuguées, c'est-à-dire transpose(U) et transpose(L), respectivement. C'est le type de retour de bunchkaufman, la fonction de factorisation matricielle correspondante.

Si S::BunchKaufman est l'objet de factorisation, les composants peuvent être obtenus via S.D, S.U ou S.L selon ce qui est approprié étant donné S.uplo, et S.p.

L'itération de la décomposition produit les composants S.D, S.U ou S.L selon ce qui est approprié étant donné S.uplo, et S.p.

Exemples

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

julia> S = bunchkaufman(A) # A est enveloppé en interne par Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D facteur:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U facteur:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
permutation:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # déstructuration via itération

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

julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D facteur:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L facteur:
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

Calculez la factorisation de Bunch-Kaufman ^[Bunch1977] d'une matrice symétrique ou hermitienne A sous la forme P'*U*D*U'*P ou P'*L*D*L'*P, selon le triangle qui est stocké dans A, et renvoyez un objet BunchKaufman. Notez que si A est symétrique complexe, alors U' et L' désignent les transposées non conjuguées, c'est-à-dire transpose(U) et transpose(L).

L'itération de la décomposition produit les composants S.D, S.U ou S.L selon ce qui est approprié étant donné S.uplo, et S.p.

Si rook est true, un pivotement de rook est utilisé. Si rook est faux, le pivotement de rook n'est pas utilisé.

Lorsque check = true, une erreur est levée si la décomposition échoue. Lorsque check = false, la responsabilité de vérifier la validité de la décomposition (via issuccess) incombe à l'utilisateur.

Les fonctions suivantes sont disponibles pour les objets BunchKaufman : size, \, inv, issymmetric, ishermitian, getindex.

Exemples

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

julia> S = bunchkaufman(A) # A est enveloppé en interne par Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
Facteur D :
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
Facteur U :
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
permutation :
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # déstructuration via itération

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}}
Facteur D :
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
Facteur L :
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! est identique à bunchkaufman, mais économise de l'espace en écrasant l'entrée A, au lieu de créer une copie.

Eigen <: Factorization

Type de factorisation de matrice de la décomposition en valeurs propres/spectrales d'une matrice carrée A. C'est le type de retour de eigen, la fonction de factorisation de matrice correspondante.

Si F::Eigen est l'objet de factorisation, les valeurs propres peuvent être obtenues via F.values et les vecteurs propres comme les colonnes de la matrice F.vectors. (Le k-ième vecteur propre peut être obtenu à partir de la tranche F.vectors[:, k].)

L'itération de la décomposition produit les composants F.values et F.vectors.

Exemples

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

Type de factorisation matricielle de la décomposition généralisée des valeurs propres/spectrales de A et B. C'est le type de retour de eigen, la fonction de factorisation matricielle correspondante, lorsqu'elle est appelée avec deux arguments matriciels.

Si F::GeneralizedEigen est l'objet de factorisation, les valeurs propres peuvent être obtenues via F.values et les vecteurs propres comme les colonnes de la matrice F.vectors. (Le k-ième vecteur propre peut être obtenu à partir de la tranche F.vectors[:, k].)

L'itération de la décomposition produit les composants F.values et F.vectors.

Exemples

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

Retourne les valeurs propres de A.

Pour les matrices non symétriques générales, il est possible de spécifier comment la matrice est équilibrée avant le calcul des valeurs propres. Les mots-clés permute, scale et sortby sont les mêmes que pour eigen.

Exemples

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

Pour une entrée scalaire, eigvals renverra un scalaire.

Exemples

julia> eigvals(-2)
-2

eigvals(A, B) -> valeurs

Calculez les valeurs propres généralisées de A et B.

Exemples

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

Retourne les valeurs propres de A. Il est possible de calculer seulement un sous-ensemble des valeurs propres en spécifiant une UnitRange irange couvrant les indices des valeurs propres triées, par exemple, les 2ème à 8ème valeurs propres.

Exemples

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

Retourne les valeurs propres de A. Il est possible de calculer seulement un sous-ensemble des valeurs propres en spécifiant une paire vl et vu pour les limites inférieure et supérieure des valeurs propres.

Exemples

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

Identique à eigvals, mais économise de l'espace en écrasant l'entrée A, au lieu de créer une copie. Les mots-clés permute, scale et sortby sont les mêmes que pour eigen.

Exemples

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

Identique à eigvals, mais économise de l'espace en écrasant l'entrée A (et B), au lieu de créer des copies.

Exemples

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

Identique à eigvals, mais économise de l'espace en écrasant l'entrée A, au lieu de créer une copie. irange est une plage d'indices de valeurs propres à rechercher - par exemple, les 2ème à 8ème valeurs propres.

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

Identique à eigvals, mais économise de l'espace en écrasant l'entrée A, au lieu de créer une copie. vl est la borne inférieure de l'intervalle à rechercher pour les valeurs propres, et vu est la borne supérieure.

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

Retourne la plus grande valeur propre de A. L'option permute=true permute la matrice pour se rapprocher d'une forme triangulaire supérieure, et scale=true met à l'échelle la matrice par ses éléments diagonaux pour rendre les lignes et les colonnes plus égales en norme. Notez que si les valeurs propres de A sont complexes, cette méthode échouera, car les nombres complexes ne peuvent pas être triés.

Exemples

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` ne peut pas avoir de valeurs propres complexes.
Stacktrace:
[...]

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

Retourne la plus petite valeur propre de A. L'option permute=true permute la matrice pour se rapprocher d'une forme triangulaire supérieure, et scale=true met à l'échelle la matrice par ses éléments diagonaux pour rendre les lignes et les colonnes plus égales en norme. Notez que si les valeurs propres de A sont complexes, cette méthode échouera, car les nombres complexes ne peuvent pas être triés.

Exemples

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` ne peut pas avoir de valeurs propres complexes.
Stacktrace:
[...]

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

Renvoie une matrice M dont les colonnes sont les vecteurs propres de A. (Le k-ème vecteur propre peut être obtenu à partir de la tranche M[:, k].)

Si le vecteur optionnel de valeurs propres eigvals est spécifié, eigvecs renvoie les vecteurs propres correspondants spécifiques.

Exemples

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

Renvoie une matrice M dont les colonnes sont les vecteurs propres de A. (Le k-ème vecteur propre peut être obtenu à partir de la tranche M[:, k].) Les mots-clés permute, scale et sortby sont les mêmes que pour eigen.

Exemples

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

Retourne une matrice M dont les colonnes sont les vecteurs propres généralisés de A et B. (Le k-ème vecteur propre peut être obtenu à partir de la tranche M[:, k].)

Exemples

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

Calcule la décomposition en valeurs propres de A, retournant un objet de factorisation Eigen F qui contient les valeurs propres dans F.values et les vecteurs propres dans les colonnes de la matrice F.vectors. Cela correspond à la résolution d'un problème de valeurs propres de la forme Ax = λx, où A est une matrice, x est un vecteur propre, et λ est une valeur propre. (Le k-ième vecteur propre peut être obtenu à partir de la tranche F.vectors[:, k].)

L'itération de la décomposition produit les composants F.values et F.vectors.

Les fonctions suivantes sont disponibles pour les objets Eigen : inv, det, et isposdef.

Pour les matrices générales non symétriques, il est possible de spécifier comment la matrice est équilibrée avant le calcul des vecteurs propres. L'option permute=true permute la matrice pour la rapprocher d'une forme triangulaire supérieure, et scale=true met à l'échelle la matrice par ses éléments diagonaux pour rendre les lignes et les colonnes plus égales en norme. La valeur par défaut est true pour les deux options.

Par défaut, les valeurs et vecteurs propres sont triés lexicographiquement par (real(λ),imag(λ)). Une fonction de comparaison différente by(λ) peut être passée à sortby, ou vous pouvez passer sortby=nothing pour laisser les valeurs propres dans un ordre arbitraire. Certains types de matrices spéciaux (par exemple Diagonal ou SymTridiagonal) peuvent implémenter leur propre convention de tri et ne pas accepter un mot-clé sortby.

Exemples

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; # destructuration via itération

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

eigen(A, B; sortby) -> GeneralizedEigen

Calcule la décomposition des valeurs propres généralisées de A et B, retournant un objet de factorisation GeneralizedEigen F qui contient les valeurs propres généralisées dans F.values et les vecteurs propres généralisés dans les colonnes de la matrice F.vectors. Cela correspond à la résolution d'un problème de valeurs propres généralisées de la forme Ax = λBx, où A, B sont des matrices, x est un vecteur propre, et λ est une valeur propre. (Le k-ième vecteur propre généralisé peut être obtenu à partir de la tranche F.vectors[:, k].)

L'itération de la décomposition produit les composants F.values et F.vectors.

Par défaut, les valeurs propres et les vecteurs sont triés lexicographiquement par (real(λ),imag(λ)). Une fonction de comparaison différente by(λ) peut être passée à sortby, ou vous pouvez passer sortby=nothing pour laisser les valeurs propres dans un ordre arbitraire.

Exemples

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

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

julia> F = eigen(A, B);

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

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

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

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

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

Calcule la décomposition en valeurs propres de A, retournant un objet de factorisation Eigen F qui contient les valeurs propres dans F.values et les vecteurs propres dans les colonnes de la matrice F.vectors. (Le k-ème vecteur propre peut être obtenu à partir de la tranche F.vectors[:, k].)

L'itération de la décomposition produit les composants F.values et F.vectors.

Les fonctions suivantes sont disponibles pour les objets Eigen : inv, det, et isposdef.

La UnitRange irange spécifie les indices des valeurs propres triées à rechercher.

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

Calcule la décomposition en valeurs propres de A, retournant un objet de factorisation Eigen F qui contient les valeurs propres dans F.values et les vecteurs propres dans les colonnes de la matrice F.vectors. (Le k-ième vecteur propre peut être obtenu à partir de la tranche F.vectors[:, k].)

L'itération de la décomposition produit les composants F.values et F.vectors.

Les fonctions suivantes sont disponibles pour les objets Eigen : inv, det, et isposdef.

vl est la borne inférieure de la fenêtre des valeurs propres à rechercher, et vu est la borne supérieure.

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

Identique à eigen, mais économise de l'espace en écrasant l'entrée A (et B), au lieu de créer une copie.

Hessenberg <: Factorisation

Un objet Hessenberg représente la factorisation de Hessenberg QHQ' d'une matrice carrée, ou un décalage Q(H+μI)Q' de celle-ci, qui est produit par la fonction hessenberg.

hessenberg(A) -> Hessenberg

Calculez la décomposition de Hessenberg de A et renvoyez un objet Hessenberg. Si F est l'objet de factorisation, la matrice unitaire peut être accédée avec F.Q (de type LinearAlgebra.HessenbergQ) et la matrice de Hessenberg avec F.H (de type UpperHessenberg), l'une ou l'autre pouvant être convertie en une matrice régulière avec Matrix(F.H) ou Matrix(F.Q).

Si A est Hermitienne ou Symétrique réelle, alors la décomposition de Hessenberg produit une matrice tridiagonale réelle-symétrique et F.H est de type SymTridiagonal.

Notez que la factorisation décalée A+μI = Q (H+μI) Q' peut être construite efficacement par F + μ*I en utilisant l'objet UniformScaling I, qui crée un nouvel objet Hessenberg avec un stockage partagé et un décalage modifié. Le décalage d'un F donné est obtenu par F.μ. Cela est utile car plusieurs résolutions décalées (F + μ*I) \ b (pour différents μ et/ou b) peuvent être effectuées efficacement une fois que F est créé.

L'itération de la décomposition produit les facteurs F.Q, F.H, F.μ.

Exemples

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 facteur : 3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}
H facteur :
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; # déstructuration via itération

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

hessenberg!(A) -> Hessenberg

hessenberg! est identique à hessenberg, mais économise de l'espace en écrasant l'entrée A, au lieu de créer une copie.

Schur <: Factorization

Type de factorisation matricielle de la factorisation de Schur d'une matrice A. C'est le type de retour de schur(_), la fonction de factorisation matricielle correspondante.

Si F::Schur est l'objet de factorisation, le facteur de Schur (quasi) triangulaire peut être obtenu via F.Schur ou F.T et les vecteurs de Schur orthogonaux/unitaires via F.vectors ou F.Z de sorte que A = F.vectors * F.Schur * F.vectors'. Les valeurs propres de A peuvent être obtenues avec F.values.

L'itération de la décomposition produit les composants F.T, F.Z et F.values.

Exemples

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

julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
eigenvalues:
2-element Vector{Float64}:
  3.0
 -2.0

julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> t, z, vals = F; # destructuring via iteration

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

GeneralizedSchur <: Factorization

Type de factorisation matricielle de la factorisation de Schur généralisée de deux matrices A et B. C'est le type de retour de schur(_, _), la fonction de factorisation matricielle correspondante.

Si F::GeneralizedSchur est l'objet de factorisation, les facteurs de Schur (quasi) triangulaires peuvent être obtenus via F.S et F.T, les vecteurs de Schur unitaires/orthogonaux à gauche via F.left ou F.Q, et les vecteurs de Schur unitaires/orthogonaux à droite peuvent être obtenus avec F.right ou F.Z de sorte que A=F.left*F.S*F.right' et B=F.left*F.T*F.right'. Les valeurs propres généralisées de A et B peuvent être obtenues avec F.α./F.β.

L'itération de la décomposition produit les composants F.S, F.T, F.Q, F.Z, F.α, et F.β.

schur(A) -> F::Schur

Calcule la factorisation de Schur de la matrice A. Le facteur de Schur (quasi) triangulaire peut être obtenu à partir de l'objet Schur F avec soit F.Schur soit F.T et les vecteurs de Schur orthogonaux/unitaires peuvent être obtenus avec F.vectors ou F.Z de sorte que A = F.vectors * F.Schur * F.vectors'. Les valeurs propres de A peuvent être obtenues avec F.values.

Pour un A réel, la factorisation de Schur est "quasitriangulaire", ce qui signifie qu'elle est supérieurement triangulaire sauf avec des blocs diagonaux de 2×2 pour toute paire conjuguée de valeurs propres complexes ; cela permet à la factorisation d'être purement réelle même lorsqu'il y a des valeurs propres complexes. Pour obtenir la factorisation de Schur (complexe) purement supérieurement triangulaire à partir d'une factorisation quasitriangulaire réelle, vous pouvez utiliser Schur{Complex}(schur(A)).

L'itération de la décomposition produit les composants F.T, F.Z et F.values.

Exemples

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

julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
valeurs propres:
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; # déstructuration via itération

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

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

Calcule la factorisation de Schur généralisée (ou QZ) des matrices A et B. Les facteurs de Schur (quasi) triangulaires peuvent être obtenus à partir de l'objet Schur F avec F.S et F.T, les vecteurs de Schur unitaires/orthogonaux à gauche peuvent être obtenus avec F.left ou F.Q et les vecteurs de Schur unitaires/orthogonaux à droite peuvent être obtenus avec F.right ou F.Z de sorte que A=F.left*F.S*F.right' et B=F.left*F.T*F.right'. Les valeurs propres généralisées de A et B peuvent être obtenues avec F.α./F.β.

L'itération de la décomposition produit les composants F.S, F.T, F.Q, F.Z, F.α et F.β.

schur!(A) -> F::Schur

Identique à schur mais utilise l'argument d'entrée A comme espace de travail.

Exemples

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

Identique à schur mais utilise les matrices d'entrée A et B comme espace de travail.

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

Réorganise la factorisation de Schur F d'une matrice A = Z*T*Z' selon le tableau logique select, retournant l'objet de factorisation réordonné F. Les valeurs propres sélectionnées apparaissent dans la diagonale principale de F.Schur et les colonnes principales correspondantes de F.vectors forment une base orthogonale/unitaire du sous-espace invariant à droite correspondant. Dans le cas réel, une paire de valeurs propres conjuguées complexes doit être soit entièrement incluse, soit entièrement exclue via select.

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

Réorganise la factorisation de Schur généralisée F d'une paire de matrices (A, B) = (Q*S*Z', Q*T*Z') selon le tableau logique select et renvoie un objet GeneralizedSchur F. Les valeurs propres sélectionnées apparaissent dans la diagonale principale de F.S et F.T, et les vecteurs de Schur orthogonaux/unitaires à gauche et à droite sont également réorganisés de sorte que (A, B) = F.Q*(F.S, F.T)*F.Z' reste valide et que les valeurs propres généralisées de A et B puissent toujours être obtenues avec F.α./F.β.

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

Identique à ordschur mais écrase la factorisation F.

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

Identique à ordschur mais écrase la factorisation F.

SVD <: Factorization

Type de factorisation matricielle de la décomposition en valeurs singulières (SVD) d'une matrice A. C'est le type de retour de svd(_), la fonction de factorisation matricielle correspondante.

Si F::SVD est l'objet de factorisation, U, S, V et Vt peuvent être obtenus via F.U, F.S, F.V et F.Vt, de sorte que A = U * Diagonal(S) * Vt. Les valeurs singulières dans S sont triées par ordre décroissant.

L'itération de la décomposition produit les composants U, S et V.

Exemples

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

julia> F = svd(A)
SVD{Float64, Float64, Matrix{Float64}, Vector{Float64}}
U factor:
4×4 Matrix{Float64}:
 0.0  1.0   0.0  0.0
 1.0  0.0   0.0  0.0
 0.0  0.0   0.0  1.0
 0.0  0.0  -1.0  0.0
valeurs singulières:
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0
Vt factor:
4×5 Matrix{Float64}:
 -0.0        0.0  1.0  -0.0  0.0
  0.447214   0.0  0.0   0.0  0.894427
  0.0       -1.0  0.0   0.0  0.0
  0.0        0.0  0.0   1.0  0.0

julia> F.U * Diagonal(F.S) * F.Vt
4×5 Matrix{Float64}:
 1.0  0.0  0.0  0.0  2.0
 0.0  0.0  3.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  2.0  0.0  0.0  0.0

julia> u, s, v = F; # déstructuration via itération

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

GeneralizedSVD <: Factorization

Type de factorisation matricielle de la décomposition en valeurs singulières généralisée (SVD) de deux matrices A et B, telle que A = F.U*F.D1*F.R0*F.Q' et B = F.V*F.D2*F.R0*F.Q'. C'est le type de retour de svd(_, _), la fonction de factorisation matricielle correspondante.

Pour une matrice M-par-N A et une matrice P-par-N B,

• U est une matrice orthogonale M-par-M,
• V est une matrice orthogonale P-par-P,
• Q est une matrice orthogonale N-par-N,
• D1 est une matrice diagonale M-par-(K+L) avec des 1 dans les K premières entrées,
• D2 est une matrice P-par-(K+L) dont le bloc supérieur droit L-par-L est diagonal,
• R0 est une matrice (K+L)-par-N dont le bloc supérieur droit (K+L)-par-(K+L) est non singulier et triangulaire supérieur,

K+L est le rang numérique effectif de la matrice [A; B].

L'itération de la décomposition produit les composants U, V, Q, D1, D2, et R0.

Les entrées de F.D1 et F.D2 sont liées, comme expliqué dans la documentation LAPACK pour le SVD généralisé et la routine xGGSVD3 qui est appelée en dessous (dans LAPACK 3.6.0 et versions ultérieures).

Exemples

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

Calcule la décomposition en valeurs singulières (SVD) de A et renvoie un objet SVD.

U, S, V et Vt peuvent être obtenus à partir de la factorisation F avec F.U, F.S, F.V et F.Vt, de sorte que A = U * Diagonal(S) * Vt. L'algorithme produit Vt et donc Vt est plus efficace à extraire que V. Les valeurs singulières dans S sont triées par ordre décroissant.

L'itération de la décomposition produit les composants U, S et V.

Si full = false (par défaut), une SVD "mince" est renvoyée. Pour une matrice A de taille $M \times N$, dans la factorisation complète U est de taille $M \times M$ et V est de taille $N \times N$, tandis que dans la factorisation mince U est de taille $M \times K$ et V est de taille $N \times K$, où $K = \min(M,N)$ est le nombre de valeurs singulières.

Si alg = DivideAndConquer(), un algorithme de diviser pour régner est utilisé pour calculer la SVD. Une autre option (typiquement plus lente mais plus précise) est alg = QRIteration().

Exemples

julia> A = rand(4,3);

julia> F = svd(A); # Stocker l'objet de factorisation

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

julia> U, S, V = F; # déstructuration via itération

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

julia> Uonly, = svd(A); # Stocker uniquement U

julia> Uonly == U
true

svd(A, B) -> GeneralizedSVD

Calculez le SVD généralisé de A et B, retournant un objet de factorisation GeneralizedSVD F tel que [A;B] = [F.U * F.D1; F.V * F.D2] * F.R0 * F.Q'

• U est une matrice orthogonale de M par M,
• V est une matrice orthogonale de P par P,
• Q est une matrice orthogonale de N par N,
• D1 est une matrice diagonale de M par (K+L) avec des 1 dans les K premières entrées,
• D2 est une matrice de P par (K+L) dont le bloc supérieur droit de L par L est diagonal,
• R0 est une matrice de (K+L) par N dont le bloc supérieur droit de (K+L) par (K+L) est non singulier et triangulaire supérieur,

K+L est le rang numérique effectif de la matrice [A; B].

L'itération de la décomposition produit les composants U, V, Q, D1, D2, et R0.

Le SVD généralisé est utilisé dans des applications telles que lorsque l'on veut comparer combien appartient à A par rapport à combien appartient à B, comme dans le génome humain contre le génome de la levure, ou le signal contre le bruit, ou entre les clusters contre à l'intérieur des clusters. (Voir Edelman et Wang pour discussion : https://arxiv.org/abs/1901.00485)

Il décompose [A; B] en [UC; VS]H, où [UC; VS] est une base orthogonale naturelle pour l'espace des colonnes de [A; B], et H = RQ' est une base non orthogonale naturelle pour l'espace des lignes de [A;B], où les lignes supérieures sont le plus étroitement attribuées à la matrice A, et les lignes inférieures à la matrice B. Les matrices multi-cosinus/sinus C et S fournissent une mesure multiple de combien A contre combien B, et U et V fournissent des directions dans lesquelles ces mesures sont effectuées.

Exemples

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! est identique à svd, mais économise de l'espace en écrasant l'entrée A, au lieu de créer une copie. Voir la documentation de svd pour plus de détails.

svd!(A, B) -> GeneralizedSVD

svd! est identique à svd, mais modifie les arguments A et B sur place, au lieu de faire des copies. Voir la documentation de svd pour plus de détails.

svdvals(A)

Retourne les valeurs singulières de A dans l'ordre décroissant.

Exemples

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)

Retourne les valeurs singulières généralisées de la décomposition en valeurs singulières généralisées de A et B. Voir aussi svd.

Exemples

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)

Retourne les valeurs singulières de A, économisant de l'espace en écrasant l'entrée. Voir aussi svdvals et svd.

svdvals!(A, B)

Retourne les valeurs singulières généralisées de la décomposition en valeurs singulières généralisées de A et B, en économisant de l'espace en écrasant A et B. Voir aussi svd et svdvals.

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

Un opérateur linéaire de rotation de Givens. Les champs c et s représentent le cosinus et le sinus de l'angle de rotation, respectivement. Le type Givens prend en charge la multiplication à gauche G*A et la multiplication par la transposée conjuguée à droite A*G'. Le type n'a pas de size et peut donc être multiplié avec des matrices de taille arbitraire tant que i2<=size(A,2) pour G*A ou i2<=size(A,1) pour A*G'.

Voir aussi givens.

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

Calcule la rotation de Givens G et le scalaire r tels que pour tout vecteur x où

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

le résultat de la multiplication

y = G*x

a la propriété que

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

Voir aussi LinearAlgebra.Givens.

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

Calcule la rotation de Givens G et le scalaire r tels que le résultat de la multiplication

B = G*A

a la propriété que

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

Voir aussi LinearAlgebra.Givens. ```

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

Calcule la rotation de Givens G et le scalaire r de sorte que le résultat de la multiplication

B = G*x

ait la propriété que

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

Voir aussi LinearAlgebra.Givens. ```

triu(M)

Triangle supérieur d'une matrice.

Exemples

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)

Renvoie le triangle supérieur de M à partir de la k-ième superdiagonale.

Exemples

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)

Triangle supérieure d'une matrice, en écrasant M dans le processus. Voir aussi triu.

triu!(M, k::Integer)

Renvoie le triangle supérieur de M à partir de la k-ième superdiagonale, en écrasant M dans le processus.

Exemples

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)

Triangle inférieur d'une matrice.

Exemples

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)

Retourne le triangle inférieur de M à partir de la k-ième superdiagonale.

Exemples

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)

Triangle inférieure d'une matrice, en écrasant M dans le processus. Voir aussi tril.

tril!(M, k::Integer)

Renvoie le triangle inférieur de M à partir de la k-ième superdiagonale, en écrasant M dans le processus.

Exemples

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

Un AbstractRange donnant les indices de la k-ième diagonale de la matrice M. En option, un style d'index peut être spécifié, ce qui détermine le type de la plage retournée. Si indstyle isa IndexLinear (par défaut), cela retourne un AbstractRange{Integer}. D'autre part, si indstyle isa IndexCartesian, cela retourne un AbstractRange{CartesianIndex{2}}.

Si k n'est pas fourni, il est supposé être 0 (correspondant à la diagonale principale).

Voir aussi : diag, diagm, Diagonal.

Exemples

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)

La k-ième diagonale d'une matrice, sous forme de vecteur.

Voir aussi diagm, diagind, Diagonal, isdiag.

Exemples

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

Construit une matrice à partir de `Pair`s de diagonales et de vecteurs. Le vecteur `kv.second` sera placé sur la diagonale `kv.first`. Par défaut, la matrice est carrée et sa taille est déduite de `kv`, mais une taille non carrée `m`×`n` (remplie de zéros si nécessaire) peut être spécifiée en passant `m,n` comme premiers arguments. Pour les indices de diagonale répétés `kv.first`, les valeurs des vecteurs correspondants `kv.second` seront additionnées.

`diagm` construit une matrice complète ; si vous souhaitez des versions économes en stockage avec une arithmétique rapide, consultez [`Diagonal`](@ref), [`Bidiagonal`](@ref), [`Tridiagonal`](@ref) et [`SymTridiagonal`](@ref).

# Exemples

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)

Construit une matrice avec les éléments du vecteur comme éléments diagonaux. Par défaut, la matrice est carrée et sa taille est donnée par length(v), mais une taille non carrée m×n peut être spécifiée en passant m,n comme premiers arguments.

Exemples

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

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

Retourne le rang de la factorisation QR

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

Calcule le rang de S en calculant sa factorisation QR. Les valeurs inférieures à tol sont considérées comme nulles. Voir le manuel de SPQR.

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

Calculez le rang numérique d'une matrice en comptant combien de valeurs de sortie de svdvals(A) sont supérieures à max(atol, rtol*σ₁) où σ₁ est la plus grande valeur singulière calculée de A. atol et rtol sont respectivement les tolérances absolue et relative. La tolérance relative par défaut est n*ϵ, où n est la taille de la plus petite dimension de A, et ϵ est le eps du type d'élément de A.

Exemples

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)

Pour tout conteneur itérable A (y compris les tableaux de n'importe quelle dimension) de nombres (ou tout type d'élément pour lequel norm est défini), calculez la p-norme (par défaut p=2) comme si A était un vecteur de la longueur correspondante.

La p-norme est définie comme

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

avec $a_i$ les entrées de A, $| a_i |$ la norm de $a_i$, et $n$ la longueur de A. Puisque la p-norme est calculée en utilisant les norms des entrées de A, la p-norme d'un vecteur de vecteurs n'est pas compatible avec l'interprétation de celui-ci comme un vecteur bloc en général si p != 2.

p peut prendre n'importe quelle valeur numérique (bien que toutes les valeurs ne produisent pas une norme vectorielle mathématiquement valide). En particulier, norm(A, Inf) renvoie la plus grande valeur dans abs.(A), tandis que norm(A, -Inf) renvoie la plus petite. Si A est une matrice et p=2, alors cela équivaut à la norme de Frobenius.

Le deuxième argument p n'est pas nécessairement une partie de l'interface pour norm, c'est-à-dire qu'un type personnalisé peut n'implémenter que norm(A) sans deuxième argument.

Utilisez opnorm pour calculer la norme opérateur d'une matrice.

Exemples

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)

Pour les nombres, retourner $\left( |x|^p \right)^{1/p}$.

Exemples

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)

Calculez la norme opérateur (ou norme de matrice) induite par la norme vectorielle p, où les valeurs valides de p sont 1, 2 ou Inf. (Notez que pour les matrices creuses, p=2 n'est actuellement pas implémenté.) Utilisez norm pour calculer la norme de Frobenius.

Lorsque p=1, la norme opérateur est la somme maximale des valeurs absolues des colonnes de A :

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

avec $a_{ij}$ les éléments de $A$, et $m$ et $n$ ses dimensions.

Lorsque p=2, la norme opérateur est la norme spectrale, égale à la plus grande valeur singulière de A.

Lorsque p=Inf, la norme opérateur est la somme maximale des valeurs absolues des lignes de A :

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

Exemples

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)

Pour les nombres, renvoyez $\left( |x|^p \right)^{1/p}$. Cela équivaut à norm.

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

Pour les vecteurs enveloppés dans Adjoint/Transpose, renvoie la norme opérateur $q$-norm de A, qui est équivalente à la p-norm avec la valeur p = q/(q-1). Elles coïncident à p = q = 2. Utilisez norm pour calculer la norme p de A en tant que vecteur.

La différence de norme entre un espace vectoriel et son dual apparaît pour préserver la relation entre la dualité et le produit scalaire, et le résultat est cohérent avec la norme opérateur p d'une matrice 1 × n.

Exemples

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)

Normalisez le tableau a sur place de sorte que sa norme p soit égale à l'unité, c'est-à-dire norm(a, p) == 1. Voir aussi normalize et norm.

normalize(a, p::Real=2)

Normaliser a de sorte que sa p-norme soit égale à l'unité, c'est-à-dire norm(a, p) == 1. Pour les scalaires, cela est similaire à sign(a), sauf que normalize(0) = NaN. Voir aussi normalize!, norm, et sign.

Exemples

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::Réel=2)

Nombre de condition de la matrice M, calculé en utilisant la norme opérateur p. Les valeurs valides pour p sont 1, 2 (par défaut) ou 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}\]

Le nombre de condition de Skeel $\kappa_S$ de la matrice M, éventuellement par rapport au vecteur x, est calculé en utilisant la norme opérateur p. $\left\vert M \right\vert$ désigne la matrice des valeurs absolues (élément par élément) de $M$; $\left\vert M \right\vert_{ij} = \left\vert M_{ij} \right\vert$. Les valeurs valides pour p sont 1, 2 et Inf (par défaut).

Cette quantité est également connue dans la littérature sous le nom de nombre de condition de Bauer, nombre de condition relatif, ou nombre de condition relatif élément par élément.

tr(M)

Trace de la matrice. Somme des éléments diagonaux de M.

Exemples

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

julia> tr(A)
5

det(M)

Déterminant de matrice.

Voir aussi : logdet et logabsdet.

Exemples

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

julia> det(M)
2.0

logdet(M)

Logarithme du déterminant de matrice. Équivalent à log(det(M)), mais peut offrir une précision accrue et évite le débordement/sous-dépassement.

Exemples

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)

Logarithme de la valeur absolue du déterminant de la matrice. Équivalent à (log(abs(det(M))), sign(det(M))), mais peut offrir une précision et/ou une vitesse accrues.

Exemples

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)

Inverse de matrice. Calcule la matrice N telle que M * N = I, où I est la matrice identité. Calculé en résolvant la division à gauche N = M \ I.

Exemples

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) # à déprécier dans Julia 2.0

Calcule la pseudo-inverse de Moore-Penrose.

Pour les matrices M avec des éléments à virgule flottante, il est pratique de calculer la pseudo-inverse en inversant uniquement les valeurs singulières supérieures à max(atol, rtol*σ₁) où σ₁ est la plus grande valeur singulière de M.

Le choix optimal de la tolérance absolue (atol) et de la tolérance relative (rtol) varie à la fois avec la valeur de M et l'application prévue de la pseudo-inverse. La tolérance relative par défaut est n*ϵ, où n est la taille de la plus petite dimension de M, et ϵ est le eps du type d'élément de M.

Pour inverser des matrices denses mal conditionnées dans un sens des moindres carrés, rtol = sqrt(eps(real(float(oneunit(eltype(M)))))) est recommandé.

Pour plus d'informations, voir ^[issue8859], ^[B96], ^[S84], ^[KY88].

Exemples

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) # à déprécier dans Julia 2.0

Calcule une base pour le noyau de `M` en incluant les vecteurs singuliers de `M` dont les valeurs singulières ont des magnitudes inférieures à `max(atol, rtol*σ₁)`, où `σ₁` est la plus grande valeur singulière de `M`.

Par défaut, la tolérance relative `rtol` est `n*ϵ`, où `n` est la taille de la plus petite dimension de `M`, et `ϵ` est le [`eps`](@ref) du type d'élément de `M`.

# Exemples

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)

Calcule le produit de Kronecker de deux vecteurs, matrices ou nombres.

Pour les vecteurs réels v et w, le produit de Kronecker est lié au produit extérieur par kron(v,w) == vec(w * transpose(v)) ou w * transpose(v) == reshape(kron(v,w), (length(w), length(v))). Notez comment l'ordre de v et w diffère à gauche et à droite de ces expressions (en raison du stockage en colonne). Pour les vecteurs complexes, le produit extérieur w * v' diffère également par la conjugaison de v.

Exemples

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)

Calcule le produit de Kronecker de A et B et stocke le résultat dans C, écrasant le contenu existant de C. C'est la version en place de kron.

exp(A::AbstractMatrix)

Calcule l'exponentielle matricielle de A, définie par

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

Pour A symétrique ou hermitien, une décomposition en valeurs propres (eigen) est utilisée, sinon l'algorithme de mise à l'échelle et de mise au carré (voir ^[H05]) est choisi.

Exemples

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)

Méthode plus efficace pour exp(im*A) de la matrice carrée A (surtout si A est Hermitienne ou Symétrique réel).

Voir aussi cispi, sincos, exp.

Exemples

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

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

Puissance de matrice, équivalente à $\exp(p\log(A))$

Exemples

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

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

Exponential de matrice, équivalent à $\exp(\log(b)A)$.

Exemples

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)

Si A n'a pas de valeur propre réelle négative, calculez le logarithme matriciel principal de A, c'est-à-dire la matrice unique $X$ telle que $e^X = A$ et $-\pi < Im(\lambda) < \pi$ pour toutes les valeurs propres $\lambda$ de $X$. Si A a des valeurs propres non positives, une fonction matricielle non principale est renvoyée chaque fois que cela est possible.

Si A est symétrique ou hermitienne, sa décomposition en valeurs propres (eigen) est utilisée, si A est triangulaire, une version améliorée de la méthode d'inversion par mise à l'échelle et de mise à l'échelle est employée (voir ^[AH12] et ^[AHR13]). Si A est réel sans valeurs propres négatives, alors la forme de Schur réelle est calculée. Sinon, la forme de Schur complexe est calculée. Ensuite, l'algorithme triangulaire supérieur (quasi-)triangulaire dans ^[AHR13] est utilisé sur le facteur supérieur (quasi-)triangulaire.

Exemples

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)

Retourne $\sqrt{x}$.

Lève une DomainError pour les arguments Real négatifs. Utilisez plutôt des arguments complexes négatifs. Notez que sqrt a une coupure de branche le long de l'axe réel négatif.

L'opérateur préfixe √ est équivalent à sqrt.

Voir aussi : hypot.

Exemples

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError with -81.0:
NaN result for non-NaN input.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

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

julia> sqrt(-81 - 0.0im)  # -0.0im est en dessous de la coupure de branche
0.0 - 9.0im

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

sqrt(A::AbstractMatrix)

Si A n'a pas d'autovalues réelles négatives, calculez la racine carrée principale de la matrice A, c'est-à-dire la matrice unique $X$ dont les autovalues ont une partie réelle positive telle que $X^2 = A$. Sinon, une racine carrée non principale est retournée.

Si A est réelle-symétrique ou hermitienne, sa décomposition en valeurs propres (eigen) est utilisée pour calculer la racine carrée. Pour de telles matrices, les autovalues λ qui semblent légèrement négatives en raison d'erreurs d'arrondi sont traitées comme si elles étaient nulles. Plus précisément, les matrices avec toutes les autovalues ≥ -rtol*(max |λ|) sont considérées comme semi-définies (produisant une racine carrée hermitienne), avec les autovalues négatives considérées comme nulles. rtol est un argument clé pour sqrt (dans le cas hermitien/réel-symétrique uniquement) qui par défaut est la précision machine multipliée par size(A,1).

Sinon, la racine carrée est déterminée par la méthode de Björck-Hammarling ^[BH83], qui calcule la forme de Schur complexe (schur) puis la racine carrée complexe du facteur triangulaire. Si une racine carrée réelle existe, alors une extension de cette méthode ^[H87] qui calcule la forme de Schur réelle puis la racine carrée réelle du facteur quasi-triangulaire est utilisée à la place.

Exemples

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

Calcule la racine cubique réelle d'une matrice réelle A. Si T = cbrt(A), alors nous avons T*T*T ≈ A, voir l'exemple donné ci-dessous.

Si A est symétrique, c'est-à-dire de type HermOrSym{<:Real}, alors (eigen) est utilisé pour trouver la racine cubique. Sinon, une version spécialisée de l'algorithme de racine p-th ^[S03] est utilisée, qui exploite la décomposition de Schur réelle (schur) pour calculer la racine cubique.

Exemples

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)

Calcule le cosinus matriciel d'une matrice carrée A.

Si A est symétrique ou hermitienne, sa décomposition en valeurs propres (eigen) est utilisée pour calculer le cosinus. Sinon, le cosinus est déterminé en appelant exp.

Exemples

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

sin(A::AbstractMatrix)

Calcule le sinus matriciel d'une matrice carrée A.

Si A est symétrique ou hermitienne, sa décomposition en valeurs propres (eigen) est utilisée pour calculer le sinus. Sinon, le sinus est déterminé en appelant exp.

Exemples

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

sincos(A::AbstractMatrix)

Calcule le sinus et le cosinus matriciels d'une matrice carrée A.

Exemples

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)

Calcule la tangente matricielle d'une matrice carrée A.

Si A est symétrique ou hermitienne, sa décomposition en valeurs propres (eigen) est utilisée pour calculer la tangente. Sinon, la tangente est déterminée en appelant exp.

Exemples

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

sec(A::AbstractMatrix)

Calcule la sécante matricielle d'une matrice carrée A.

csc(A::AbstractMatrix)

Calculez la cosecante de matrice d'une matrice carrée A.

cot(A::AbstractMatrix)

Calculez la cotangente matricielle d'une matrice carrée A.

cosh(A::AbstractMatrix)

Calculez le cosinus hyperbolique matriciel d'une matrice carrée A.

sinh(A::AbstractMatrix)

Calculez le sinus hyperbolique matriciel d'une matrice carrée A.

tanh(A::AbstractMatrix)

Calculez la tangente hyperbolique de matrice d'une matrice carrée A.

sech(A::AbstractMatrix)

Calculez la sécante hyperbolique de matrice de la matrice carrée A.

csch(A::AbstractMatrix)

Calculez la cosecante hyperbolique de matrice de la matrice carrée A.

coth(A::AbstractMatrix)

Calculez le cotangent hyperbolique de matrice de la matrice carrée A.

acos(A::AbstractMatrix)

Calcule le cosinus inverse d'une matrice carrée A.

Si A est symétrique ou hermitienne, sa décomposition en valeurs propres (eigen) est utilisée pour calculer le cosinus inverse. Sinon, le cosinus inverse est déterminé en utilisant log et sqrt. Pour la théorie et les formules logarithmiques utilisées pour calculer cette fonction, voir ^[AH16_1].

Exemples

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)

Calculez le sinus inverse de matrice d'une matrice carrée A.

Si A est symétrique ou hermitienne, sa décomposition en valeurs propres (eigen) est utilisée pour calculer le sinus inverse. Sinon, le sinus inverse est déterminé en utilisant log et sqrt. Pour la théorie et les formules logarithmiques utilisées pour calculer cette fonction, voir ^[AH16_2].

Exemples

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)

Calcule la tangente inverse de matrice d'une matrice carrée A.

Si A est symétrique ou hermitienne, son eigendecomposition (eigen) est utilisée pour calculer la tangente inverse. Sinon, la tangente inverse est déterminée en utilisant log. Pour la théorie et les formules logarithmiques utilisées pour calculer cette fonction, voir ^[AH16_3].

Exemples

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)

Calculez la matrice sécante inverse de A.

acsc(A::AbstractMatrix)

Calculez la cosecante de matrice inverse de A.

acot(A::AbstractMatrix)

Calculez la cotangente inverse de la matrice A.

acosh(A::AbstractMatrix)

Calculez le cosinus hyperbolique inverse d'une matrice carrée A. Pour la théorie et les formules logarithmiques utilisées pour calculer cette fonction, voir ^[AH16_4].

asinh(A::AbstractMatrix)

Calculez le sinus hyperbolique inverse d'une matrice carrée A. Pour la théorie et les formules logarithmiques utilisées pour calculer cette fonction, voir ^[AH16_5].

atanh(A::AbstractMatrix)

Calculez la tangente hyperbolique inverse d'une matrice carrée A. Pour la théorie et les formules logarithmiques utilisées pour calculer cette fonction, voir ^[AH16_6].

asech(A::AbstractMatrix)

Calculez la matrice inverse de la sécante hyperbolique de A.

acsch(A::AbstractMatrix)

Calculez le cosécante hyperbolique inverse de la matrice A.

acoth(A::AbstractMatrix)

Calculez le cotangente hyperbolique inverse de A.

lyap(A, C)

Calcule la solution X de l'équation de Lyapunov continue AX + XA' + C = 0, où aucun eigenvalue de A n'a de partie réelle nulle et aucun deux eigenvalues ne sont des conjugués complexes négatifs l'un de l'autre.

Exemples

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)

Calcule la solution X de l'équation de Sylvester AX + XB + C = 0, où A, B et C ont des dimensions compatibles et A et -B n'ont pas d'autovalues avec une partie réelle égale.

Exemples

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

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

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

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

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

issuccess(F::Factorization)

Testez si une factorisation d'une matrice a réussi.

Exemples

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

julia> issuccess(F)
true

issuccess(F::LU; allowsingular = false)

Testez si la factorisation LU d'une matrice a réussi. Par défaut, une factorisation qui produit un facteur U valide mais de rang déficient est considérée comme un échec. Cela peut être modifié en passant allowsingular = true.

Exemples

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

julia> issuccess(F)
false

julia> issuccess(F, allowsingular = true)
true

issymmetric(A) -> Bool

Teste si une matrice est symétrique.

Exemples

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

Testez si une matrice est définie positive (et Hermitienne) en essayant d'effectuer une factorisation de Cholesky de A.

Voir aussi isposdef!, cholesky.

Exemples

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

julia> isposdef(A)
true

isposdef!(A) -> Bool

Testez si une matrice est définie positive (et Hermitienne) en essayant d'effectuer une factorisation de Cholesky de A, en écrasant A dans le processus. Voir aussi isposdef.

Exemples

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

Testez si A est triangulaire inférieure à partir de la k-ième superdiagonale.

Exemples

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

Testez si A est triangulaire supérieure à partir de la k-ième superdiagonale.

Exemples

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

Testez si une matrice est diagonale dans le sens où iszero(A[i,j]) est vrai sauf si i == j. Notez qu'il n'est pas nécessaire que A soit carrée ; si vous souhaitez également vérifier cela, vous devez vérifier que size(A, 1) == size(A, 2).

Exemples

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

Testez si une matrice est Hermitienne.

Exemples

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)

Transposition paresseuse. La mutation de l'objet retourné doit muter A de manière appropriée. Souvent, mais pas toujours, cela donne Transpose(A), où Transpose est un wrapper de transposition paresseuse. Notez que cette opération est récursive.

Cette opération est destinée à un usage en algèbre linéaire - pour la manipulation générale des données, voir permutedims, qui est non récursive.

Exemples

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 # la transposition d'une transposition déplie le parent
true

julia> Transpose(B) # cependant, le constructeur enveloppe toujours son argument
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
 3  2
 0  0

julia> B[1,2] = 4; # modifier B modifiera automatiquement A

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

Pour les matrices complexes, l'opération adjoint est équivalente à une transposition conjuguée.

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

La transpose d'un AbstractVector est un vecteur ligne :

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

julia> transpose(v) # retourne un vecteur ligne
1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> transpose(v) * v # calcule le produit scalaire
14

Pour une matrice de matrices, les blocs individuels sont opérés de manière récursive :

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

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

julia> transpose(D) # les blocs sont transposés de manière récursive
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 2; 3 4]   [2 4; 6 8]
 [3 6; 9 12]  [4 8; 12 16]

transpose(F::Factorization)

Transposition paresseuse de la factorisation F. Par défaut, renvoie une TransposeFactorization, sauf pour les Factorization avec un eltype réel, auquel cas renvoie une AdjointFactorization.

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

Transposer la matrice A et la stocke dans la matrice X. size(X) doit être égal à size(transpose(A)). Aucune mémoire supplémentaire n'est allouée en dehors du redimensionnement de rowval et nzval de X, si nécessaire.

Voir halfperm!

transpose!(dest,src)

Transposer le tableau src et stocker le résultat dans le tableau préalloué dest, qui doit avoir une taille correspondant à (size(src,2),size(src,1)). Aucune transposition en place n'est supportée et des résultats inattendus se produiront si src et dest ont des régions de mémoire qui se chevauchent.

Exemples

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

Transposé

Type d'enveloppe paresseux pour une vue transposée de l'objet d'algèbre linéaire sous-jacent, généralement un AbstractVector/AbstractMatrix. En général, le constructeur Transpose ne doit pas être appelé directement, utilisez plutôt transpose. Pour matérialiser la vue, utilisez copy.

Ce type est destiné à une utilisation en algèbre linéaire - pour la manipulation générale des données, voir permutedims.

Exemples

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

Type d'enveloppe paresseux pour la transposée de l'objet Factorization sous-jacent. En général, le constructeur TransposeFactorization ne doit pas être appelé directement, utilisez plutôt transpose(:: Factorization).

A'
adjoint(A)

Adjoint paresseux (transposition conjuguée). Notez que adjoint est appliqué de manière récursive aux éléments.

Pour les types numériques, adjoint renvoie le conjugué complexe, et donc il est équivalent à la fonction identité pour les nombres réels.

Cette opération est destinée à une utilisation en algèbre linéaire - pour la manipulation générale des données, voir permutedims.

Exemples

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 à adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

julia> B isa Adjoint
true

julia> adjoint(B) === A # l'adjoint d'un adjoint déplie le parent
true

julia> Adjoint(B) # cependant, le constructeur enveloppe toujours son argument
2×2 adjoint(adjoint(::Matrix{Complex{Int64}})) with eltype Complex{Int64}:
 3+2im  9+2im
 0+0im  0+0im

julia> B[1,2] = 4 + 5im; # modifier B modifiera automatiquement A

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

Pour les matrices réelles, l'opération adjoint est équivalente à une transpose.

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

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

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

L'adjoint d'un AbstractVector est un vecteur ligne :

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

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

julia> x'x # calculer le produit scalaire, équivalent à x' * x
25 + 0im

Pour une matrice de matrices, les blocs individuels sont opérés de manière récursive :

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

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

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

adjoint(F::Factorization)

Adjoint paresseux de la factorisation F. Par défaut, renvoie un wrapper AdjointFactorization.

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

Transposer la matrice A et stocke l'adjoint des éléments dans la matrice X. size(X) doit être égal à size(transpose(A)). Aucune mémoire supplémentaire n'est allouée en dehors du redimensionnement de rowval et nzval de X, si nécessaire.

Voir halfperm!

adjoint!(dest,src)

Transpose conjuguée du tableau src et stockez le résultat dans le tableau préalloué dest, qui doit avoir une taille correspondant à (size(src,2),size(src,1)). Aucune transposition en place n'est prise en charge et des résultats inattendus se produiront si src et dest ont des régions de mémoire qui se chevauchent.

Exemples

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

Type d'enveloppe paresseux pour une vue adjoint de l'objet d'algèbre linéaire sous-jacent, généralement un AbstractVector/AbstractMatrix. En général, le constructeur Adjoint ne doit pas être appelé directement, utilisez plutôt adjoint. Pour matérialiser la vue, utilisez copy.

Ce type est destiné à une utilisation en algèbre linéaire - pour la manipulation générale des données, voir permutedims.

Exemples

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

julia> Adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

AdjointFactorization

Type d'enveloppe paresseux pour l'adjoint de l'objet Factorization sous-jacent. En général, le constructeur AdjointFactorization ne doit pas être appelé directement, utilisez plutôt adjoint(:: Factorization).

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

Évaluez avec empressement la transposition/adjointe de matrice paresseuse. Notez que la transposition est appliquée de manière récursive aux éléments.

Cette opération est destinée à un usage en algèbre linéaire - pour une manipulation générale des données, voir permutedims, qui est non récursive.

Exemples

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

Retourne la distance entre les éléments successifs du tableau dans la dimension 1 en unités de taille d'élément.

Exemples

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)

Vérifiez qu'une matrice est carrée, puis renvoyez sa dimension commune. Pour plusieurs arguments, renvoyez un vecteur.

Exemples

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 calcule le taux de flop maximal de l'ordinateur en utilisant la précision double gemm!. Par défaut, si aucun argument n'est spécifié, il multiplie deux matrices Float64 de taille n x n, où n = 4096. Si le BLAS sous-jacent utilise plusieurs threads, des taux de flop plus élevés sont réalisés. Le nombre de threads BLAS peut être défini avec BLAS.set_num_threads(n).

Si l'argument clé eltype est fourni, peakflops construira des matrices avec des éléments de type eltype pour calculer le taux de flop maximal.

Par défaut, peakflops utilisera le meilleur timing parmi 3 essais. Si l'argument clé ntrials est fourni, peakflops utilisera ce nombre d'essais pour choisir le meilleur timing.

Si l'argument clé parallel est défini sur true, peakflops est exécuté en parallèle sur tous les processeurs de travail. Le taux de flop de l'ensemble de l'ordinateur parallèle est retourné. Lors de l'exécution en parallèle, un seul thread BLAS est utilisé. L'argument n fait toujours référence à la taille du problème qui est résolu sur chaque processeur.

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

Retourne la partie hermitienne de la matrice carrée A, définie comme (A + A') / 2, sous forme d'une matrice Hermitian. Pour les matrices réelles A, cela est également connu sous le nom de partie symétrique de A ; on l'appelle parfois la "partie réelle de l'opérateur". L'argument optionnel uplo contrôle l'argument correspondant de la vue Hermitian. Pour les matrices réelles, cette dernière est équivalente à une vue Symmetric.

Voir aussi hermitianpart! pour l'opération correspondante en place.

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

Écrasez la matrice carrée A sur place avec sa partie hermitienne (A + A') / 2, et retournez Hermitian(A, uplo). Pour les matrices réelles A, cela est également connu sous le nom de partie symétrique de A.

Voir aussi hermitianpart pour l'opération correspondante hors place.

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

Copier efficacement les éléments de la matrice A vers B avec adjunction comme suit :

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

Les éléments B[ir_dest, jr_dest] sont écrasés. De plus, les paramètres de plage d'index doivent satisfaire length(ir_dest) == length(jr_src) et length(jr_dest) == length(ir_src).

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

Copier efficacement les éléments de la matrice A vers B avec transposition comme suit :

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

Les éléments B[ir_dest, jr_dest] sont écrasés. De plus, les paramètres de plage d'index doivent satisfaire length(ir_dest) == length(jr_src) et length(jr_dest) == length(ir_src).

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

Copier efficacement les éléments de la matrice M vers B en fonction du paramètre de caractère tM comme suit :

Les éléments B[ir_dest, jr_dest] sont écrasés. De plus, les paramètres de plage d'index doivent satisfaire length(ir_dest) == length(jr_src) et length(jr_dest) == length(ir_src).

Voir aussi copyto! et copy_adjoint!.

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

Calcule le produit matrice-matrice ou matrice-vecteur $A B$ et stocke le résultat dans Y, écrasant la valeur existante de Y. Notez que Y ne doit pas être aliasé avec A ou B.

Exemples

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

Implémentation

Pour les types de matrices et de vecteurs personnalisés, il est recommandé d'implémenter mul! à 5 arguments plutôt que d'implémenter directement mul! à 3 arguments si possible.

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

Multiplication-addition de matrices ou de vecteurs en place combinée $A B α + C β$. Le résultat est stocké dans C en le remplaçant. Notez que C ne doit pas être aliasé avec A ou B.

Exemples

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]; # Une copie de la valeur originale de C

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

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

Échelle d'un tableau B par un scalaire a en écrasant B sur place. Utilisez rmul! pour multiplier le scalaire par la droite. L'opération de mise à l'échelle respecte la sémantique de la multiplication * entre a et un élément de B. En particulier, cela s'applique également à la multiplication impliquant des nombres non finis tels que NaN et ±Inf.

Exemples

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)

Calcule le produit matriciel $AB$, en écrasant B, et retourne le résultat. Ici, A doit être d'un type de matrice spécial, comme, par exemple, Diagonal, UpperTriangular ou LowerTriangular, ou d'un type orthogonal, voir QR.

Exemples

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)

Échelle un tableau A par un scalaire b en écrasant A sur place. Utilisez lmul! pour multiplier le scalaire par la gauche. L'opération de mise à l'échelle respecte la sémantique de la multiplication * entre un élément de A et b. En particulier, cela s'applique également à la multiplication impliquant des nombres non finis tels que NaN et ±Inf.

Exemples

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)

Calcule le produit matrice-matrice $AB$, en écrasant A, et retourne le résultat. Ici, B doit être d'un type de matrice spécial, comme, par exemple, Diagonal, UpperTriangular ou LowerTriangular, ou d'un type orthogonal, voir QR.

Exemples

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

Calcule A \ B sur place et stocke le résultat dans Y, en retournant le résultat.

L'argument A ne doit pas être une matrice. Au lieu de matrices, il doit s'agir d'un objet de factorisation (par exemple, produit par factorize ou cholesky). La raison en est que la factorisation elle-même est à la fois coûteuse et nécessite généralement d'allouer de la mémoire (bien qu'elle puisse également être effectuée sur place via, par exemple, lu!), et les situations critiques en termes de performance nécessitant ldiv! exigent généralement un contrôle fin sur la factorisation de A.

Exemples

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)

Calcule A \ B sur place et écrase B pour stocker le résultat.

L'argument A ne doit pas être une matrice. Au lieu de matrices, il doit s'agir d'un objet de factorisation (par exemple, produit par factorize ou cholesky). La raison en est que la factorisation elle-même est à la fois coûteuse et nécessite généralement d'allouer de la mémoire (bien qu'elle puisse également être effectuée sur place via, par exemple, lu!), et les situations critiques en termes de performance nécessitant ldiv! nécessitent généralement également un contrôle fin sur la factorisation de A.

Exemples

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)

Divise chaque entrée d'un tableau B par un scalaire a en écrasant B sur place. Utilisez rdiv! pour diviser le scalaire par la droite.

Exemples

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

Calcule A \ B sur place par élimination de Gauss avec pivotement partiel et stocke le résultat dans B, retournant le résultat. Dans le processus, les diagonales de A sont également écrasées.

rdiv!(A, B)

Calcule A / B sur place et écrase A pour stocker le résultat.

L'argument B ne doit pas être une matrice. Au lieu de matrices, il doit s'agir d'un objet de factorisation (par exemple, produit par factorize ou cholesky). La raison en est que la factorisation elle-même est à la fois coûteuse et nécessite généralement de l'allocation de mémoire (bien qu'elle puisse également être effectuée sur place via, par exemple, lu!), et les situations critiques en termes de performance nécessitant rdiv! exigent généralement un contrôle fin sur la factorisation de B.

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

Divise chaque entrée d'un tableau A par un scalaire b en écrasant A sur place. Utilisez ldiv! pour diviser le scalaire par la gauche.

Exemples

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

Interface aux sous-routines BLAS.

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

Définissez le nombre de threads que la bibliothèque BLAS doit utiliser égal à n::Integer.

Accepte également nothing, auquel cas julia essaie de deviner le nombre par défaut de threads. Passer nothing est déconseillé et existe principalement pour des raisons historiques.

get_num_threads()

Obtenez le nombre de threads que la bibliothèque BLAS utilise.

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

Écrase X avec c*X + s*Y et Y avec -conj(s)*X + c*Y pour les premiers n éléments du tableau X avec un pas incx et les premiers n éléments du tableau Y avec un pas incy. Renvoie X et Y.

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

Écrasez X avec a*X pour les premiers n éléments du tableau X avec un pas incx. Renvoie X.

Si n et incx ne sont pas fournis, length(X) et stride(X,1) sont utilisés.

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

Renvoie X mis à l'échelle par a pour les premiers n éléments du tableau X avec un pas incx.

Si n et incx ne sont pas fournis, length(X) et stride(X,1) sont utilisés.

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

Copie n éléments du tableau X avec un pas incx vers le tableau Y avec un pas incy. Renvoie Y.

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

Produit scalaire de deux vecteurs consistant en n éléments du tableau X avec un pas incx et n éléments du tableau Y avec un pas incy.

Exemples

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

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

Fonction Dot pour deux vecteurs complexes consistant en n éléments du tableau X avec un pas incx et n éléments du tableau Y avec un pas incy.

Exemples

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)

Fonction Dot pour deux vecteurs complexes, consistant en n éléments du tableau X avec un pas incx et n éléments du tableau U avec un pas incy, conjuguant le premier vecteur.

Exemples

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

nrm2(n, X, incx)

2-norme d'un vecteur composé de n éléments du tableau X avec un pas incx.

Exemples

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)

Somme des magnitudes des premiers n éléments du tableau X avec un pas incx.

Pour un tableau réel, la magnitude est la valeur absolue. Pour un tableau complexe, la magnitude est la somme de la valeur absolue de la partie réelle et de la valeur absolue de la partie imaginaire.

Exemples

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)

Trouvez l'indice de l'élément de dx ayant la valeur absolue maximale. n est la longueur de dx, et incx est le pas. Si n et incx ne sont pas fournis, ils supposent des valeurs par défaut de n=length(dx) et incx=stride1(dx).

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

Met à jour le vecteur y comme alpha*A*x + beta*y ou alpha*A'x + beta*y selon tA. alpha et beta sont des scalaires. Retourne le y mis à jour.

gemv(tA, alpha, A, x)

Retourne alpha*A*x ou alpha*A'x selon tA. alpha est un scalaire.

gemv(tA, A, x)

Retourne A*x ou A'x selon tA.

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

Met à jour le vecteur y comme alpha*A*x + beta*y ou alpha*A'*x + beta*y selon trans. La matrice A est une matrice bande générale de dimension m par size(A,2) avec kl sous-diagonales et ku super-diagonales. alpha et beta sont des scalaires. Retourne le y mis à jour.

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

Retourne alpha*A*x ou alpha*A'*x selon trans. La matrice A est une matrice bande générale de dimension m par size(A,2) avec kl sous-diagonales et ku super-diagonales, et alpha est un scalaire.

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

Met à jour le vecteur y comme alpha*A*x + beta*y. A est supposé être hermitien. Seul le triangle ul de A est utilisé. alpha et beta sont des scalaires. Retourne le y mis à jour.

hemv(ul, alpha, A, x)

Retourne alpha*A*x. A est supposé être hermitien. Seule la ul triangle de A est utilisée. alpha est un scalaire.

hemv(ul, A, x)

Retourne A*x. A est supposé être hermitien. Seul le triangle ul de A est utilisé.

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

Met à jour le vecteur y comme α*A*x + β*y, où A est une matrice hermitienne fournie au format packagé AP.

Avec uplo = 'U', le tableau AP doit contenir la partie triangulaire supérieure de la matrice hermitienne packagée séquentiellement, colonne par colonne, de sorte que AP[1] contienne A[1, 1], AP[2] et AP[3] contiennent respectivement A[1, 2] et A[2, 2], et ainsi de suite.

Avec uplo = 'L', le tableau AP doit contenir la partie triangulaire inférieure de la matrice hermitienne packagée séquentiellement, colonne par colonne, de sorte que AP[1] contienne A[1, 1], AP[2] et AP[3] contiennent respectivement A[2, 1] et A[3, 1], et ainsi de suite.

Les entrées scalaires α et β doivent être des nombres complexes ou réels.

Les entrées de tableau x, y et AP doivent toutes être de type ComplexF32 ou ComplexF64.

Retourne le y mis à jour.

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

Met à jour le vecteur y comme alpha*A*x + beta*y. A est supposé être symétrique. Seule la triangle ul de A est utilisée. alpha et beta sont des scalaires. Retourne le y mis à jour.

symv(ul, alpha, A, x)

Retourne alpha*A*x. A est supposé être symétrique. Seule la ul triangle de A est utilisée. alpha est un scalaire.

symv(ul, A, x)

Retourne A*x. A est supposé être symétrique. Seule la ul triangle de A est utilisée.

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

Met à jour le vecteur y comme alpha*A*x + beta*y où A est une matrice symétrique en bande d'ordre size(A,2) avec k super-diagonales stockées dans l'argument A. La disposition de stockage pour A est décrite dans le module de référence BLAS, BLAS de niveau 2 à https://www.netlib.org/lapack/explore-html/. Seul le triangle uplo de A est utilisé.

Retourne le y mis à jour.

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

Retourne alpha*A*x où A est une matrice symétrique en bande d'ordre size(A,2) avec k super-diagonales stockées dans l'argument A. Seul le triangle uplo de A est utilisé.

sbmv(uplo, k, A, x)

Retourne A*x où A est une matrice symétrique en bande d'ordre size(A,2) avec k super-diagonales stockées dans l'argument A. Seule la triangle uplo de A est utilisée.

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

Met à jour le vecteur y comme α*A*x + β*y, où A est une matrice symétrique fournie au format packagé AP.

Avec uplo = 'U', le tableau AP doit contenir la partie triangulaire supérieure de la matrice symétrique emballée séquentiellement, colonne par colonne, de sorte que AP[1] contienne A[1, 1], AP[2] et AP[3] contiennent respectivement A[1, 2] et A[2, 2], et ainsi de suite.

Avec uplo = 'L', le tableau AP doit contenir la partie triangulaire inférieure de la matrice symétrique emballée séquentiellement, colonne par colonne, de sorte que AP[1] contienne A[1, 1], AP[2] et AP[3] contiennent respectivement A[2, 1] et A[3, 1], et ainsi de suite.

Les entrées scalaires α et β doivent être réelles.

Les entrées de tableau x, y et AP doivent toutes être de type Float32 ou Float64.

Retourne le y mis à jour.

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

Retourne op(A)*b, où op est déterminé par tA. Seul le triangle ul de A est utilisé. dA détermine si les valeurs diagonales sont lues ou supposées être toutes égales à un. La multiplication se fait en place sur b.

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

Retourne op(A)*b, où op est déterminé par tA. Seule la triangle ul de A est utilisée. dA détermine si les valeurs diagonales sont lues ou supposées être toutes égales à un.

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

Écrasez b avec la solution de A*x = b ou l'une des deux autres variantes déterminées par tA et ul. dA détermine si les valeurs diagonales sont lues ou supposées être toutes égales à un. Retournez le b mis à jour.

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

Retourne la solution de A*x = b ou l'une des deux autres variantes déterminées par tA et ul. dA détermine si les valeurs diagonales sont lues ou supposées être toutes égales à un.

ger!(alpha, x, y, A)

Mise à jour de rang-1 de la matrice A avec les vecteurs x et y comme alpha*x*y' + A.

her!(uplo, alpha, x, A)

Méthodes uniquement pour les tableaux complexes. Mise à jour de rang 1 de la matrice hermitienne A avec le vecteur x comme alpha*x*x' + A. uplo contrôle quel triangle de A est mis à jour. Renvoie A.

syr!(uplo, alpha, x, A)

Mise à jour de rang-1 de la matrice symétrique A avec le vecteur x sous la forme alpha*x*transpose(x) + A. uplo contrôle quel triangle de A est mis à jour. Renvoie A.

spr!(uplo, α, x, AP)

Mettre à jour la matrice A comme A+α*x*x', où A est une matrice symétrique fournie au format packagé AP et x est un vecteur.

Avec uplo = 'U', le tableau AP doit contenir la partie triangulaire supérieure de la matrice symétrique emballée séquentiellement, colonne par colonne, de sorte que AP[1] contienne A[1, 1], AP[2] et AP[3] contiennent respectivement A[1, 2] et A[2, 2], et ainsi de suite.

Avec uplo = 'L', le tableau AP doit contenir la partie triangulaire inférieure de la matrice symétrique emballée séquentiellement, colonne par colonne, de sorte que AP[1] contienne A[1, 1], AP[2] et AP[3] contiennent respectivement A[2, 1] et A[3, 1], et ainsi de suite.

L'entrée scalaire α doit être réelle.

Les entrées de tableau x et AP doivent toutes être de type Float32 ou Float64. Retournez le AP mis à jour.

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

Met à jour la partie triangulaire inférieure ou supérieure spécifiée par uplo de C comme alpha*A*B + beta*C ou les autres variantes selon tA et tB. Retourne le C mis à jour.

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

Retourne la partie triangulaire inférieure ou supérieure spécifiée par uplo de A*B ou les trois autres variantes selon tA et tB.

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

Retourne la partie triangulaire inférieure ou supérieure spécifiée par uplo de A*B ou les trois autres variantes selon tA et tB.

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

Mettre à jour C comme alpha*A*B + beta*C ou les trois autres variantes selon tA et tB. Retourner le C mis à jour.

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

Retourne alpha*A*B ou les trois autres variantes selon tA et tB.

gemm(tA, tB, A, B)

Retourne A*B ou les trois autres variantes selon tA et tB.