Exemple pratique de pourquoi il n'est pas bon d'inverser une matrice

Je suis conscient du fait qu'inverser une matrice pour résoudre un système linéaire n'est pas une bonne idée, car il n'est pas aussi précis et aussi efficace que de résoudre directement le système ou d'utiliser la décomposition LU, Cholesky ou QR.

Cependant, je n'ai pas pu vérifier cela avec un exemple pratique. J'ai essayé ce code (dans MATLAB)

M   = 500;    
A   = rand(M,M);
A   = real(expm(1i*(A+A.')));
b   = rand(M,1);

x1  = A\b;
x2  = inv(A)*b;

disp(norm(b-A*x1))
disp(norm(b-A*x2))

et les résidus sont toujours du même ordre (10 ^ -13).

Quelqu'un pourrait-il fournir un exemple pratique dans lequel inv (A) * b est beaucoup moins inexact que A \ b?

------ Mise à jour de la question ------

Merci pour vos réponses. Supposons cependant que nous devions résoudre fois un système , où est toujours la même matrice. Considérez queA x = b $n$$Ax = b$$A$

- $A$ est plein, et donc $A^{-1}$ nécessite la même mémoire de stockage que $A$ .

-Le nombre de conditions de $A$ est petit, donc $A^{-1}$ peut être calculé avec précision.

Dans ce cas, ne serait-il pas plus efficace de calculer $A^{-1}$ plutôt que d'utiliser une décomposition LU? Par exemple, j'ai essayé ce code Matlab:

%Set A and b:
M           = 1000; 
A           = rand(M,M);
A           = real(expm(1i*(A+A.')));
b           = rand(M,1);

%Times we solve the system:
n           = 3000;

%Performing LU decomposition:
disp('Performing LU decomposition')
tic
[L,U,P]     = lu(A);
toc
fprintf('\n')

%Solving the system n times with LU decomposition:
optsL.LT    = true;   %Options for linsolve
optsU.UT    = true;
disp('Solving the system n times using LU decomposition')
tic
for ii=1:n
    x1      = linsolve(U, linsolve(L,P*b,optsL) , optsU);
end
toc
fprintf('\n')

%Computing inverse of A:
disp('Computing inverse of A')
tic
Ainv        = inv(A);
toc
fprintf('\n')

%Solving the system n times with Ainv:
disp('Solving the system n times with A inv')
tic
for ii=1:n
    x2  = Ainv*b;
end
toc
fprintf('\n')

disp('Residuals')
disp(norm(b-A*x1))
disp(norm(b-A*x2))

disp('Condition number of A')
disp(cond(A))

Pour une matrice dont le nombre de conditions est d'environ 450, les résidus sont $O(10^{-11})$ dans les deux cas, mais il faut 19 secondes pour résoudre le système n fois en utilisant la décomposition LU, alors qu'en utilisant l'inverse de A, cela prend seulement 9 secondes.

Normalement, il y a quelques raisons principales de préférer résoudre un respect de système linéaire pour utiliser l'inverse. Brièvement:

• problème avec le numéro conditionnel (commentaire @GoHokies)
• problème dans le cas rare (réponse @ChrisRackauckas)
• efficacité (commentaire @Kirill)

Quoi qu'il en soit, comme l'a fait remarquer @ChristianClason dans les commentaires, il peut y avoir des cas où l'utilisation de l'inverse est une bonne option.

Dans la note / l'article d'Alex Druinsky, Sivan Toledo, How Accurate is inv (A) * b? il y a une certaine réflexion sur ce problème.

Selon l'article, la principale raison de la préférence générale pour résoudre le système linéaire est à l'intérieur de ces deux estimations ( est la vraie solution): $x$

Maintenant, l'estimation de l'inverse peut être améliorée, sous certaines conditions par rapport à l'inverse, voir le théorème 1 dans l'article, mais peut être conditionnellement précis et non stable en arrière.$x_V$

Le papier montre les cas où cela se produit ( est l'inverse)$V$

(1) n'est pas une bonne inverse droite, ou$V$

(2) est un mauvais inverse gauche tel queest beaucoup plus petit que, ou$V$$||x_V||$$||x||$

(3) la projection de sur les vecteurs singuliers gauches de associée à de petites valeurs singulières est petite.$b$$A$

Ainsi, la possibilité d'utiliser ou non l'inverse dépend de l'application, vous pouvez vérifier l'article et voir si votre cas remplit la condition pour obtenir la stabilité en arrière ou si vous n'en avez pas besoin.

En général, à mon avis, il est plus sûr de résoudre le système linéaire.

Voici un exemple rapide très pratique lié à l'utilisation de la mémoire dans les PDE. Quand on discrétise l'opérateur de Laplace, , par exemple, dans l'équation de chaleur$\Delta u$

$A$

$A$$I-\gamma A$SpecialMatrices.jl

julia> using SpecialMatrices
julia> Strang(5)
5×5 SpecialMatrices.Strang{Float64}:
 2.0  -1.0   0.0   0.0   0.0
-1.0   2.0  -1.0   0.0   0.0
 0.0  -1.0   2.0  -1.0   0.0
 0.0   0.0  -1.0   2.0  -1.0
 0.0   0.0   0.0  -1.0   2.0

$n$$\mathcal{O}(3n)$$\mathcal{O}(1)$

Cependant, disons que nous voulons inverser la matrice.

julia> inv(collect(Strang(5)))
5×5 Array{Float64,2}:
 0.833333  0.666667  0.5  0.333333  0.166667
 0.666667  1.33333   1.0  0.666667  0.333333
 0.5       1.0       1.5  1.0       0.5
 0.333333  0.666667  1.0  1.33333   0.666667
 0.166667  0.333333  0.5  0.666667  0.833333

$\mathcal{O}(n^2)$

\IterativeSolvers.jl$Ax=b$$A^{-1}$$A$

Comme d'autres l'ont mentionné, le numéro de condition et l'erreur numérique sont une autre raison, mais le fait que l'inverse d'une matrice clairsemée soit dense donne une idée très claire "c'est une mauvaise idée".