Comment fonctionne l'approximation de l'égalité Matlab?

Question

Dans le code suivant, j'ai suivi une procédure pour créer une matrice définie positive aléatoire P.

Au début, je créé une décomposition de valeurs singulières [U, S, V] d'un tableau aléatoire A et je suis en train de vérifier que, en fait, U '* U == U * U' = I (où I est la matrice d'identité) qui est connue de la théorie. Le problème est que si je vérifie moi-même le contenu des matrices, je peux vérifier cela, mais Matlab produit une matrice logique qui ne vérifie pas que zéro étant représenté par -0.000 ou 0.0000 donc le résultat est 1 seulement si les signes correspondent. Pourquoi donc?

Mais le plus gros problème se pose en quelques lignes en dessous, où le défini positif (toutes ses valeurs propres sont positives) la matrice P est produit et je veux simplement vérifier que P = P ». En cliquant sur x et y, je peux voir que leur contenu est exactement le même mais Matlab ne peut pas le vérifier non plus. Je ne comprends pas pourquoi cela se passe puisque dans ce cas nous parlons ici de la même variable P ici qui est simplement transposée.

Voici le code:

%Dimension of the problem 
n = 100; 

%Random matrix A 
A = rand(n, n)*10 - 5; 

%Singular value decomposition 
[U, S, V] = svd(A); 

%Verification that U*U'=U'*U=I 
U'*U == U*U' 

%Minimum eigenvalue of S 
l_min = min(diag(S)); 

%Maximum eigenvalue of S 
l_max = max(diag(S)); 

%The rest of the eigenvalues are distributed randomly between the minimum 
%and the maximum value 
z = l_min + (l_max - l_min)*rand(n - 2, 1); 

%The vector of the eigenvalues 
eig_p = [l_min; l_max; z]; 

%The Lambda diagonal matrix 
Lambda = diag(eig_p); 

%The P matrix 
P = U*Lambda*U'; 

%Verification that P is positive definite 
all(eig(P) > 0) 

%Verification that P=P' 
x=P; 
y=P'; 
x==y 

Answer 1

Votre problème n'est pas 0 est représentée comme -0.000 ou 0.0000 (vous pouvez vérifier cela en exécutant (-0) == 0), mais plutôt que les valeurs sont en fait vraiment petit (par rapport aux autres nombres dans la matrice). Opérations comme ce que vous faites aura toujours de petites erreurs de la façon dont les nombres à virgule flottante sont représentés et manipulés.

Au lieu de vérifier que P=P', essayez de vérifier que abs(P-P') < 0.000000001, ou quel que soit le seuil est approprié pour vous donné l'application.