PHP rounding error with simple multiplication

Question

PHP seems to round incorrectly when using (int) to cast variables. Why?

$multiplier = 100000000;
$value = 0.01020637;
echo (int)($value*$multiplier);

Output: 1020636. (unexpected output)

$multiplier = 100000000;
$value = 0.01020637;
echo ($value*$multiplier);

Output: 1020637. (Expected correct output)

Edit: it gets even worse...

$multiplier = 100000000;
$value = 0.01020637;
echo $temp = ($value*$multiplier);
echo '<br/>';
echo (int)$temp;

Output:

1020637

1020636

Answer 1

Things can get hairy when you're dealing with floats, floating point math (and problems involved) are well understood, but can crop up when you're not expecting them. As seems to have happened here. You could read up on the rules extensively, or use language provided tools when handling floating point arithmetic.

When you care about the precision involved you should use the bcmul() function. It's an "optional" extension, but if you care about precision it starts being required rather quickly.

Example:

multiplier = 100000000;
$value = 0.01020637;
echo (int)($value*$multiplier);
echo "\n";
echo bcmul($value, $multiplier, 0);

Sample: http://ideone.com/Wt9kKb

Answer 2

PHP (especially in 32 bit builds) has problems with floating point numbers. This is why casting float into int can have unpredictable results. See PHP Integer page for more detail. Basically, you're getting tiny imprecisions in the math and that can cause serious problems when trying to do something like ceil()

If you really need the numbers converted to int I would suggest you round the numbers first

$multiplier = 100000000;
$value = 0.01020637;
$temp = round($value*$multiplier);
echo $temp . '<br/>' . (int)$temp;

This works by truncating off the small floating point errors. While bcmath can also do the truncation, it's not part of PHP core and not a good overall solution. Your best bet is to write a rounding routine yourself that can return the precision you're looking for. In the project I work on, that was what we did. We wrote our own rounding function and it fixes the problems you'll run into. Without knowing the specifics of what you're trying to do it's hard to say if that's what you need but it's how we did it without bcmath.

Answer 3

The problem you're seeing is the following: When multiplying two numbers like this:

$mulitply = 0.1 * 100;

You are not multiplying exactly 100 with 0.1, but with with 0.09999999998... And when it comes to (int), it converts numbers like 4.999 to 4, so your result 1020636.999999999 becomes 1020636 when counting with (int).

Answer 4

bcmul allows for higher precision

$test =  (int) bcmul('100000000', '0.01020637');
echo $test

returns the correct answer.

Answer 5

To round floats in PHP you should use the round() function. Just casting to an integer does not round the value correctly.

First argument is which float (the result of your calculation in this case) to be rounded, second is optional, and specifies the amount of decimals (aka precision) being returned. There is also a third argument, controlling the mode. These can be PHP_ROUND_HALF_UP, PHP_ROUND_HALF_DOWN, PHP_ROUND_HALF_EVEN or PHP_ROUND_HALF_ODD.

Example from php.net/round:

<?php
    echo round(3.4);         // 3
    echo round(3.6);         // 4
    echo round(3.6, 0);      // 4
    echo round(1.95583, 2);  // 1.96

    // With the third element, "mode"
    echo round(9.5, 0, PHP_ROUND_HALF_UP);   // 10
    echo round(9.5, 0, PHP_ROUND_HALF_DOWN); // 9
    echo round(9.5, 0, PHP_ROUND_HALF_EVEN); // 10
    echo round(9.5, 0, PHP_ROUND_HALF_ODD);  // 9
?>

An example for your code (live example):

<?php
    $multiplier = 100000000;
    $value = 0.01020637;
    echo intval(round($value*$multiplier)); // Returns 1020637
?>