PHP round(), floor() and ceil(): Rounding and Math

round($x) rounds to the nearest whole number, floor($x) always rounds down and ceil($x) always rounds up. Give round() a second argument for decimal places: round(3.14159, 2) is 3.14.

<?php
$price = 19.456;

echo round($price), "\n";     // nearest whole number
echo round($price, 2), "\n";  // 2 decimal places
echo floor($price), "\n";     // always down
echo ceil($price), "\n";      // always up

All three return a float, even when the value is whole. var_dump(round(5)) prints float(5), so cast with (int) when you need an integer.

Round to 2 decimal places

The second argument of round() is the precision. A positive number rounds to that many decimal places. A negative number rounds to the left of the decimal point, which is handy for rough figures like "about 1,200 visitors".

<?php
$n = 1234.5678;

echo round($n, 2), "\n";   // 2 decimals
echo round($n, 1), "\n";   // 1 decimal
echo round($n, -1), "\n";  // nearest ten
echo round($n, -2), "\n";  // nearest hundred

echo round(2.5), " ", round(-2.5), "\n";  // halves go away from zero
echo round(3.10, 2), "\n";                // trailing zero is not kept

round(3.10, 2) prints 3.1 because a float has no idea how many zeros you wanted. When the number is going on a page (prices, percentages), format it instead: number_format() turns 3.1 into "3.10" with number_format(3.1, 2), and sprintf('%.2f', $x) does the same.

Round half up, half down or half even

By default round() rounds a half away from zero, which is the 四捨五入 most people learned in school. The third argument picks a different rule for values exactly halfway between two numbers.

<?php
$values = [1.5, 2.5, -2.5];

foreach ($values as $v) {
    echo $v, ": ",
        round($v, 0, PHP_ROUND_HALF_UP), " up, ",
        round($v, 0, PHP_ROUND_HALF_DOWN), " down, ",
        round($v, 0, PHP_ROUND_HALF_EVEN), " even, ",
        round($v, 0, PHP_ROUND_HALF_ODD), " odd\n";
}

PHP_ROUND_HALF_EVEN is "banker's rounding": halves go to the nearest even number, so rounding many values does not drift upward over time. Accounting code often wants it.

floor and ceil with negative numbers

floor() moves toward negative infinity and ceil() toward positive infinity. With negative numbers that surprises people: floor(-3.5) is -4, not -3. If you want to cut off the decimals (切り捨て toward zero), cast to int instead.

<?php
foreach ([3.7, -3.7] as $x) {
    echo "x = $x\n";
    echo "  floor: ", floor($x), "\n";
    echo "  ceil:  ", ceil($x), "\n";
    echo "  (int): ", (int) $x, "\n";
}

// Pages needed for 23 items at 10 per page
echo ceil(23 / 10), " pages\n";

The pagination line is the classic use of ceil(): any leftover item still needs a page.

Integer division and modulo

/ returns a float when the division is not even, so 7 / 2 is 3.5. For whole-number division use intdiv(), which drops the remainder, and % for the remainder itself.

<?php
$minutes = 135;

$hours = intdiv($minutes, 60);
$rest = $minutes % 60;
echo "$minutes minutes = {$hours}h {$rest}m\n";

echo 7 / 2, "\n";
echo intdiv(-7, 2), "\n";   // truncates toward zero
echo -7 % 3, "\n";          // sign of the left operand
echo fmod(7.5, 2), "\n";    // remainder for floats

// Even or odd
foreach ([4, 7] as $n) {
    echo $n, $n % 2 === 0 ? " is even\n" : " is odd\n";
}

% converts both operands to integers first, so 7.5 % 2 is 1, and since PHP 8.1 it also prints Deprecated: Implicit conversion from float 7.5 to int loses precision. Use fmod() when the decimals matter. Dividing by zero with /, intdiv() or % throws a DivisionByZeroError in PHP 8, so check the divisor first when it comes from input.

Powers, roots, abs, max and min

** raises to a power (pow() does the same), sqrt() takes a square root and abs() removes the sign. max() and min() take either several arguments or one array.

<?php
echo 2 ** 10, "\n";       // 1024
echo 2 ** -1, "\n";       // 0.5
echo sqrt(144), "\n";     // 12
echo 27 ** (1 / 3), "\n"; // cube root
echo abs(-42), "\n";      // 42

$scores = [72, 95, 88, 61];
echo max($scores), " ", min($scores), "\n";
echo max(3, 9, 4), "\n";
echo array_sum($scores) / count($scores), "\n"; // average

// Clamp a value into the range 0 to 100
$volume = 140;
echo max(0, min(100, $volume)), "\n";

** is evaluated right to left, so 2 ** 3 ** 2 means 2 ** 9. The max(0, min(100, $x)) pair is the usual way to clamp a value between a lower and an upper limit. M_PI holds pi if you need it for circles.

Random numbers with random_int and rand

random_int($min, $max) returns a random integer with both ends included. The output changes on every run, so press Run a few times.

<?php
echo "Dice: ", random_int(1, 6), "\n";

// A 6-digit code, zero padded
printf("Code: %06d\n", random_int(0, 999999));

// Random element of an array
$colors = ['red', 'green', 'blue'];
echo "Color: ", $colors[array_rand($colors)], "\n";

// Random float between 0 and 1
echo "Float: ", random_int(0, PHP_INT_MAX) / PHP_INT_MAX, "\n";

Use random_int() for anything security related: login codes, tokens, password reset links. rand() and mt_rand() still work and accept the same ($min, $max) arguments, but their sequence can be predicted. For shuffling and picking with a secure source, PHP 8.2 added Random\Randomizer ($r->getInt(1, 6), $r->shuffleArray($a)).

Why floor() sometimes gives the wrong answer

Floats are stored in binary, and many decimal values (like 0.1) cannot be stored exactly. Most of the time printing hides that, but floor() and (int) do not round, they cut, and a value like 7.999999999 becomes 7.

<?php
$x = (0.1 + 0.7) * 10;

echo $x, "\n";            // looks like 8
var_dump($x);             // the real value
echo floor($x), "\n";     // 7, not 8
echo floor(round($x, 10)), "\n"; // round first, then floor

When you need exact decimals, as with money, store whole units (cents as integers: 1999 instead of 19.99) and divide only for display. Rounding to a sensible precision before floor() or ceil(), as in the last line, also fixes most cases.