PHP Floating-Point Numbers

last modified April 1, 2025

PHP uses a platform-dependent floating-point type based on IEEE 754, typically 64-bit doubles. This guide explores its properties, precision challenges, and best practices for effective numerical operations in PHP applications.

PHP Float Overview

This section introduces PHP's float type, a key numeric type for decimal values. It follows IEEE 754, usually as a 64-bit double, depending on the system. Understanding its range and precision is vital for accurate computations. The example below demonstrates basic usage and its limits in PHP. This knowledge helps developers manage floating-point quirks effectively.

<?php

// Float declarations
$singleFloat = 1.2345678901234567;
$smallFloat = 5.0E-324;
$largeFloat = 1.7976931348623157E308;

echo "Float: $singleFloat\n";
echo "Smallest positive: $smallFloat\n";
echo "Largest: $largeFloat\n";

echo "\nPHP_FLOAT_MIN: " . PHP_FLOAT_MIN . "\n";
echo "PHP_FLOAT_MAX: " . PHP_FLOAT_MAX . "\n";
echo "Size in bytes: " . 8 . "\n"; // Typically 64-bit

// Additional example: Scientific notation
$sciFloat = 1.23E-10;
echo "\nScientific notation: $sciFloat\n";

PHP's float type is a floating-point number adhering to IEEE 754, typically a 64-bit double on modern systems, though its size can vary by platform. It provides 15-17 significant decimal digits and a range from ±5.0×10⁻³²⁴ (codePHP_FLOAT_MIN) to ±1.7976931348623157×10³⁰⁸ (PHP_FLOAT_MAX), stored in 8 bytes usually.

Unlike languages with multiple numeric types, PHP uses float for all non-integer numbers, with no distinct decimal type, balancing simplicity and flexibility. This means precision issues, like those with 0.1 + 0.2, are common and need careful handling. Scientific notation (e.g., 1.23E-10) is supported, making it easy to work with very small or large values.

Precision and Rounding

Precision in PHP floats can lead to surprises due to their binary representation. This section shows how decimal fractions cause errors and how PHP mitigates them. Examples use built-in functions to control rounding effectively. Mastering these tools ensures reliable numeric results in PHP scripts. It's essential for avoiding subtle calculation bugs.

<?php

// Precision demonstration
$a = 0.1;
$b = 0.2;
$sum = $a + $b;

echo "0.1 + 0.2 = $sum\n";
echo "0.1 + 0.2 == 0.3? " . ($sum == 0.3 ? 'true' : 'false') . "\n";
echo "Full precision: " . sprintf("%.17f", $sum) . "\n";

$value = 2.34567;
echo "\nRounding examples:\n";
echo "round($value): " . round($value) . "\n";
echo "floor($value): " . floor($value) . "\n";
echo "ceil($value): " . ceil($value) . "\n";
echo "round to 2 decimals: " . round($value, 2) . "\n";

// Additional example: Pi rounding
$pi = 3.14159;
echo "\nPi to 3 digits: " . round($pi, 3) . "\n";

PHP floats, being binary-based per IEEE 754, can't precisely represent decimals like 0.1 or0.2, so 0.1 + 0.2 equals 0.30000000000000004, not 0.3, as seen with sprintf("%.17f"). These errors can compound in loops or repeated math, requiring careful precision management in code.

PHP offers round for nearest value (with optional precision), floor to round down, and ceil to round up, all returning floats. For instance, round(2.34567, 2) gives 2.35, ideal for display or controlled precision, unlike string-based alternatives in other languages. Adjust the php.ini precision setting (default 14) or use formatting to control output as needed.

Comparing Floating-Point Values

Comparing floats in PHP demands caution due to inherent precision inaccuracies. Direct equality checks often fail, so this section provides a safer comparison method. It also addresses special values like NaN and infinity in PHP's context. The example clarifies these issues with practical PHP solutions. This ensures dependable comparison logic in your scripts.

<?php

