Les flottants en PHP 8

Pour écrire un flottant, vous pouvez utiliser la notation décimale, ou bien la notation scientifique 😃. Par exemple, vous pouvez écrire ce flottant en notation décimale 1234.5678 ou en notation scientifique 1.2345678E+3. Vous pouvez également insérer des tirets bas dans la partie entière. Si l'exposant est positif, vous pouvez omettre le signe, soit 1.2345678E3. Si l'exposant est négatif, vous devez impérativement mettre le signe.

Dans le script ci-dessous, regardez le \$a du premier echo (* il y en a aussi dans les suivants). Le backslash \ devant le dollar $ annule le sens spécial de ce $. Du coup, $a n'est pas substituée pas sa valeur 😉.

<?php /** * $a écrit en notation décimale * Remarquez le \ devant le $ dans le echo **/ $a = 1234.5678; echo "\$a => $a", '<br>'; /** * C'est possible d'insérer des tirets bas * Dans la partie entière **/ $a = 1_234.5678; echo "\$a => $a", '<br>'; /** * $a écrit en notation scientifique * AVEC le signe de l'exposant **/ $a = 1.2345678E+3; echo "\$a => $a", '<br>'; /** * $a écrit en notation scientifique * SANS le signe de l'exposant **/ $a = 1.2345678E3; echo "\$a => $a", '<br>'; // $b écrit en notation décimale $b = 0.0012345; echo "\$b => $b", '<br>'; /** * $b écrit en notation scientifique * Ici le signe moins est obligatoire **/ $b = 1.2345E-3; echo "\$b => $b", '<br>';

Maintenant, on va regarder quelques constantes prédéfinies, liées à l'utilisation des flottants. Comme pour les entiers, il y a une constante pour le plus petit flottant PHP_FLOAT_MIN et une constante pour le plus grand flottant PHP_FLOAT_MAX. Ensuite, il y a le nombre de chiffres (* nombre de digits) maximum possible pour l'affichage PHP_FLOAT_DIG et enfin une valeur PHP_FLOAT_EPSILON, qui représente l'erreur maximale que PHP peut faire sur la représentation d'un nombre flottant en machine. Des opérations arithmétiques non élémentaires peuvent donner des erreurs plus importantes que cette valeur 🤨.

<?php // Plus petit flottant sur cette machine echo "Min => ", PHP_FLOAT_MIN, '<br>'; // Plus grand flottant echo "Max => ", PHP_FLOAT_MAX, '<br>'; // Nb de digits max pour afffichage echo "Dig => ", PHP_FLOAT_DIG, '<br>'; // Erreur max de représentation du flottant en mémoire echo "Eps => ", PHP_FLOAT_EPSILON, '<br>'; Tester le code en PHP 7.3

Si vous voulez comparer deux flottants, il faut faire attention (* et c'est vrai dans tous les langages). Il y a cette fameuse erreur, de représentation des valeurs flottantes en mémoire. On va la mettre en évidence. Je prends un premier flottant qui vaut 1.0, et ensuite, un deuxième qui vaut la somme de 10 additions de 0.1. Alors, ces flottants sont égaux, sauf que si je les teste avec un test d'égalité, eh bien PHP, va me dire qu'ils ne sont pas égaux 🤭.

Un affichage avec un printf permet lui aussi de faire apparaître cette différence.

La solution, c'est de soustraire les deux flottants, ça fera apparaître cette petite erreur. Puis, il faut prendre la valeur absolue pour "enlever le signe". Et enfin, on vérifie que cette erreur est inférieure à une petite valeur 😄. Ici, j'ai choisi 1E-6. Ne prenez pas le PHP_FLOAT_EPSILON comme petite valeur. Comme je l'ai dit plus haut, c'est une erreur relative de représentation d'un flottant, mais les calculs peuvent donner une erreur plus grande que cette constante, c'est bien précisé dans la documentation (* voir l'avertissement).

<?php $first = 1.0; $second = 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1; // gettype retourne double pour des raisons historiques echo gettype($first), " => raison historique<br>"; echo is_float($first), " => c'est bien un float<br>"; // printf permet de faire apparaître une différence // %1.20f permet d'afficher le flottant avec 20 chiffres après la virgule printf("first => %1.20f<br>", $first); printf("second => %1.20f<br>", $second); /** * PHP ne les trouve pas égaux * C'est un pb classique de comparaison de flottants * Il y a des arrondis sur la représentation en mémoire des flottants * Et il y a donc des petites erreurs sur les calculs en virgule flottante **/ if ($first == $second) echo "Test égalité => Ils sont égaux<br>"; else echo "Test égalité => Ils ne sont pas égaux<br>"; /** * On peut toujours comparer la différence à une petite valeur * Là il va les trouver égaux. **/ if (abs($first - $second) <= 1E-6) echo "Par différence => Ils sont égaux<br>"; else echo "Par différence => Ils ne sont pas égaux<br>"; Tester le code en PHP 7.3

Il arrive que certains calculs soient impossibles à faire. C'est le cas d'une division de zéro par zéro. Dans ce cas, PHP en 7.3, vous le fait savoir en utilisant une valeur particulière NAN (Not A Number) alors que, PHP en 8.2, déclenche une erreur fatale 😉.

Il y a également deux valeurs particulières en PHP qui sont INF pour plus l'infini et -INF pour moins l'infini.

Si vous faites un cast d'un flottant vers un entier, alors PHP ne garde que la partie entière. La partie décimale est perdue. Donc attention ce n'est pas un arrondi 😉. Pour faire un arrondi, vous avez la fonction round.

<?php /** * Ha ça il ne sait pas faire. Moi non plus ! * PHP 7.3 vous retourne NAN pour une division de zéro par zéro * PHP 8.2 vous déclenche une erreur fatale **/ echo 0.0 / 0.0, '<br>'; /** * INF pour INFINITY **/ echo 1E3000, '<br>'; echo -1E3000, '<br>'; /** * Il est possible d'utiliser les valeurs -INF et INF * dans des expressions. */ if (10E100 < INF) echo "Je suis inférieur à plus l'infini<br>"; /** * Ce n'est pas un arrondi * PHP ne garde que la partie entière * La partie décimale est supprimée * Utiliser round https://www.php.net/manual/fr/function.round.php **/ $a = 1234.9; var_dump((int)$a); Tester le code en PHP 7.3