0.1 0.2 !== 0.3 in PHP due to binary floating-point precision limitations, so developers must avoid direct comparisons and use epsilon-based checks, employ BCMath or GMP for exact arithmetic, store currency in integers when possible, format output carefully, and never rely on float precision for financial calculations.

When working with numbers in PHP, especially in financial or scientific calculations, developers often run into subtle but serious issues caused by floating-point precision. While PHP handles integers and strings predictably, floating-point arithmetic can produce results that seem wrong at first glance—like 0.1 0.2 !== 0.3. This isn't a bug in PHP; it's a consequence of how computers represent decimal numbers in binary.

Let’s break down the perils of floating-point precision in PHP and how to handle them properly.

Why Floating-Point Math Goes Wrong

Floating-point numbers in PHP (like in most programming languages) follow the IEEE 754 standard for binary representation. The problem arises because many decimal fractions cannot be represented exactly in binary.

For example:

var_dump(0.1   0.2); // float(0.30000000000000004)
var_dump(0.1   0.2 == 0.3); // bool(false)

This happens because 0.1 and 0.2 are repeating fractions in binary, just like 1/3 is 0.333... in decimal. When stored in finite memory (64 bits for a double), they get rounded, leading to tiny inaccuracies.

These rounding errors accumulate and can cause:

• Incorrect comparisons
• Unexpected results in calculations
• Bugs in financial applications (e.g., incorrect totals)

Don’t Use Direct Equality Comparisons

One of the most common mistakes is comparing floating-point numbers with == or ===.

// ? Dangerous
if (0.1   0.2 == 0.3) {
    echo "Equal"; // This won't execute
}

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

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

if (floatsEqual(0.1   0.2, 0.3)) {
    echo "Effectively equal"; // This will execute
}

Choose $epsilon based on your application’s required precision. For money, 0.0001 is often sufficient.

Use BCMath or GMP for Exact Arithmetic

When precision is critical—like in financial calculations—avoid floating-point numbers entirely. PHP provides BCMath and GMP extensions for arbitrary precision arithmetic.

BCMath: Arbitrary Precision Decimal Math

BCMath works with numbers as strings and supports addition, subtraction, multiplication, division, etc., with exact precision.

// Example: 0.1   0.2 = 0.3, exactly
$result = bcadd('0.1', '0.2', 1); // '0.3'

Note: All operands must be strings, and you specify the scale (number of decimal places).

More examples:

echo bcmul('0.1', '0.2', 2); // '0.02'
echo bcdiv('1.0', '3.0', 5);  // '0.33333'

BCMath is ideal for:

• Currency calculations
• Tax, interest, or invoice totals
• Any situation where rounding errors are unacceptable

GMP: Integer-Based High-Precision Math

GMP is more efficient for large integers but works best when you can scale values (e.g., store cents instead of dollars).

$amount1 = gmp_init(10); // 10 cents
$amount2 = gmp_init(20); // 20 cents
$total = gmp_add($amount1, $amount2); // 30 cents
echo gmp_strval($total); // "30"

This avoids decimals entirely—common in payment systems.

Formatting and Display Issues

Even if internal calculations are correct, displaying floats can mislead:

echo 0.29 * 100; // Might show 28.999999999999996

Use number_format() or printf() to control output:

echo number_format(0.29 * 100, 2); // "29.00"

But remember: formatting only affects display, not the underlying value.

Best Practices Summary

To avoid floating-point pitfalls in PHP:

• ? Never compare floats directly—use an epsilon.
• ? Use BCMath for financial or high-precision decimal math.
• ? Store currency in cents (integers) when possible.
• ? Validate and round input values intentionally.
• ? Be cautious with type juggling—PHP might silently convert strings to floats.

Example of safe money handling:

// Add two amounts in cents using BCMath
function addMoney($a, $b) {
    return bcadd($a, $b, 0); // No decimal places for cents
}

$totalCents = addMoney('150', '250'); // '400' cents = $4.00

Floating-point numbers are useful for scientific or approximate calculations, but they’re a poor fit for exact arithmetic. In PHP, the key is knowing when to step outside the default float behavior and use tools like BCMath to preserve accuracy.

Basically: if precision matters, don’t trust the decimal point—take control of it.

The above is the detailed content of The Perils of Precision: Handling Floating-Point Numbers in PHP. For more information, please follow other related articles on the PHP Chinese website!