Navigating the Pitfalls of Floating-Point Inaccuracy in PHP

Inaccurate floating point numbers are a common problem in PHP. The answer is that it uses IEEE 754 double-precision format to make decimal decimals unable to be accurately represented; 1. 0.1 or 0.2 are infinite loop decimals in binary, and the computer needs to truncate the error; 2. When comparing floating point numbers, use tolerance instead of ==, such as abs($a - $b)

Floating-point arithmetic is a common source of confusion and subtle bugs in PHP — and in many programming languages. While PHP handles numbers dynamically, its underlying use of IEEE 754 double-precision floating-point format means that not all decimal numbers can be represented exactly . This leads to inaccuracies that can surprise developers, especially when doing financial calculations or comparisons.

Let's walk through the key pitfalls and practical strategies to manage floating-point inaccuracy in PHP.

1. Why Floating-Point Numbers Are Imprecise

Computers represent floating-point numbers in binary, but many decimal fractions (like 0.1 or 0.2 ) have infinite binary representations. For example:

 $a = 0.1 0.2;
echo $a; // Outputs: 0.3000000000000000004

This is not a PHP bug — it's how floating-point math works at the hardware level. The result is very close to 0.3 , but not exactly 0.3 .

This happens because:

• 0.1 in binary is a repeating fraction (like 1/3 in decimal).
• The computer must round it to fit into finite memory.
• These tiny rounding errors accumulate during arithmetic.

2. Never Use == to Compare Floating-Point Numbers

Direct equality checks often fail due to tiny precision errors:

 var_dump(0.1 0.2 == 0.3); // false!

Instead, use a tolerance (epsilon) to check if two floats are "close enough":

 function floatsEqual($a, $b, $epsilon = 0.00001) {
    return abs($a - $b) < $epsilon;
}

var_dump(floatsEqual(0.1 0.2, 0.3)); // true

Choose $epsilon based on your required precision. For financial apps, even 0.00001 might be too loose — consider working with integers (eg, cents) instead.

3. Avoid Floating-Point for Financial Calculations

Never store currency values like $10.99 as floats. Even small rounding errors can cause discrepancies in totals, taxes, or balances.

✅ Best practice: Use integers (cents) or strings with arbitrary precision libraries

 // Store in cents
$price1 = 1099; // $10.99
$price2 = 250; // $2.50
$total = $price1 $price2; // 1349 cents = $13.49

Or use PHP's BC Math or GMP extensions for arbitrary precision:

 // Using BC Math
echo bcadd('0.1', '0.2', 2); // '0.30'
echo bcmul('1.25', '3.10', 2); // '3.87'

BC Math functions treat numbers as strings and perform exactly decimal arithmetic — ideal for money.

4. Be Cautious When Converting to Integers

Casting floats to integers truncates, and improvement can lead to off-by-one errors:

 $float = 0.99 * 100; // Should be 99
echo (int)$float; // Might print 98!

Why? Because 0.99 * 100 might evaluate to 98.99999999999999 .

✅ Fix: Round before casting

 echo (int)round(0.99 * 100); // 99

Always use round() when converting floats to integers for accuracy.

5. Watch Out for String Formatting and Display

Sometimes, the number is accurate enough, but formatting exposes floating-point noise:

 printf("%.20f", 0.1 0.2);
// 0.300000000000000004441

Use number_format() or sprintf() to round for display:

 echo number_format(0.1 0.2, 2); // "0.30"

But remember: formatting only affects output — it doesn't fix underlying precision issues in calculations.

Summary of Best Practices

• ✅ Use bcadd() , bcsub() , bcmul() , bcdiv() for financial math.
• ✅ Compare floats with a small tolerance, not == .
• ✅ Store currency in cents (integers) when possible.
• ✅ Always round() before casting floats to integers.
• ✅ Format output with number_format() to hide floating-point noise.
• ❌ Never rely on exact float equality.

Floating-point inaccuracy isn't unique to PHP, but ignoring it can lead to real-world bugs. By understanding the limits of binary floating-point and using the right tools — especially BC Math and integer-based arithmetic — you can avoid most pitfalls.

Basically: don't let floats handle money, and never trust exactly equality .

The above is the detailed content of Navigating the Pitfalls of Floating-Point Inaccuracy in PHP. For more information, please follow other related articles on the PHP Chinese website!