function nearlyEqual($a, $b, $epsilon = 1E-10) {
    $absA = abs($a);
    $absB = abs($b);
    $diff = abs($a - $b);

    if ($a == $b) return true;
    if ($a == 0 || $b == 0 || $diff < PHP_FLOAT_EPSILON)
    {
        return $diff < ($epsilon * PHP_FLOAT_EPSILON);
    }

    return $diff / ($absA + $absB) < $epsilon;
}

$x = 0.1 + 0.2;
$y = 0.3;

echo "Direct equality: " . ($x == $y ? 'true' : 'false') . "\n";
echo "NearlyEqual: " . (nearlyEqual($x, $y) ? 'true' : 'false') . "\n";
echo "Difference: " . ($x - $y) . "\n";

$nan = NAN;
$inf = INF;

echo "\nNAN == NAN: " . ($nan == $nan ? 'true' : 'false') . "\n";
echo "is_nan($nan): " . (is_nan($nan) ? 'true' : 'false') . "\n";
echo "INF == INF: " . ($inf == $inf ? 'true' : 'false') . "\n";

// Additional example: Small number comparison
$small = 1E-15;
echo "\nNearlyEqual($small, 0): " . (nearlyEqual($small, 0) ? 'true' : 'false') . "\n";

In PHP, using == for float comparisons is unreliable, as 0.1 + 0.2 != 0.3 due to tiny binary precision errors, often off by a small fraction like 5.5E-17. The nearlyEqual function compares floats within an epsilon (e.g., 1E-10), using PHP_FLOAT_EPSILON for near-zero cases, ensuring robust checks.

Special values like NAN and INF need care—NAN != NAN, so is_nan is required, while INF == INF holds true but requires context handling. For small numbers like 1E-15 versus 0, nearlyEqual succeeds where == fails, making it a practical solution. This method adapts to PHP's float behavior, enhancing comparison accuracy across applications.

Floating-Point for Financial Calculations

PHP's float type struggles with financial precision due to its binary nature. This section contrasts float issues with a precise integer-based workaround. Examples show interest calculations and monetary rounding in PHP effectively. These techniques ensure accuracy for financial tasks in PHP projects. For complex needs, consider extensions like BCMath instead.

<?php

$principal = 1000.00;
$interestRate = 0.05; // 5%
$years = 10;

// Using floating-point
$futureValueFloat = $principal * pow(1 + $interestRate, $years);
echo "Future value (floating-point): $" . round($futureValueFloat, 2) . "\n";

// Workaround with integer cents
$principalCents = 100000; // $1000.00 in cents
$futureValueCents = round($principalCents * pow(1 + $interestRate, $years));
$futureValue = $futureValueCents / 100;
echo "Accurate future value: $" . number_format($futureValue, 2) . "\n";

$payment = 123.456789;
echo "\nPayment to cents: " . round($payment, 2) . "\n";
echo "Payment rounded up: " . ceil($payment * 100) / 100 . "\n";
echo "Payment rounded down: " . floor($payment * 100) / 100 . "\n";

// Additional example: Tax calculation
$price = 19.99;
$taxRate = 0.08;
$tax = round($price * $taxRate, 2);
echo "\nTax on $$price: $$tax\n";

PHP's float type introduces errors in financial math, like compound interest on $1000 at 5% over 10 years, where tiny inaccuracies can appear in the result. Using cents as integers (e.g., 100000 for $1000) and converting back after calculation yields a precise $1628.89, avoiding float drift.

Functions like round($payment, 2), ceil, and floor with cents (e.g., 12345 cents to $123.45) ensure exact monetary values, vital for accounting integrity. A tax on $19.99 at 8% becomes exactly $1.60 with round, aligning with real-world expectations. For high-precision needs, PHP's BCMath extension offers an alternative to floats entirely.

Best Practices

Use PHP floats for general math but switch to integer cents or BCMath for financial accuracy. Avoid == for float comparisons, using nearlyEqual with epsilon instead for reliability. Apply round, ceil, or floor explicitly, and use number_format for clean output formatting. Check NAN with is_nan and INF with is_infinite to handle edge cases properly. These practices keep your PHP numeric code robust and error-free.

Source References

Learn more from these resources: PHP Float Documentation, PHP Math Functions, and BCMath Documentation.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all PHP tutorials.