La traduction de cette page n'est pas à jour. Cliquez ici pour voir la dernière version en anglais.

inv

Inverse de matrice

Syntaxe

Y = inv(X)

Description

Y = inv(X) calcule l’inverse de la matrice carrée X.

• X^(-1) est équivalent à inv(X).

• x = A\b est calculé différemment de x = inv(A)*b et est recommandé pour résoudre les systèmes d’équations linéaires.

Exemples

Matrice inverse

Calculez l’inverse d’une matrice de 3 x 3.

X = [1 0 2; -1 5 0; 0 3 -9]

X = 3×3

     1     0     2
    -1     5     0
     0     3    -9

Y = inv(X)

Y = 3×3

    0.8824   -0.1176    0.1961
    0.1765    0.1765    0.0392
    0.0588    0.0588   -0.0980

Vérifiez les résultats. Idéalement, Y*X produit la matrice identité. Puisque inv effectue l’inversion de matrice à l’aide de calculs en virgule flottante, Y*X est, dans la pratique, proche mais pas tout à fait égale à la matrice identité eye(size(X)).

Y*X

ans = 3×3

    1.0000    0.0000   -0.0000
         0    1.0000   -0.0000
         0   -0.0000    1.0000

Résoudre un système linéaire

Vérifiez pourquoi la résolution d’un système linéaire par inversion de matrice via inv(A)*b est inférieure à la résolution directe à l’aide de l’opérateur backslash, x = A\b.

Créez une matrice aléatoire A d’ordre 500 construite de sorte que son nombre de conditionnement cond(A) corresponde à 1e10, et que sa norme norm(A) corresponde à 1. La solution exacte x est un vecteur aléatoire de longueur 500, et le côté droit est b = A*x. Ainsi, le système d’équations linéaires est mal conditionné mais régulier.

n = 500; 
Q = orth(randn(n,n));
d = logspace(0,-10,n);
A = Q*diag(d)*Q';
x = randn(n,1);
b = A*x;

Résolvez le système linéaire A*x = b en inversant la matrice de coefficients A. Utilisez tic et toc pour obtenir des informations sur le temps d'exécution.

tic
y = inv(A)*b; 
t = toc

t = 0.0331

Identifiez l’erreur absolue et l’erreur résiduelle du calcul.

err_inv = norm(y-x)

err_inv = 3.5877e-06

res_inv = norm(A*y-b)

res_inv = 4.0719e-07

Résolvez maintenant le même système linéaire en utilisant l’opérateur backslash \.

tic
z = A\b;
t1 = toc

t1 = 0.0279

err_bs = norm(z-x)

err_bs = 2.3426e-06

res_bs = norm(A*z-b)

res_bs = 2.6245e-15

Le calcul backslash est plus rapide et présente une erreur résiduelle inférieure de plusieurs ordres d’amplitude. Le fait que err_inv et err_bs sont tous deux de l’ordre de 1e-6 reflète simplement le nombre de conditionnement de la matrice.

Le comportement de cet exemple est typique. Le fait d’utiliser A\b plutôt que inv(A)*b est deux à trois fois plus rapide et produit des résidus de l’ordre de la précision de la machine par rapport à l’amplitude des données.

Arguments d'entrée

X — Matrice en entrée

matrice carrée

Matrice en entrée, spécifiée en tant que matrice carrée. Si X est mal mise à l’échelle ou presque singulière, le calcul de inv perd de sa précision numérique. Utilisez rcond ou cond pour vérifier le nombre de conditionnement de la matrice.

Types de données : single | double
Support des nombres complexes : Oui

En savoir plus

Inverse de matrice

Une matrice X est inversible s’il existe une matrice Y de même taille telle que $$XY=YX=I_n$$, où $$I_n$$ est une matrice identité de dimension n x n. La matrice Y est appelée l’inverse de X.

Une matrice sans inverse est singulière. Une matrice carrée n’est singulière que si son déterminant est exactement zéro.

Conseils

• Il est rarement nécessaire de former l’inverse explicite d’une matrice. Une mauvaise utilisation de inv se produit fréquemment lors de la résolution d’un système d’équations linéaires Ax = b. Pour résoudre l’équation, une possibilité consiste à utiliser x = inv(A)*b. Du point de vue du temps d’exécution et de l’exactitude numérique, une meilleure option consiste à utiliser l’opérateur matriciel backslash x = A\b. Cela produit la solution en utilisant l'élimination de Gauss-Jordan, sans former explicitement l’inverse. Consultez mldivide pour plus d’informations.

Algorithmes

inv effectue une décomposition LU de la matrice en entrée (ou une décomposition LDL si la matrice en entrée est hermitienne). Elle utilise ensuite les résultats pour former un système linéaire dont la solution est l’inverse de la matrice inv(X). Pour les entrées de matrice creuse, inv(X) crée une matrice identité creuse et utilise le backslash X\speye(size(X)).

Capacités étendues

Génération de code C/C++

Générez du code C et C++ avec MATLAB® Coder™.

Notes d’usage et limitations :

• L'utilisation de matrices singulières en entrée peut produire des valeurs non finies qui diffèrent des résultats de MATLAB^®.

Environnement basé sur les threads

Exécutez du code en arrière-plan avec MATLAB® backgroundPool ou accélérez le code avec Parallel Computing Toolbox™ ThreadPool.

Cette fonction supporte entièrement les environnements basés sur des threads. Pour plus d’informations, consultez Run MATLAB Functions in Thread-Based Environment.

GPU Arrays

Accélérez le code en exécutant les calculs sur une unité de traitement graphique (GPU) avec Parallel Computing Toolbox™.

• X doit être non creuse.

• La fonction MATLAB inv affiche un avertissement si X est mal mis à l’échelle ou presque singulier. La fonction gpuArray inv n’est pas en mesure de vérifier cette condition. Prenez des mesures pour éviter cette situation.

Pour plus d’informations, consultez Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Distributed arrays

Divisez les tableaux volumineux dans la mémoire combinée de votre cluster avec Parallel Computing Toolbox™.

Cette fonction supporte entièrement les distributed arrays. Pour plus d’informations, consultez Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Historique des versions

Introduit avant R2006a

R2022a: Amélioration des performances lors de l’inversion de grandes matrices triangulaires

La fonction inv est plus performante lorsqu’elle opère sur de grandes matrices triangulaires.

Par exemple, l’inversion d’une matrice triangulaire supérieure de 5 000 x 5 000 est environ 3,7 fois plus rapide par rapport à la version précédente.

function timingInv
rng default
A = randn(5e3);
[~,R] = lu(A);

tic
Y = inv(R); 
toc
end

Les temps d’exécution approximatifs sont les suivants :

R2021b : 1,1 s

R2022a : 0,3 s

Le code a été chronométré sur un système de test Windows^® 10 avec CPU, Intel^® Xeon^® W-2133 @ 3.60 GHz en utilisant la fonction timingInv.

Voir aussi

det | lu | rref | mldivide