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é.
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 Addbccomp 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="<🎜 sous Linux bc >
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 JSNumé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 ?>
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!