Les nombres à virgule flottante (aussi connus comme "floats",
"doubles", ou "nombres réels")
peuvent être spécifiés en utilisant les syntaxes suivantes :
<?php
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
$d = 1_234.567; // à partir de PHP 7.4.0
?>Formellement à partir de PHP 7.4.0 (auparavant, les underscores n'étaient pas autorisé) :
LNUM [0-9]+(_[0-9]+)*
DNUM ({LNUM}?"."{LNUM}) | ({LNUM}"."{LNUM}?)
EXPONENT_DNUM (({LNUM} | {DNUM}) [eE][+-]? {LNUM})
La taille d'un nombre décimal est dépendante de la plate-forme, cependant, un nombre maximal d'environ 1.8e308 avec une précision sur 14 chiffres est une valeur commune (format 64 bits IEEE).
Les nombres flottants ont une précision limitée. Même s'ils dépendent du système, PHP utilise le format de précision des décimaux IEEE 754, qui donnera une erreur maximale relative de l'ordre de 1.11e-16 (dûe aux arrondis). Les opérations arithmétiques non-élémentaires peuvent donner des erreurs plus importantes et bien sûr les erreurs doivent être prises en compte lorsque plusieurs opérations sont liées.
Aussi, les nombres rationnels exactement représentables sous forme de nombre à virgule
flottante en base 10, comme 0.1 ou 0.7, n'ont pas
de représentation exacte comme nombres à virgule flottante en base 2, utilisée en
interne, et ce quelle que soit la taille de la mantisse. De ce fait, ils ne peuvent
être convertis sans une petite perte de précision. Ceci peut mener à des résultats
confus: par exemple, floor((0.1+0.7)*10) retournera normalement
7 au lieu de 8 attendu, car la représentation
interne sera quelque chose comme 7.9999999999999991118....
Ainsi, ne faites jamais confiance aux derniers chiffres d'un nombre flottant, mais aussi, ne comparez pas l'égalité de 2 nombres flottant directement. Si une plus grande précision est nécessaire, les fonctions mathématiques de précision arbitraire et les fonctions gmp sont disponibles.
Pour une explication "simple", voir le » guide relatif aux nombres à virgule flottante.
Si une chaîne est
numérique
ou numérique de tête alors elle sera transformée en sa valeur flottante
correspondante, sinon elle sera convertie à zéro(0).
Pour les valeurs d'autres types, la conversion est effectuée en convertissant la valeur d'abord en int puis en float. Voir conversion en entier pour plus d'informations.
Note:
Comme certains types ont un comportement indéfinie lors de la conversion en int, ceci est aussi le cas lors de la conversion en float.
Comme dit dans la note ci-dessus, le test d'égalité des valeurs de nombres flottants est problématique, en raison de la façon dont ils sont représentés en interne. Cependant, il existe des façons de réaliser cette comparaison.
Pour tester l'égalité de valeurs de nombres flottants, une borne supérieure
de l'erreur relative à l'arrondi est utilisée. Cette valeur est connue
comme étant l'epsilon de la machine, ou le unit roundoff,
et est la différence la plus petite acceptable dans les calculs.
$a et $b sont égaux sur 5 nombres après la virgule.
Exemple #1 Comparaison de nombres flottants
<?php
$a = 1.23456789;
$b = 1.23456780;
$epsilon = 0.00001;
if( abs($a - $b) < $epsilon) {
echo "true";
}
?>
Quelques opérations numériques peuvent donner comme résultat une valeur
représentée par la constante NAN. Ce résultat représente
une valeur indéfinie ou non représentable lors de calculs avec des nombres
à virgule flottante. Toute comparaison, même stricte de cette valeur avec
une autre valeur, y compris cette constante elle-même, sauf si elle est
égale à true, donnera une valeur de false.
En raison du fait que NAN représente tout nombre de valeurs
différentes, NAN ne doit pas être comparé à d'autres valeurs,
y compris cette constante elle-même, et à la place, elle doit être vérifiée
en utilisant la fonction is_nan().
$x = 8 - 6.4; // which is equal to 1.6
$y = 1.6;
var_dump($x == $y); // is not true
PHP thinks that 1.6 (coming from a difference) is not equal to 1.6. To make it work, use round()
var_dump(round($x, 2) == round($y, 2)); // this is true
This happens probably because $x is not really 1.6, but 1.599999.. and var_dump shows it to you as being 1.6.General computing hint: If you're keeping track of money, do yourself and your users the favor of handling everything internally in cents and do as much math as you can in integers. Store values in cents if at all possible. Add and subtract in cents. At every operation that wii involve floats, ask yourself "what will happen in the real world if I get a fraction of a cent here" and if the answer is that this operation will generate a transaction in integer cents, do not try to carry fictional fractional accuracy that will only screw things up later.just a comment on something the "Floating point precision" inset, which goes: "This is related to .... 0.3333333."
While the author probably knows what they are talking about, this loss of precision has nothing to do with decimal notation, it has to do with representation as a floating-point binary in a finite register, such as while 0.8 terminates in decimal, it is the repeating 0.110011001100... in binary, which is truncated. 0.1 and 0.7 are also non-terminating in binary, so they are also truncated, and the sum of these truncated numbers does not add up to the truncated binary representation of 0.8 (which is why (floor)(0.8*10) yields a different, more intuitive, result). However, since 2 is a factor of 10, any number that terminates in binary also terminates in decimal.I'd like to point out a "feature" of PHP's floating point support that isn't made clear anywhere here, and was driving me insane.
This test (where var_dump says that $a=0.1 and $b=0.1)
if ($a>=$b) echo "blah!";
Will fail in some cases due to hidden precision (standard C problem, that PHP docs make no mention of, so I assumed they had gotten rid of it). I should point out that I originally thought this was an issue with the floats being stored as strings, so I forced them to be floats and they still didn't get evaluated properly (probably 2 different problems there).
To fix, I had to do this horrible kludge (the equivelant of anyway):
if (round($a,3)>=round($b,3)) echo "blah!";
THIS works. Obviously even though var_dump says the variables are identical, and they SHOULD BE identical (started at 0.01 and added 0.001 repeatedly), they're not. There's some hidden precision there that was making me tear my hair out. Perhaps this should be added to the documentation?To compare two numbers use:
$epsilon = 1e-6;
if(abs($firstNumber-$secondNumber) < $epsilon){
// equals
}In some cases you may want to get the maximum value for a float without getting "INF".
var_dump(1.8e308); will usually show: float(INF)
I wrote a tiny function that will iterate in order to find the biggest non-infinite float value. It comes with a configurable multiplicator and affine values so you can share more CPU to get a more accurate estimate.
I haven't seen better values with more affine, but well, the possibility is here so if you really thing it's worth the cpu time, just try to affine more.
Best results seems to be with mul=2/affine=1. You can play with the values and see what you get. The good thing is this method will work on any system.
<?php
function float_max($mul = 2, $affine = 1) {
$max = 1; $omax = 0;
while((string)$max != 'INF') { $omax = $max; $max *= $mul; }
for($i = 0; $i < $affine; $i++) {
$pmax = 1; $max = $omax;
while((string)$max != 'INF') {
$omax = $max;
$max += $pmax;
$pmax *= $mul;
}
}
return $omax;
}
?>Be careful when using float values in strings that are used as code later, for example when generating JavaScript code or SQL statements. The float is actually formatted according to the browser's locale setting, which means that "0.23" will result in "0,23". Imagine something like this:
$x = 0.23;
$js = "var foo = doBar($x);";
print $js;
This would result in a different result for users with some locales. On most systems, this would print:
var foo = doBar(0.23);
but when for example a user from Germany arrives, it would be different:
var foo = doBar(0,23);
which is obviously a different call to the function. JavaScript won't state an error, additional arguments are discarded without notice, but the function doBar(a) would get 0 as parameter. Similar problems could arise anywhere else (SQL, any string used as code somewhere else). The problem persists, if you use the "." operator instead of evaluating the variable in the string.
So if you REALLY need to be sure to have the string correctly formatted, use number_format() to do it!Since actual values can vary slightly, $epsilon may not be set according to your configuration. You can replace $epsilon with PHP_FLOAT_EPSILON. There is also, in my opinion, a more elegant method for checking float equality:
<?php
// bccomp will returns 0 for equality, 1 if $value1 is greater and -1 otherwise
if (bccomp($value1, $value2) == 0) {
// equals
}
?>Since actual values can vary slightly, $epsilon may not be set according to your configuration. You can replace $epsilon with PHP_FLOAT_EPSILON. There is also, in my opinion, a more elegant method for checking float equality:
bccomp($value1, $value2) == 0 // bccomp will returns 0 for equality, 1 if $value1 is greater and -1 otherwiseConcider the following:
(19.6*100) != 1960
echo gettype(19.6*100) returns 'double', However even .....
(19.6*100) !== (double)1960
19.6*100 cannot be compaired to anything without manually
casting it as something else first.
(string)(19.6*100) == 1960
Rule of thumb, if it has a decimal point, use the BCMath functions.The 'floating point precision' box in practice means:
<? echo (69.1-floor(69.1)); ?>
Think this'll return 0.1?
It doesn't - it returns 0.099999999999994
<? echo round((69.1-floor(69.1))); ?>
This returns 0.1 and is the workaround we use.
Note that
<? echo (4.1-floor(4.1)); ?>
*does* return 0.1 - so if you, like us, test this with low numbers, you won't, like us, understand why all of a sudden your script stops working, until you spend a lot of time, like us, debugging it.
So, that's all lovely then.<?php
$binarydata32 = pack('H*','00000000');
$float32 = unpack("f", $binarydata32); // 0.0
$binarydata64 = pack('H*','0000000000000000');
$float64 = unpack("d", $binarydata64); // 0.0
?>
I get 0 both for 32-bit and 64-bit numbers.
But, please don't use your own "functions" to "convert" from float to binary and vice versa. Looping performance in PHP is horrible. Using pack/unpack you use processor's encoding, which is always correct. In C++ you can access the same 32/64 data as either float/double or 32/64 bit integer. No "conversions".
To get binary encoding:
<?php
$float32 = pack("f", 5300231);
$binarydata32 =unpack('H*',$float32); //"0EC0A14A"
$float64 = pack("d", 5300231);
$binarydata64 =unpack('H*',$float64); //"000000C001385441"
?>
And my example from half a year ago:
<?php
$binarydata32 = pack('H*','0EC0A14A');
$float32 = unpack("f", $binarydata32); // 5300231
$binarydata64 = pack('H*','000000C001385441');
$float64 = unpack("d", $binarydata64); // 5300231
?>
And please mind the Big and Little endian boys...