Explication graphique détaillée de la méthode de comparaison des nombres à virgule flottante PHP

Cet article présente principalement la méthode de comparaison de nombres à virgule flottante PHP, qui a une bonne valeur de référence. Jetons-y un coup d'œil avec l'éditeur ci-dessous

Le problème de précision des opérations sur les nombres à virgule flottante

Regardons d'abord un exemple :

<?php
$a = 0.1;
$b = 0.9;
$c = 1;
var_dump(($a+$b)==$c);
var_dump(($c-$b)==$a);
?>

$a+$b==$c renvoie vrai, correct
$c-$b==$a renvoie faux, erreur

Pourquoi cela se produit-il ?

Après l'opération, le contenu effectivement renvoyé lorsque la précision est de 20 chiffres est le suivant :

<?php
$a = 0.1;
$b = 0.9;
$c = 1;
printf("%.20f", $a+$b); // 1.00000000000000000000
printf("%.20f", $c-$b); // 0.09999999999999997780
?>

$c-$b est 0,099999999999999997780, donc la comparaison avec 0,1 renvoie faux

Ce problème se produit car le calcul en virgule flottante implique de la précision, et il peut y avoir des erreurs lorsque le le nombre à virgule flottante est converti en binaire, entraînant une perte de précision.

Méthode de conversion des nombres à virgule flottante

La partie entière adopte divisé par 2 pour prendre le resteméthode

La partie décimale est arrondie selon la méthode multipliée par 2

Par exemple : Convertir le nombre 8,5 en binaire

La partie entière est 8

8/2=4 8%2=0
4/2=2 4%2=0
2/2=1 2%2=0

1 est plus petit que 2, il n'est donc pas nécessaire de le calculer. Le système binaire de l'entier 8 est . 1000

La partie décimale est 0,5

0,5x2 = 1,0

Parce que la partie décimale est 0 après arrondi, il n'y a plus besoin de calculer

Décimal Le système binaire de 0,5 est 0,1 >

0,9x2=1,8 0,8x2=1,6 0,6x2=1,2 0,2x2=0,4 0,4x2=0,8

0,8x2=1,6

…. Après cela, la boucle continue Lorsque la précision d'interception est N, le nombre après N sera arrondi. , ce qui entraîne une perte de précision. Dans l'exemple ci-dessus, la précision de 0,9 est perdue lors de la conversion en binaire, ce qui entraîne des erreurs lors de la comparaison.

Ne croyez donc jamais qu'un nombre à virgule flottante est précis jusqu'au dernier chiffre, et ne comparez jamais deux nombres à virgule flottante pour vérifier leur égalité.

Comment comparer correctement les nombres à virgule flottante

Utilisez la méthode ronde pour traiter puis comparer Exemple :

2. méthodes de fonctionnement de précision

Lorsque vous effectuez d'abord les calculs, utilisez des méthodes de calcul de haute précision pour garantir que la précision n'est pas perdue.

<?php
$a = 0.1;
$b = 0.9;
$c = 1;
var_dump(($c-$b)==$a);          // false
var_dump(round(($c-$b),1)==round($a,1)); // true
?>

La méthode de fonctionnement de haute précision est la suivante :

bcadd

Convertir deux nombres de haute précision Add

bccomp Compare deux nombres de haute précision et renvoie -1,0,1

bcp Diviser deux nombres de haute précision

bcmod Trouver le reste d'un nombre de haute précision

bcmul Multipliez deux nombres de haute précision

bcpow Trouvez la puissance d'un nombre de haute précision

bcpowmod Trouver le module de la puissance des nombres de haute précision

bcscale Configurer le nombre de décimales par défaut , ce qui équivaut à "scale="

bcsqrt Trouver la racine carrée d'un nombre de haute précision

bcsub Soustraire deux nombres de haute précisionExemple :

Recommandations associées :

Explication détaillée de JS

Numéro à virgule flottante
Traitement des opérations (tutoriel graphique)

<?php
$a = 0.1;
$b = 0.9;
$c = 1;
var_dump(($c-$b)==$a);     // false
var_dump(bcsub($c, $b, 1)==$a); // true
?>

Implémentation Javascript pour trouver la racine carrée du

Nombre à virgule flottante
Explication détaillée

Exemple de partage de résolution du fonctionnement inexact de virgule flottante en PHP

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!