Php floating-point rounding error ... how can I make sure it works correctly?

Question

I have the following function that determines if the sale is fully paid. I don’t remember why I did it this way, but it still works, and I don’t remember why I had to do it.

function _payments_cover_total() { //get_payments is a list of payment amounts such as: //10.20, 10.21, or even 10.1010101101 (10 decimals max) $total_payments = 0; foreach($this->sale_lib->get_payments() as $payment) { $total_payments += $payment['payment_amount']; } //to_currency_no_money rounds total to 2 decimal places if (to_currency_no_money($this->sale_lib->get_total()) - $total_payments ) > 1e-6 ) ) { return false; } return true; } 

I am wondering if there is ever a case where, due to a rounding error, this function will return false if it is not.

The main part I'm asking about is:

  > 1e-6 

I think sooner than before, but in some cases this caused problems.

 > 0 

Answer 1

I think you are doing what is mentioned on the php help page. To quote it directly:

To check the floating point values ​​for equality, the upper bound uses a relative error due to rounding. This value is known as machine epsilon or rounding, and is the smallest acceptable difference in calculation.

 $a and $b are equal to 5 digits of precision. <?php $a = 1.23456789; $b = 1.23456780; $epsilon = 0.00001; if(abs($a-$b) < $epsilon) { echo "true"; } ?> 

So in your case:

(to_currency_no_money($this->sale_lib->get_total()) - $total_payments) > 1e-6

the relative error due to rounding should not exceed 1e-6 or 0.000001

if you are not sure that the left operand is more than the right 100% of the time, then you should add abs() for example, for correctness.

 $relative_error=to_currency_no_money($this->sale_lib->get_total()) - $total_payments; if(abs($relative_error) > 1e-6){ return false } return true; 

Answer 2

 $x = (1.333-1.233)-(1.334-1.234); echo $x; //result = $x = -2.2204460492503E-16 - close to zero //but (1.333-1.233)-(1.334-1.234) = 0.1 - 0.1 = 0 (in calculator) if($x === 0){ echo "|zero"; } else { echo "|non zero"; //<== this is result } //screen = -2.2204460492503E-16|non zero //how to get to zero? if($x > 1e-6){//1e-6 mathematical constant echo "|non zero"; } else { echo "|zero";//this is result } //screen -2.2204460492503E-16|non zero|zero if ($x > 1e-6 ) { echo " false"; //echo "|non zero"; //return false; } else{ echo " true";//<== this resut //echo "|zero"; //return true; } //screen -2.2204460492503E-16|non zero|zero true printf("%.1f<br />", 1e-1); printf("%.2f<br />", 1e-2); printf("%.3f<br />", 1e-3); printf("%.4f<br />", 1e-4); printf("%.5f<br />", 1e-5); printf("%.6f<br />", 1e-6); printf("%.7f<br />", 1e-7); printf("%.8f<br />", 1e-8); printf("%.9f<br />", 1e-9); printf("%.10f<br />", 1e-10); printf("%.11f<br />", 1e-11); printf("%.12f<br />", 1e-12); printf("%.29f<br />", -2.2204460492503E-16); //0.1 //0.01 //0.001 //0.0001 //0.00001 //0.000001 //0.0000001 //0.00000001 //0.000000001 //0.0000000001 //0.00000000001 //0.000000000001 //-0.00000000000000022204460492503 

Answer 3

Sorry, but when you are dealing with currency, you should not use PHP floats as specified in IMSoP. The reason is also in the PHP float man pages:

In addition, rational numbers that are accurately represented as floating point numbers in base 10, such as 0.1 or 0.7, do not have an exact representation as floating point numbers in base 2, which is used internally, regardless of the size of the mantissa. Therefore, they cannot be converted to their internal binary copies without a slight loss of accuracy. This can lead to confusing results: for example, gender ((0.1 + 0.7) * 10) usually returns 7 instead of expected 8, since the internal representation will be something like +7.9999999999999991118 ....

Therefore, never trust the action of floating-point numbers to the last digit, and do not compare floating-point numbers directly for equality. If accuracy is needed above, arbitrary precision mathematical functions and gmp functions are available.

Please note that the help page indicates that you cannot trust floating point results to the last digit, no matter how short (after the decimal point) it is .

Therefore, when you have very short floats (only 2 digits after the decimal point), the accuracy of the float (1e-6) is not really included in it, and you cannot trust them 100%.

Since it is about money, to avoid angry clients and lawsuits accusing of penis shaving ( https://en.wikipedia.org/wiki/Salami_slicing ), the real solutions are:

1) either use PHP BC math, which works with the string representation of numbers http://php.net/manual/en/book.bc.php

2) at the suggestion of IMSoP, use integers and keep the amounts in the lowest denomination (cents, euro cents or whatever you have) inside.

The first solution may be a bit more saturated resource: I didn’t use BC math very much, but storing strings and doing arbitrary precision math (which in this case can be a bit overwhelmed), by definition, has more RAM and the CPU is intensive than working with integers .

This may, however, require smaller changes in other parts of the code.

The second solution requires changes in the presentation, so that wherever the user sees the amounts, they are normalized to dollars, cents (or whatever you have).

Please note, however, that in this case you are also triggering problems with rounding risks at some point, for example:

 float shown_amount; // what we show to customer: in dollars,cents int real_amount; // what we use internally: in cents shown_amount = cent_amount / 100; 

you can reuse rounding problems as you are swimming again, and opportunities for rounding errors, so be careful and remember to perform calculations and rounding only on real_amount, never on show_amount